diff --git a/.changeset/violet-melons-poke.md b/.changeset/violet-melons-poke.md
new file mode 100644
index 00000000..a845151c
--- /dev/null
+++ b/.changeset/violet-melons-poke.md
@@ -0,0 +1,2 @@
+---
+---
diff --git a/README.md b/README.md
index 349d38c8..abd54f10 100644
--- a/README.md
+++ b/README.md
@@ -39,10 +39,9 @@ https://github.com/SimplePDF/simplepdf-embed/assets/10613140/8924f018-6076-4e44-
 
 # Get started
 
-- 🧩 [Iframe bridge](./embed/README.md) - `@simplepdf/embed` (framework-free client to embed + programmatically drive the editor, with an AI SDK adapter, generated from the editor manifest; the React layer is `@simplepdf/react-embed-pdf`)
 - ⚛️ [React component](./react/README.md) - `@simplepdf/react-embed-pdf`
+- 🧩 [Iframe bridge](./embed/README.md) - `@simplepdf/embed` (framework-free client to embed + programmatically drive the editor, with an AI SDK adapter)
 - 🚀 [Script tag](./web/README.md) - `@simplepdf/web-embed-pdf`
-- 🛠 [Iframe API](./documentation/IFRAME.md) - `postMessage` events
 - 🤖 [SimplePDF Copilot](./copilot/README.md) - AI form-filling reference implementation
 
 # Features
diff --git a/copilot/README.md b/copilot/README.md
index 14a58fbe..041ec7a2 100644
--- a/copilot/README.md
+++ b/copilot/README.md
@@ -69,9 +69,9 @@ Browser
 - SimplePDF Copilot drives the editor through `postMessage` (focus a field, set a value, navigate, submit)
 - LLM streaming runs through your server via the Vercel AI SDK; you choose the provider
 - Tool calls are executed in the browser, against the iframe. Your server only proxies the chat stream.
-- **Voice input is different — it is a deliberate audio egress, on one of two paths.** Dictating into the composer records a short audio clip in the browser; recording starts when you tap the mic, and when you confirm it (✓) the clip is transcribed and the editable transcript drops into the textarea. Two routes, each named in the recorder before the audio is sent:
+- **Voice input is different, it is a deliberate audio egress, on one of two paths.** Dictating into the composer records a short audio clip in the browser; recording starts when you tap the mic, and when you confirm it (✓) the clip is transcribed and the editable transcript drops into the textarea. Two routes, each named in the recorder before the audio is sent:
   - **Demo (server):** when the deployment is in demo mode (operator keys configured), the clip uploads to `/api/transcribe`, which forwards it to OpenAI (`gpt-4o-transcribe`) and returns the transcript. So **audio leaves the browser to SimplePDF's server and then OpenAI** (the server keeps no audio, logs no transcript).
-  - **BYOK (browser-direct):** configure a Speech-to-Text provider (OpenAI or a custom OpenAI-compatible endpoint) in the model picker's Speech-to-Text tab; the clip is sent **directly from the browser to that endpoint, never to SimplePDF**. The key lives only in this browser's encrypted vault — a demo/reference feature (a browser-held key is exposed to anything on the page).
+  - **BYOK (browser-direct):** configure a Speech-to-Text provider (OpenAI or a custom OpenAI-compatible endpoint) in the model picker's Speech-to-Text tab; the clip is sent **directly from the browser to that endpoint, never to SimplePDF**. The key lives only in this browser's encrypted vault, a demo/reference feature (a browser-held key is exposed to anything on the page).
   - In both cases PDF bytes still stay on-device, and audio is sent only when you confirm the recording (never automatically). The recorder prompt names the actual audio recipient before you confirm: the **demo** prompt reads "Speak to SimplePDF Copilot…" (its server→OpenAI flow is the one described above, and "What is this demo?" documents it); the **BYOK** prompt reads "Speak to OpenAI…" or "Speak to <your endpoint>…" (sent directly to that provider, not to SimplePDF).
 
 ## Built with
@@ -119,19 +119,19 @@ In the running app, open the chat sidebar, click **Bring your own provider**, pa
 
 ### Run the demo without asking viewers for a key
 
-Asking every visitor to paste a provider key is friction-heavy. To skip that, put the deployment **in demo mode**: configure a single chat key/model/turn-cap plus a transcription key in your `.env`, and the server pays for chat + voice under your account for every visitor. There are no invite links — demo mode is simply on whenever both are configured. The chat opens already wired up and the Model Picker stays out of the way (visitors can still bring their own key to override).
+Asking every visitor to paste a provider key is friction-heavy. To skip that, put the deployment **in demo mode**: configure a single chat key/model/turn-cap plus a transcription key in your `.env`, and the server pays for chat + voice under your account for every visitor. There are no invite links, demo mode is simply on whenever both are configured. The chat opens already wired up and the Model Picker stays out of the way (visitors can still bring their own key to override).
 
 Demo mode requires **both**:
 
-- `DEMO_CHAT_API_KEY` + `DEMO_CHAT_MODEL` + `DEMO_RATE_LIMIT_TURNS` — the chat key, the model, and the per-IP turn cap.
-- `DEMO_STT_OPENAI_API_KEY` — the voice transcription key (transcription-only, never your chat key).
+- `DEMO_CHAT_API_KEY` + `DEMO_CHAT_MODEL` + `DEMO_RATE_LIMIT_TURNS`, the chat key, the model, and the per-IP turn cap.
+- `DEMO_STT_OPENAI_API_KEY`, the voice transcription key (transcription-only, never your chat key).
 
 Two chat models are supported on the demo path:
 
 - Anthropic Claude Haiku 4.5 (`DEMO_CHAT_MODEL=anthropic_haiku_4_5`)
 - DeepSeek V4 Flash (`DEMO_CHAT_MODEL=deepseek_v4_flash`)
 
-Leave the demo vars unset and the deployment runs **BYOK-only**: every visitor brings their own key via the Model Picker. Note: with no invite gating, demo mode is open to anyone who can reach the page, so the **per-IP turn cap (`DEMO_RATE_LIMIT_TURNS`) is the cost control** — size it accordingly. See [`.env.example`](./.env.example) for the exact vars.
+Leave the demo vars unset and the deployment runs **BYOK-only**: every visitor brings their own key via the Model Picker. Note: with no invite gating, demo mode is open to anyone who can reach the page, so the **per-IP turn cap (`DEMO_RATE_LIMIT_TURNS`) is the cost control**, size it accordingly. See [`.env.example`](./.env.example) for the exact vars.
 
 ### Voice input (dictation)
 
@@ -170,9 +170,9 @@ The iframe will refuse to load on origins that aren't whitelisted, so add your s
 
 For multi-container deployments (or any deploy where you want per-IP rate-limit counters to survive restarts), set `REDIS_URL` to a Redis-protocol-compatible instance (Valkey on DO Managed Caching is the canonical fit at $15/mo). When `REDIS_URL` is set, `IP_HASH_SALT` is also required (the server refuses to boot otherwise) so the persisted hashes can't be brute-forced against a leaked snapshot. Generate one with `openssl rand -hex 32`. Without `REDIS_URL`, counters live in memory per container, which is fine for local dev, single-instance hosts, or BYOK-only deployments.
 
-> **DO App Platform gotcha — wire the database from the App side.** If you're using DO Managed Caching, **don't** start by adding a Trusted Source on the cluster. Open your App Platform app → **Settings** → **App Spec** → **+ Create or Attach Database** → pick the existing cluster (or provision a new one). DO then auto-handles trusted sources, VPC routing, and injects the connection string into the app's env. Wiring from the cluster side leaves the App on a public-egress IP that can't be matched to a Trusted Source, and you'll get `ETIMEDOUT` even with the source allowlisted. Same shape as adding a custom domain: it has to be done from the App, not from the resource.
+> **DO App Platform gotcha, wire the database from the App side.** If you're using DO Managed Caching, **don't** start by adding a Trusted Source on the cluster. Open your App Platform app → **Settings** → **App Spec** → **+ Create or Attach Database** → pick the existing cluster (or provision a new one). DO then auto-handles trusted sources, VPC routing, and injects the connection string into the app's env. Wiring from the cluster side leaves the App on a public-egress IP that can't be matched to a Trusted Source, and you'll get `ETIMEDOUT` even with the source allowlisted. Same shape as adding a custom domain: it has to be done from the App, not from the resource.
 >
-> Once attached, DO injects the connection string as `DATABASE_URL` (the bind variable's default name) — **rename it** to `REDIS_URL` in the App's env vars, OR add a separate `REDIS_URL` entry whose value is `${cluster-name.DATABASE_URL}` to alias it. The copilot server only reads `REDIS_URL`.
+> Once attached, DO injects the connection string as `DATABASE_URL` (the bind variable's default name), **rename it** to `REDIS_URL` in the App's env vars, OR add a separate `REDIS_URL` entry whose value is `${cluster-name.DATABASE_URL}` to alias it. The copilot server only reads `REDIS_URL`.
 
 #### One-click deploy to DigitalOcean
 
@@ -219,9 +219,9 @@ The chat sidebar advertises these tools to the model. Each runs inside the ifram
 | `setFieldValue` | Write a value into a field |
 | `selectTool` | Switch the editor toolbar (`TEXT`, `COMB_TEXT`, `CHECKBOX`, `SIGNATURE`, `PICTURE`) |
 | `goTo` | Navigate to a specific page (1-indexed) |
-| `movePage` | Reorder a visible page (`fromPage` → `toPage`, both 1-indexed). Destructive — only fired on explicit user request |
-| `deletePages` | Remove visible pages and their fields (last remaining page can't be deleted). Destructive — only fired on explicit user request |
-| `rotatePage` | Rotate a visible page 90° clockwise per call. Destructive — only fired on explicit user request |
+| `movePage` | Reorder a visible page (`fromPage` → `toPage`, both 1-indexed). Destructive, only fired on explicit user request |
+| `deletePages` | Remove visible pages and their fields (last remaining page can't be deleted). Destructive, only fired on explicit user request |
+| `rotatePage` | Rotate a visible page 90° clockwise per call. Destructive, only fired on explicit user request |
 | `submit` (Pro mode) / `download` (demo mode) | Finalize: real iframe `SUBMIT` on a Pro fork (lands in BYOS + webhooks) vs. an in-browser `DOWNLOAD` on the hosted demo |
 
 Tool input + output schemas + the bridge that posts these events into the iframe live in the [`@simplepdf/embed`](../embed) package (generated from the editor contract); copilot's tool catalogue + middleware live in `src/lib/tools/` (`definitions.ts`, `middleware.ts`). System prompt: `src/server/tools.ts`. Public iframe contract these tools exercise: [`documentation/IFRAME.md`](../documentation/IFRAME.md).
@@ -245,7 +245,7 @@ The architecture is deliberate:
 - **Document data stays in the browser.** SimplePDF processes PDFs client-side. The iframe never uploads document bytes to SimplePDF.
 - **Chat traffic flows through your server.** You control the provider, the keys, the logs, and any RAG / internal data layered in.
 - **Submission is direct to your storage.** On Premium with [Bring Your Own Storage](https://simplepdf.com/pricing) (S3, Azure Blob, or SharePoint), completed PDFs upload from the browser to your bucket, never to SimplePDF servers.
-- **Voice input is the one exception, and it is opt-in.** Dictation sends the recorded audio clip out of the browser — unlike PDF bytes, dictated audio (which can contain PII/PHI) leaves the device. Two routes, each disclosed before recording: the **demo** route uploads to SimplePDF's server and on to OpenAI (the server keeps no audio and logs no transcript text — only an IP hash, byte size, and elapsed time); the **BYOK** route sends audio **directly to the user's chosen provider, never to SimplePDF** (SimplePDF makes no retention claim for user-selected providers — that's the provider's policy). Audio is sent only on an explicit Record.
+- **Voice input is the one exception, and it is opt-in.** Dictation sends the recorded audio clip out of the browser, unlike PDF bytes, dictated audio (which can contain PII/PHI) leaves the device. Two routes, each disclosed before recording: the **demo** route uploads to SimplePDF's server and on to OpenAI (the server keeps no audio and logs no transcript text, only an IP hash, byte size, and elapsed time); the **BYOK** route sends audio **directly to the user's chosen provider, never to SimplePDF** (SimplePDF makes no retention claim for user-selected providers, that's the provider's policy). Audio is sent only on an explicit Record.
 
 ### Using the demo account
 
diff --git a/documentation/IFRAME.md b/documentation/IFRAME.md
index bbd7d7be..a62218f4 100644
--- a/documentation/IFRAME.md
+++ b/documentation/IFRAME.md
@@ -2,13 +2,13 @@
 
 SimplePDF Embed [React](../react/README.md) and [Web](../web/README.md) integrate `SimplePDF` in a single line of code by displaying the editor in a modal.
 
-**For more control** — embedding the editor inline (e.g. in a `div`), or driving it programmatically — read on.
+**For more control**, embedding the editor inline (e.g. in a `div`), or driving it programmatically, read on.
 
 ## The iframe URL vs. programmatic control
 
 Pointing an `<iframe src>` at the editor (below) gives you the **full editor, with your account's branding**, in zero JavaScript. What it does **not** give you is **programmatic control**: you can't read a field, jump to a page, prefill values, submit, or let an AI agent fill and read the document on the user's behalf.
 
-For that, drive the same iframe with the typed [`@simplepdf/embed`](#iframe-communication) client — see [Iframe Communication](#iframe-communication).
+For that, drive the same iframe with the typed [`@simplepdf/embed`](#iframe-communication) client, see [Iframe Communication](#iframe-communication).
 
 ## With a SimplePDF account (to collect customers' submissions)
 
@@ -96,7 +96,7 @@ See [Data Privacy & companyIdentifier](../README.md#data-privacy--companyidentif
 
 _Programmatic control is only available with a SimplePDF account_
 
-The iframe communicates over the `postMessage` API. Use **[`@simplepdf/embed`](../embed/README.md)** — a zero-dependency client that drives the editor over the iframe for you, **generated from the editor contract** so it can't drift. It wraps everything for you: request/response correlation, timeouts, the editor-ready / document-loaded lifecycle, typed events, and the closed error model. Methods + arguments are camelCase; the editor's `snake_case` wire is handled behind the scenes. (If you'd rather add no dependency, the raw protocol is documented under [Wire shape](#wire-shape).)
+The iframe communicates over the `postMessage` API. Use **[`@simplepdf/embed`](../embed/README.md)**, a zero-dependency client that drives the editor over the iframe for you, **generated from the editor contract** so it can't drift. It wraps everything for you: request/response correlation, timeouts, the editor-ready / document-loaded lifecycle, typed events, and the closed error model. Methods + arguments are camelCase; the editor's `snake_case` wire is handled behind the scenes. (If you'd rather add no dependency, the raw protocol is documented under [Wire shape](#wire-shape).)
 
 The examples below go from the simplest embed to full programmatic and agentic control. `createEmbed` either **creates** the iframe inside a container you provide, or **attaches** to an `<iframe>` you render.
 
@@ -110,8 +110,8 @@ The examples below go from the simplest embed to full programmatic and agentic c
 import { createEmbed } from "@simplepdf/embed";
 
 const embed = createEmbed({
-  target: "#editor", // a container — the iframe is created inside it
-  companyIdentifier: "acme", // your <companyIdentifier>.simplepdf.com — use "embed" for the free editor
+  target: "#editor", // a container, the iframe is created inside it
+  companyIdentifier: "acme", // your <companyIdentifier>.simplepdf.com, use "embed" for the free editor
   document: { url: "https://example.com/form.pdf" },
 });
 
@@ -161,7 +161,7 @@ See the [`@simplepdf/embed` README](../embed/README.md#actions) for the full met
 
 ### 4. Fill and read a document (what an agent does for you)
 
-"Fill and read this document for me" is just these operations in sequence — read the fields, fill one, then walk the user to a signature: navigate to its page, focus the field, and open the signature tool.
+"Fill and read this document for me" is just these operations in sequence, read the fields, fill one, then walk the user to a signature: navigate to its page, focus the field, and open the signature tool.
 
 ```ts
 // read
@@ -177,23 +177,23 @@ await embed.actions.focusField({ fieldId: "f_signature" });
 await embed.actions.selectTool({ tool: "SIGNATURE" });
 ```
 
-An AI agent does exactly this — the next section exposes these operations as tools the model calls.
+An AI agent does exactly this, the next section exposes these operations as tools the model calls.
 
 ### 5. Drive the editor from an LLM (agentic)
 
 The same operations are exposed as [Vercel AI SDK](https://sdk.vercel.ai) tools:
 
 ```ts
-// server — execute-less tool definitions for streamText / generateText
+// server: execute-less tool definitions for streamText / generateText
 import { simplePDFToolDefinitions } from "@simplepdf/embed/ai-sdk";
 streamText({ model, tools: simplePDFToolDefinitions() });
 
-// browser — run the model's tool calls against the live editor
+// browser: run the model's tool calls against the live editor
 import { createSimplePDFExecutor } from "@simplepdf/embed/ai-sdk";
 const execute = createSimplePDFExecutor({ embed });
 ```
 
-In React, `@simplepdf/react-embed-pdf/ai-sdk`'s `useEmbedTools(embedRef)` is the same registry pre-bound to the live editor — drop it straight into `useChat({ tools })`.
+In React, `@simplepdf/react-embed-pdf/ai-sdk`'s `useEmbedTools(embedRef)` is the same registry pre-bound to the live editor, drop it straight into `useChat({ tools })`.
 
 ---
 
@@ -201,9 +201,9 @@ In React, `@simplepdf/react-embed-pdf/ai-sdk`'s `useEmbedTools(embedRef)` is the
 
 The single source of truth for the available operations and events can be found at **[`https://simplepdf.com/embed/json`](https://simplepdf.com/embed/json)**.
 
-It describes every operation (its `request_type`, input/output JSON Schema, and per-operation error codes), the outbound events, the supported locales, and the **complete closed set of error codes** — each `code` carrying a plain-language description of its meaning. It is the iframe / `postMessage` counterpart to the REST API's OpenAPI spec at [`/api/json`](https://simplepdf.com/api/json).
+It describes every operation (its `request_type`, input/output JSON Schema, and per-operation error codes), the outbound events, the supported locales, and the **complete closed set of error codes**, each `code` carrying a plain-language description of its meaning. It is the iframe / `postMessage` counterpart to the REST API's OpenAPI spec at [`/api/json`](https://simplepdf.com/api/json).
 
-- **Programmatic access (recommended):** [`@simplepdf/embed`](https://github.com/SimplePDF/simplepdf-embed/tree/main/embed) generates its client, zod schemas (`/schemas`), and agentic tool registry (`/tools`, `/ai-sdk`) from this exact contract — use the package and you never read the raw spec.
+- **Programmatic access (recommended):** [`@simplepdf/embed`](https://github.com/SimplePDF/simplepdf-embed/tree/main/embed) generates its client, zod schemas (`/schemas`), and agentic tool registry (`/tools`, `/ai-sdk`) from this exact contract, use the package and you never read the raw spec.
 - **Agents / LLMs:** point the model at `/embed/json` (or `@simplepdf/embed/ai-sdk`) to discover and drive the editor programmatically.
 
 ### Wire shape
diff --git a/embed/README.md b/embed/README.md
index 76aad2cd..cf56398e 100644
--- a/embed/README.md
+++ b/embed/README.md
@@ -1,37 +1,8 @@
 # @simplepdf/embed
 
-Embed and programmatically drive the [SimplePDF](https://simplepdf.com) editor over its iframe / `postMessage` bridge — from any framework, with zero runtime dependencies.
+Embed and programmatically drive the [SimplePDF](https://simplepdf.com) editor over its iframe / `postMessage` bridge, from any framework, with zero runtime dependencies.
 
-Types, schemas, and tools are **generated from a pinned copy of the editor's published manifest** ([`/embed/json`](https://simplepdf.com/embed/json)), so the client cannot drift from the contract.
-
-> Using React? Use [`@simplepdf/react-embed-pdf`](../react) — `<EmbedPDF>` + `useEmbed` (+ the agentic `tools`), built on this core.
-
-## Install
-
-```bash
-npm install @simplepdf/embed
-```
-
-Zero runtime dependencies at the root. `zod` is an optional peer, needed only by the `/schemas`, `/tools`, and `/ai-sdk` subpaths. `/ai-sdk` produces values for the Vercel AI SDK but never imports `ai`; bring your own.
-
-## Subpaths
-
-| Import | Purpose | Peer |
-| --- | --- | --- |
-| `@simplepdf/embed` | `createEmbed`, the `Embed` handle, the closed error model + `BridgeResult` types, `unwrap`, `NOOP_LOGGER` | none |
-| `@simplepdf/embed/protocol` | wire operation/event constants | none |
-| `@simplepdf/embed/schemas` | zod schema for every operation input | `zod` |
-| `@simplepdf/embed/tools` | SDK-agnostic agentic tool registry + `routeToolCall` + `isSimplePDFToolName` | `zod` |
-| `@simplepdf/embed/ai-sdk` | `simplePDFToolDefinitions()` (server) + `createSimplePDFExecutor({ embed })` (browser) for the Vercel AI SDK | `zod` |
-
-## Conventions
-
-The SDK is **camelCase** (the JS/TS idiom); the editor's snake_case wire stays behind a transform the bridge owns, so you never type it:
-
-- **Methods, their arguments + results, and the agentic tool names/args are camelCase**: `embed.actions.getFields()`, `embed.actions.setFieldValue({ fieldId, value })`, `embed.actions.submit({ downloadCopy })`. They are generated from the contract and lowered to the snake_case wire (`field_id`, `download_copy`) at the `postMessage` boundary — automatically.
-- **Events are the one exception — delivered VERBATIM**: `embed.events.on(type, handler)` hands the handler the editor's outbound payload unchanged (snake_case fields like `document_id`), so events stay byte-for-byte compatible with the published manifest and with `@simplepdf/react-embed-pdf`'s existing `onEmbedEvent`.
-
-The editor owns all validation and FIFO ordering; the bridge just posts, correlates by `request_id`, and times out a dead iframe. Every method resolves to a `BridgeResult<T>` and never throws; only construction errors (bad config) throw, synchronously.
+> Using React? Use [`@simplepdf/react-embed-pdf`](../react): `<EmbedPDF>` + `useEmbed` (+ the agentic `tools`), built on this core.
 
 ## Quick start
 
@@ -62,6 +33,40 @@ if (fields.success) {
 
 The handle has three groups: **`embed.actions`** (operations), **`embed.events`** (subscriptions), **`embed.lifecycle`** (teardown).
 
+## Agentic / tool-calling
+
+Drive the editor from an LLM. Tool names + inputs are the same camelCase as the SDK; the bridge lowers them to the wire, so the model generates exactly what `routeToolCall` (and React's `useEmbedTools`) dispatch.
+
+```ts
+// server (Vercel AI SDK): execute-less tool definitions
+import { simplePDFToolDefinitions } from '@simplepdf/embed/ai-sdk'
+streamText({ model, tools: simplePDFToolDefinitions() })
+
+// browser: a bridge-bound executor for onToolCall
+import { createSimplePDFExecutor } from '@simplepdf/embed/ai-sdk'
+const execute = createSimplePDFExecutor({ embed })
+```
+
+`@simplepdf/embed/tools` exposes the same registry SDK-agnostically (`routeToolCall`, `isSimplePDFToolName`). In React, `@simplepdf/react-embed-pdf/ai-sdk`'s `useEmbedTools(embedRef)` is the same registry pre-bound to the live editor.
+
+## Install
+
+```bash
+npm install @simplepdf/embed
+```
+
+Zero runtime dependencies at the root. `zod` is an optional peer, needed only by the `/schemas`, `/tools`, and `/ai-sdk` subpaths. `/ai-sdk` produces values for the Vercel AI SDK but never imports `ai`; bring your own.
+
+## Subpaths
+
+| Import | Purpose | Peer |
+| --- | --- | --- |
+| `@simplepdf/embed` | `createEmbed`, the `Embed` handle, the closed error model + `BridgeResult` types, `unwrap`, `NOOP_LOGGER` | none |
+| `@simplepdf/embed/protocol` | wire operation/event constants | none |
+| `@simplepdf/embed/schemas` | zod schema for every operation input | `zod` |
+| `@simplepdf/embed/tools` | SDK-agnostic agentic tool registry + `routeToolCall` + `isSimplePDFToolName` | `zod` |
+| `@simplepdf/embed/ai-sdk` | `simplePDFToolDefinitions()` (server) + `createSimplePDFExecutor({ embed })` (browser) for the Vercel AI SDK | `zod` |
+
 ## Where the editor goes
 
 One function. It does the right thing based on what `target` points at:
@@ -103,7 +108,7 @@ createEmbed({ target, companyIdentifier: 'acme', document: { dataUrl: 'data:appl
 createEmbed({ target, companyIdentifier: 'acme', document: { file: pdfFileOrBlob } })
 ```
 
-- **`url`**: any `http(s)` URL. Fetched from your page first (50 MB cap); on CORS / size / network failure it falls back to the editor's `?open` loader, so CORS-restricted public URLs still load. `user:pass@` credentials are allowed (they route via `?open`). A **SimplePDF documents URL** on your base-domain family (e.g. `https://acme.simplepdf.com/documents/<id>?prefill=<id>`) is navigated to directly — the editor loads + prefills the stored document itself (your `context` is carried through).
+- **`url`**: any `http(s)` URL. Fetched from your page first (50 MB cap); on CORS / size / network failure it falls back to the editor's `?open` loader, so CORS-restricted public URLs still load. `user:pass@` credentials are allowed (they route via `?open`). A **SimplePDF documents URL** on your base-domain family (e.g. `https://acme.simplepdf.com/documents/<id>?prefill=<id>`) is navigated to directly, so the editor loads + prefills the stored document itself (your `context` is carried through).
 - **`file`**: a `File` (e.g. from `<input type="file">`) or any `Blob`. Converted for you, no `FileReader`.
 - **`dataUrl`**: a `data:` URL string.
 
@@ -119,7 +124,7 @@ if (r.success) r.data.fields // typed FieldRecord[]
 else r.error.code // a closed BridgeErrorCode
 ```
 
-`embed.actions.*` — method names + arguments are camelCase (the snake_case wire is generated + transformed for you; [`/embed/json`](https://simplepdf.com/embed/json) or `@simplepdf/embed/schemas` carry every field):
+`embed.actions.*`: method names + arguments are camelCase (the snake_case wire is generated + transformed for you; [`/embed/json`](https://simplepdf.com/embed/json) or `@simplepdf/embed/schemas` carry every field):
 
 ```ts
 await embed.actions.loadDocument({ dataUrl, name, page })
@@ -138,7 +143,7 @@ await embed.actions.download()
 
 Full set: `createField`, `deleteFields`, `deletePages`, `detectFields`, `download`, `focusField`, `getDocumentContent`, `getFields`, `goTo`, `loadDocument`, `movePage`, `rotatePage`, `selectTool`, `setFieldValue`, `submit`.
 
-**"Fill and read this document for me"** is just these operations in sequence — exactly what the agentic tools expose to a model:
+**"Fill and read this document for me"** is just these operations in sequence, exactly what the agentic tools expose to a model:
 
 ```ts
 const fields = await embed.actions.getFields() // read
@@ -151,7 +156,7 @@ await embed.actions.selectTool({ tool: 'SIGNATURE' })
 
 ## Events
 
-`embed.events.on(type, handler)` subscribes to one editor event and hands the handler that event's payload VERBATIM (snake_case) — the stable, established contract. It returns an unsubscribe function:
+`embed.events.on(type, handler)` subscribes to one editor event and hands the handler that event's payload VERBATIM (snake_case), the stable, established contract. It returns an unsubscribe function:
 
 ```ts
 const off = embed.events.on('SUBMISSION_SENT', (data) => {
@@ -159,7 +164,7 @@ const off = embed.events.on('SUBMISSION_SENT', (data) => {
 })
 off() // unsubscribe (all subscriptions also clear on lifecycle.dispose())
 
-// The full set — each handler receives that event's typed payload:
+// The full set, each handler receives that event's typed payload:
 embed.events.on('EDITOR_READY', () => {})
 embed.events.on('DOCUMENT_LOADED', (data) => data.document_id)
 embed.events.on('PAGE_FOCUSED', (data) => data) // { previous_page, current_page, total_pages }
@@ -168,7 +173,7 @@ embed.events.on('SUBMISSION_SENT', (data) => data) // { document_id, submission_
 
 ## Lifecycle
 
-`embed.lifecycle.dispose()` tears down the bridge (removes the iframe in the container case; clears subscriptions + pending requests). Readiness — `booting → editorReady → documentLoaded` — is observable via the `EDITOR_READY` / `DOCUMENT_LOADED` events above.
+`embed.lifecycle.dispose()` tears down the bridge (removes the iframe in the container case; clears subscriptions + pending requests). Readiness (`booting → editorReady → documentLoaded`) is observable via the `EDITOR_READY` / `DOCUMENT_LOADED` events above.
 
 ## Errors
 
@@ -186,22 +191,6 @@ const { fields } = unwrap(await embed.actions.getFields())
 
 Use [`@simplepdf/react-embed-pdf`](../react): `<EmbedPDF>` renders the iframe and `useEmbed()` returns `{ embedRef, actions }`; its opt-in `/ai-sdk` subpath adds `useEmbedTools(embedRef)` for the AI SDK. It is built on this core.
 
-## Agentic / tool-calling
-
-Drive the editor from an LLM. Tool names + inputs are the same camelCase as the SDK; the bridge lowers them to the wire, so the model generates exactly what `routeToolCall` (and React's `useEmbedTools`) dispatch.
-
-```ts
-// server (Vercel AI SDK): execute-less tool definitions
-import { simplePDFToolDefinitions } from '@simplepdf/embed/ai-sdk'
-streamText({ model, tools: simplePDFToolDefinitions() })
-
-// browser: a bridge-bound executor for onToolCall
-import { createSimplePDFExecutor } from '@simplepdf/embed/ai-sdk'
-const execute = createSimplePDFExecutor({ embed })
-```
-
-`@simplepdf/embed/tools` exposes the same registry SDK-agnostically (`routeToolCall`, `isSimplePDFToolName`). In React, `@simplepdf/react-embed-pdf/ai-sdk`'s `useEmbedTools(embedRef)` is the same registry pre-bound to the live editor.
-
 ## Reference: the editor contract (the spec)
 
 The single source of truth for the available operations and events can be found at **[`https://simplepdf.com/embed/json`](https://simplepdf.com/embed/json)**.
diff --git a/react/README.md b/react/README.md
index 3b1ea60c..d12b067c 100644
--- a/react/README.md
+++ b/react/README.md
@@ -36,7 +36,7 @@ Easily add [SimplePDF](https://simplepdf.com) to your React app, by using the `E
 npm install @simplepdf/react-embed-pdf
 ```
 
-The package root (`<EmbedPDF>`, `useEmbed`) has no `zod` dependency. Only the agentic tools — the opt-in [`@simplepdf/react-embed-pdf/ai-sdk`](#agentic--useembedtools-vercel-ai-sdk) subpath — need `zod` (a peer). Install it alongside if you use them (npm 7+ adds it automatically; pnpm / Yarn PnP users must add it explicitly):
+The package root (`<EmbedPDF>`, `useEmbed`) has no `zod` dependency. Only the agentic tools, the opt-in [`@simplepdf/react-embed-pdf/ai-sdk`](#agentic--useembedtools-vercel-ai-sdk) subpath, need `zod` (a peer). Install it alongside if you use them (npm 7+ adds it automatically; pnpm / Yarn PnP users must add it explicitly):
 
 ```sh
 npm install zod
@@ -80,7 +80,7 @@ import { EmbedPDF } from '@simplepdf/react-embed-pdf';
 
 ### Modal mode
 
-Modal is the default — just wrap any HTML element and the editor opens in a modal on the user's click. You don't need the `mode` prop; pass `mode="modal"` only if you want to be explicit.
+Modal is the default, just wrap any HTML element and the editor opens in a modal on the user's click. You don't need the `mode` prop; pass `mode="modal"` only if you want to be explicit.
 
 ```jsx
 import { EmbedPDF } from "@simplepdf/react-embed-pdf";
@@ -143,7 +143,7 @@ _Some actions require a SimplePDF account. See [Retrieving PDF Data](../README.m
 
 `const { embedRef, actions } = useEmbed();` drives the editor imperatively (`actions`); the agentic `tools` come from the opt-in `@simplepdf/react-embed-pdf/ai-sdk` subpath (`useEmbedTools(embedRef)`). Attach `embedRef` to the component: `<EmbedPDF ref={embedRef} mode="inline" … />`.
 
-#### Imperative — `actions`
+#### Imperative: `actions`
 
 Actions are camelCase (the editor's snake_case wire is transformed for you). `useEmbed().actions` exposes the FULL editor surface; the most common:
 
@@ -194,7 +194,7 @@ const Editor = () => {
 };
 ```
 
-**"Fill and read this document for me"** is just these actions in sequence — exactly what an AI agent calls on your behalf (read the fields, fill one, then walk the user to a signature: navigate to its page, focus it, open the signature tool):
+**"Fill and read this document for me"** is just these actions in sequence, exactly what an AI agent calls on your behalf (read the fields, fill one, then walk the user to a signature: navigate to its page, focus it, open the signature tool):
 
 ```jsx
 const { embedRef, actions } = useEmbed();
@@ -206,9 +206,9 @@ await actions.focusField({ fieldId: 'f_signature' });
 await actions.selectTool({ tool: 'SIGNATURE' });
 ```
 
-#### Agentic — `useEmbedTools` (Vercel AI SDK)
+#### Agentic: `useEmbedTools` (Vercel AI SDK)
 
-The agentic tools live in the opt-in `@simplepdf/react-embed-pdf/ai-sdk` subpath — importing it is what pulls `zod`, so a non-agentic app never loads it (mirroring `@simplepdf/embed`'s `/ai-sdk`). `useEmbedTools(embedRef)` binds the SimplePDF tool set to the live editor — drop it straight into the AI SDK and an LLM can drive the editor:
+The agentic tools live in the opt-in `@simplepdf/react-embed-pdf/ai-sdk` subpath, importing it is what pulls `zod`, so a non-agentic app never loads it (mirroring `@simplepdf/embed`'s `/ai-sdk`). `useEmbedTools(embedRef)` binds the SimplePDF tool set to the live editor, drop it straight into the AI SDK and an LLM can drive the editor:
 
 ```jsx
 import { useChat } from '@ai-sdk/react';
@@ -223,7 +223,7 @@ const CopilotEditor = () => {
 };
 ```
 
-For server-side tool definitions (execute-less, for `streamText`), import `simplePDFToolDefinitions` from `@simplepdf/react-embed-pdf/ai-sdk`. `embedRef.current` is the flat editor-actions handle — every camelCase operation, with the deprecated `selectTool` / `submit` overloads; subscribe to editor events via the `onEmbedEvent` prop. (The framework-free `@simplepdf/embed` core exposes the grouped `embed.actions` / `embed.events` / `embed.lifecycle` handle for non-React use.)
+For server-side tool definitions (execute-less, for `streamText`), import `simplePDFToolDefinitions` from `@simplepdf/react-embed-pdf/ai-sdk`. `embedRef.current` is the flat editor-actions handle, every camelCase operation, with the deprecated `selectTool` / `submit` overloads; subscribe to editor events via the `onEmbedEvent` prop. (The framework-free `@simplepdf/embed` core exposes the grouped `embed.actions` / `embed.events` / `embed.lifecycle` handle for non-React use.)
 
 See [Retrieving PDF Data](../README.md#retrieving-pdf-data) for text extraction, downloading, and server-side storage options.