fix tests

.changeset/README.md

@@ -0,0 +1,13 @@
+# Changesets
+
+Hello and welcome! This folder has been automatically generated by `@changesets/cli`, a build tool that works
+with multi-package repos, or single-package repos to help you version and publish your code. You can
+find the full documentation for it [in the repository](https://github.com/changesets/changesets).
+
+## Adding a changeset
+
+To add a changeset, run `pnpm changeset` in the root of the repository. This will prompt you to select
+which packages have changed and what type of version bump (major, minor, or patch) should be applied.
+
+All `@json-render/*` packages are versioned together -- a changeset for any one of them will bump all
+packages to the same version.

.changeset/config.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://unpkg.com/@changesets/config@3.1.1/schema.json",
+  "changelog": "@changesets/cli/changelog",
+  "commit": false,
+  "fixed": [
+    [
+      "@json-render/core",
+      "@json-render/react",
+      "@json-render/react-native",
+      "@json-render/remotion",
+      "@json-render/codegen"
+    ]
+  ],
+  "linked": [],
+  "access": "public",
+  "baseBranch": "main",
+  "updateInternalDependencies": "patch",
+  "privatePackages": {
+    "version": false,
+    "tag": false
+  }
+}

.cursor/mcp.json

@@ -1,8 +0,0 @@
-{
-  "mcpServers": {
-    "json-render": {
-      "command": "npx",
-      "args": ["tsx", "examples/mcp/server.ts", "--stdio"]
-    }
-  }
-}

.github/workflows/ci.yml

@@ -13,76 +13,36 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  version-sync:
-    name: Version Sync Check
+  ci:
+    name: Lint, Type Check & Build
     runs-on: ubuntu-latest
+
     steps:
-      - uses: actions/checkout@v4
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9.0.0
+
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version-file: .node-version
-      - name: Check version sync
-        run: node scripts/check-version-sync.js
+          node-version: 20
+          cache: "pnpm"
 
-  lint:
-    name: Lint
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version-file: .node-version
-          cache: pnpm
-      - run: pnpm install --frozen-lockfile
-      - run: pnpm lint
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
 
-  test:
-    name: Test
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version-file: .node-version
-          cache: pnpm
-      - run: pnpm install --frozen-lockfile
-      - name: Build packages
-        run: pnpm turbo run build --filter='./packages/*'
-      - run: pnpm test
+      - name: Lint
+        run: pnpm lint
 
-  docs:
-    name: Docs (${{ matrix.environment }})
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        environment: [production, preview]
-    env:
-      VERCEL_ENV: ${{ matrix.environment }}
-      DOCS_EXPECT_NOINDEX: ${{ matrix.environment == 'preview' && '1' || '0' }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version-file: .node-version
-          cache: pnpm
-      - run: pnpm install --frozen-lockfile
-      - run: pnpm turbo run build --filter='web^...'
-      - run: pnpm --filter web build
-      - run: pnpm --filter web test:routes
+      - name: Type check
+        run: pnpm type-check
 
-  typecheck:
-    name: Type Check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version-file: .node-version
-          cache: pnpm
-      - run: pnpm install --frozen-lockfile
-      - run: pnpm type-check
+      - name: Test
+        run: pnpm test
+
+      - name: Build
+        run: pnpm build

.github/workflows/release.yml

@@ -6,74 +6,21 @@ on:
       - main
   workflow_dispatch:
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: false
+concurrency: ${{ github.workflow }}-${{ github.ref }}
 
 permissions:
-  contents: read
+  contents: write
+  pull-requests: write
 
 jobs:
-  check-release:
-    name: Check for new version
+  release:
+    name: Release
     runs-on: ubuntu-latest
-    timeout-minutes: 5
-    outputs:
-      should_release: ${{ steps.check.outputs.should_release }}
-      needs_github_release: ${{ steps.check.outputs.needs_github_release }}
-      version: ${{ steps.check.outputs.version }}
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
         with:
-          node-version-file: .node-version
-
-      - name: Compare package.json version to npm and check GitHub release
-        id: check
-        run: |
-          LOCAL_VERSION=$(node -p "require('./packages/core/package.json').version")
-          echo "Local version: $LOCAL_VERSION"
-
-          NPM_VERSION=$(npm view @json-render/core version 2>/dev/null || echo "0.0.0")
-          echo "npm version: $NPM_VERSION"
-
-          if [ "$LOCAL_VERSION" != "$NPM_VERSION" ]; then
-            echo "Version changed: $NPM_VERSION -> $LOCAL_VERSION"
-            echo "should_release=true" >> "$GITHUB_OUTPUT"
-            echo "needs_github_release=true" >> "$GITHUB_OUTPUT"
-          else
-            echo "Version unchanged on npm, skipping build and publish"
-            echo "should_release=false" >> "$GITHUB_OUTPUT"
-
-            TAG="v$LOCAL_VERSION"
-            if gh release view "$TAG" &>/dev/null; then
-              echo "GitHub release $TAG exists"
-              echo "needs_github_release=false" >> "$GITHUB_OUTPUT"
-            else
-              echo "GitHub release $TAG is missing, will create it"
-              echo "needs_github_release=true" >> "$GITHUB_OUTPUT"
-            fi
-          fi
-          echo "version=$LOCAL_VERSION" >> "$GITHUB_OUTPUT"
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  publish:
-    name: Publish to npm
-    needs: check-release
-    if: needs.check-release.outputs.should_release == 'true'
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    environment: Release
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
+          fetch-depth: 0
 
       - name: Install pnpm
         uses: pnpm/action-setup@v4
@@ -81,86 +28,20 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version-file: .node-version
+          node-version: 20
           cache: pnpm
           registry-url: "https://registry.npmjs.org"
 
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
 
-      - name: Build packages
-        run: pnpm run build
-
-      - name: Publish all public packages
-        run: |
-          LOCAL_VERSION="${{ needs.check-release.outputs.version }}"
-          FAILED=""
-
-          publish_pkg() {
-            local dir="$1" name="$2"
-            REGISTRY_VERSION=$(npm view "$name" version 2>/dev/null || echo "0.0.0")
-            if [ "$LOCAL_VERSION" = "$REGISTRY_VERSION" ]; then
-              echo "$name@$LOCAL_VERSION already published, skipping"
-              return 0
-            fi
-            echo "Publishing $name@$LOCAL_VERSION..."
-            TARBALL=$(cd "$dir" && pnpm pack --pack-destination /tmp | tail -1)
-            if ! npm publish "$TARBALL" --provenance --access public; then
-              FAILED="$FAILED $name"
-            fi
-          }
-
-          for dir in packages/*/; do
-            PKG_NAME=$(node -p "try { const p = require('./$dir/package.json'); p.private ? '' : p.name } catch { '' }")
-            [ -z "$PKG_NAME" ] && continue
-            publish_pkg "$dir" "$PKG_NAME"
-          done
-
-          if [ -n "$FAILED" ]; then
-            echo "Failed to publish:$FAILED"
-            exit 1
-          fi
-
-  github-release:
-    name: Create GitHub Release
-    needs: [check-release, publish]
-    if: >-
-      always()
-      && needs.check-release.outputs.needs_github_release == 'true'
-      && (needs.publish.result == 'success' || needs.publish.result == 'skipped')
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    permissions:
-      contents: write
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Extract changelog entry
-        run: |
-          VERSION="${{ needs.check-release.outputs.version }}"
-          awk '/<!-- release:start -->/{found=1; next} /<!-- release:end -->/{found=0} found{print}' CHANGELOG.md > /tmp/release-notes.md
-
-          LINES=$(wc -l < /tmp/release-notes.md | tr -d ' ')
-          if [ "$LINES" -lt 2 ]; then
-            echo "Error: No release notes found between <!-- release:start --> and <!-- release:end --> markers in CHANGELOG.md"
-            exit 1
-          fi
-          echo "Extracted release notes for $VERSION ($LINES lines)"
-
-      - name: Create GitHub Release
-        run: |
-          VERSION="${{ needs.check-release.outputs.version }}"
-          TAG="v$VERSION"
-
-          if gh release view "$TAG" &>/dev/null; then
-            echo "Release $TAG already exists"
-          else
-            echo "Creating release $TAG..."
-            gh release create "$TAG" \
-              --title "$TAG" \
-              --target ${{ github.sha }} \
-              --notes-file /tmp/release-notes.md
-          fi
+      - name: Create Release Pull Request or Publish
+        uses: changesets/action@v1
+        with:
+          version: pnpm ci:version
+          publish: pnpm ci:publish
+          title: "chore: version packages"
+          commit: "chore: version packages"
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_VERCEL_TOKEN_ELEVATED }}

.gitignore

@@ -4,11 +4,13 @@
 node_modules
 .pnp
 .pnp.js
-.pnpm-store/
 
 # Local env files
-.env*
-!.env.example
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
 
 # Testing
 coverage
@@ -28,9 +30,6 @@ out/
 build
 dist
 *.tsbuildinfo
-.svelte-kit/
-tsup.config.bundled_*.mjs
-next-env.d.ts
 
 
 # Debug
@@ -44,8 +43,4 @@ yarn-error.log*
 
 # opensrc - source code for packages
 opensrc/
-
-# Stripe apps (generated from template + build artifacts)
-examples/stripe-app/*/stripe-app.json
-examples/stripe-app/*/.build
-examples/stripe-app/*/yarn.lock
+.env*.local

.node-version

@@ -1 +0,0 @@
-24

.vscode/mcp.json

@@ -1,9 +0,0 @@
-{
-  "servers": {
-    "json-render": {
-      "type": "stdio",
-      "command": "npx",
-      "args": ["tsx", "examples/mcp/server.ts", "--stdio"]
-    }
-  }
-}

AGENTS.md

@@ -25,88 +25,12 @@ This ensures we don't install outdated versions that may have incompatible types
 ## Code Style
 
 - Do not use emojis in code or UI
+- Do not use barrel files (index.ts that re-exports from other files)
 - Use shadcn CLI to add shadcn/ui components: `pnpm dlx shadcn@latest add <component>`
-- **Web app docs (`apps/web/`):** Never use Markdown table syntax (`| col | col |`). Always use HTML `<table>` with `<thead>`, `<tbody>`, `<tr>`, `<th>`, `<td>`. Markdown tables do not render correctly in the web app. Inside HTML table cells, curly braces must be escaped as JSX expressions (e.g. `<code>{'{ "$state": "/path" }'}</code>`) because MDX parses `{` as a JSX expression boundary.
-
-## AI SDK / AI Gateway
-
-When using the Vercel AI SDK (`ai` package) with AI Gateway, pass the model as a plain string identifier -- do not import a provider constructor:
-
-```ts
-import { streamText } from "ai";
-
-const result = streamText({
-  model: "anthropic/claude-haiku-4.5",
-  prompt: "...",
-});
-```
-
-This requires `AI_GATEWAY_API_KEY` to be set in the environment. See `tests/e2e/` for examples.
-
-## Dev Servers
-
-All apps and examples with dev servers use [portless](https://github.com/vercel-labs/portless) to avoid hardcoded ports. Portless assigns random ports and exposes each app via `.localhost` URLs.
-
-Naming convention:
-- Main web app: `json-render` → `json-render.localhost:1355`
-- Examples: `[name]-demo.json-render` → `[name]-demo.json-render.localhost:1355`
-
-When adding a new example that runs a dev server, wrap its `dev` script with `portless <name>`:
-
-```json
-{
-  "scripts": {
-    "dev": "portless my-example-demo.json-render next dev --turbopack"
-  }
-}
-```
-
-Do **not** add `--port` flags -- portless handles port assignment automatically. Do **not** add portless as a project dependency; it must be installed globally.
 
 ## Workflow
 
 - Run `pnpm type-check` after each turn to ensure type safety
-- Documentation lives in `apps/web/content/docs/` and uses Geistdocs frontmatter. Keep public `/docs` URLs, heading IDs, `lib/page-titles.ts`, `lib/docs-navigation.ts`, and the content `meta.json` files in sync.
-- For docs routing or infrastructure changes, run `pnpm turbo run build --filter='web^...'`, `pnpm --filter web build`, and `pnpm --filter web test:routes`. Existing-page source and Markdown parity are covered by `apps/web/tests/fixtures/docs-baseline.json`; update fixtures only when intentionally changing the documented content.
-- When making user-facing changes (new packages, API changes, new features, renamed exports, changed behavior), update the relevant documentation:
-  - Package `README.md` files in `packages/*/README.md`
-  - Root `README.md` (if packages table, install commands, or examples are affected)
-  - Web app docs in `apps/web/` (if guides, API references, or examples need updating)
-  - Skills in `skills/*/SKILL.md` (if the package has a corresponding skill)
-  - `AGENTS.md` (if workflow or conventions change)
-
-## Releasing
-
-Releases are manual, single-PR affairs. The maintainer controls the changelog voice and format.
-
-All public `@json-render/*` packages share the same version. The canonical version lives in `packages/core/package.json`.
-
-### Preparing a release
-
-When asked to prepare a release (e.g. "prepare v0.17.0"):
-
-1. Create a branch (e.g. `prepare-v0.17.0`)
-2. Bump the version in `packages/core/package.json`
-3. Run `pnpm run version:sync` to update all other `@json-render/*` packages
-4. Write the changelog entry in `CHANGELOG.md`, wrapped in `<!-- release:start -->` and `<!-- release:end -->` markers (move the markers from the previous entry to the new one)
-5. **Fill documentation gaps** — every public package should have:
-   - A row in the root `README.md` packages table
-   - A renderer section in the root `README.md` (if it's a renderer)
-   - An API reference page at `apps/web/content/docs/api/<name>.mdx`
-   - An entry in `apps/web/lib/page-titles.ts` and `apps/web/lib/docs-navigation.ts`
-   - An entry in the docs-chat system prompt (`apps/web/app/api/docs-chat/route.ts`)
-   - A skill at `skills/<name>/SKILL.md`
-   - A `packages/<name>/README.md`
-6. **Run `pnpm type-check`** after all changes to verify nothing is broken
-7. Open a PR and merge to `main`
-
-CI compares the `@json-render/core` version to what's on npm. If it differs, it builds, publishes all public packages, and creates the GitHub release automatically. The release body is extracted from the content between the markers.
-
-### Scripts
-
-- `pnpm run version:sync` — sync all `@json-render/*` package versions to match `@json-render/core`
-- `pnpm run version:check` — verify all versions are in sync (runs in CI)
-- `pnpm run ci:publish` — build all packages and publish to npm (CI only)
 
 <!-- opensrc:start -->
 

CHANGELOG.md

@@ -1,110 +0,0 @@
-# Changelog
-
-## 0.21.0
-
-<!-- release:start -->
-
-### New Features
-
-- **TanStack Start renderer:** Added `@json-render/tanstack-start` for JSON-defined applications with file-based routes, reusable layouts, SSR loaders, head metadata, prerender paths, client navigation, and route fallbacks (#334)
-- **Experimental Jev composition:** Added `experimental_composeSpec` and `experimental_createEvaluator` to compose validated specs from app-owned candidates, plus a Jev model option and iterative composition editing in the playground
-
-### Improvements
-
-- **Vue named slots:** Vue registries now support catalog-declared named slots alongside the default `children` slot (#323)
-- **React streaming stability:** Stabilized streamed React renders and added coverage for incomplete streamed props and nested prop identities (#325)
-- **Documentation and project status:** Expanded renderer, Jev, and package documentation and added Labs status badges to the project README
-
-### Contributors
-
-- @ctate
-- @Railly
-<!-- release:end -->
-
-## 0.20.0
-
-### New Features
-
-- **Named slots for React:** Components can declare named slots such as `header` and `footer`, while `children` remains the default slot. Slots are preserved through validation, streaming, nested conversion, code export, playground views, and Devtools navigation (#320). Built from the original contribution by @wotnak in #105
-- **Nested repeats:** `repeat.statePath` now accepts item-relative paths such as `{ "$item": "employees" }`, enabling nested data rendering across React, React Native, React Email, React PDF, Image, Ink, Solid, Svelte, and Vue (#319). Built from the original contribution by @tmchow in #256
-- **Harness chat example:** Added a complete Next.js example using the AI SDK 7 harness adapter, agent delegation, sandbox transport, and json-render components (#302)
-
-### Bug Fixes
-
-- **Chained action params:** Named `onSuccess` and `onError` actions now receive their configured `params` across core and all renderer bridges (#307)
-- **Consistent optional visibility:** Element `visible` fields now remain optional across Zod 4 versions, while prompts explicitly require `children` arrays for every element (#299)
-- **Spec validation and autofix:** Dangling child references are pruned, malformed visibility conditions are reported, and repeated items can be filtered safely (#300)
-
-### Improvements
-
-- **Release toolchain hardening:** The workspace now requires Node.js 24 and pnpm 11, enforces package engine checks, and applies a minimum package release age (#293)
-
-### Breaking Changes
-
-- Custom renderer bridges that implement the core `executeAction` callback must now accept an `ActionBinding` instead of a bare action name. This exposes chained action params to custom integrations at compile time (#307)
-
-### Contributors
-
-- @ctate
-- @Railly
-- @tmchow
-- @wotnak
-
-## 0.19.0
-
-### New Features
-
-- **Custom directives API** — `@json-render/core` now supports custom directives via `defineDirective`, letting you declare new JSON shapes (like `$format`, `$math`) that resolve to computed values at render time. Directives compose naturally — nest `$format` over `$math` over `$state` and they resolve inside-out. All four renderers (React, Vue, Svelte, Solid) have built-in directive resolution (#279)
-- **`@json-render/directives`** — New package shipping seven ready-made directives: `$format` (date, currency, number, percent via `Intl`), `$math` (add, subtract, multiply, divide, mod, min, max, round, floor, ceil, abs), `$concat`, `$count`, `$truncate`, `$pluralize`, and `$join`. Also exports `createI18nDirective` for `$t` translation keys with `{{param}}` interpolation, and `standardDirectives` for one-line registration (#279)
-
-### Improvements
-
-- **Example READMEs** — Added documentation to the chat, dashboard, game-engine, and no-ai examples (#277)
-
-### Contributors
-
-- @ctate
-
-## 0.18.0
-
-### New Features
-
-- **Devtools** — Five new packages for inspecting json-render apps in the browser: `@json-render/devtools` (framework-agnostic core), plus `@json-render/devtools-react`, `@json-render/devtools-vue`, `@json-render/devtools-svelte`, and `@json-render/devtools-solid` adapters. Drop `<JsonRenderDevtools />` into your app to get a shadow-DOM-isolated panel with six tabs (Spec, State, Actions, Stream, Catalog, Pick), a DOM picker that maps clicked elements back to spec keys via `data-jr-key`, a capped event store, and server-side stream tap utilities. Floating toggle or `Cmd`/`Ctrl` + `Shift` + `J`, tree-shakes to `null` in production (#273)
-- **Devtools example** — New `examples/devtools` Next.js demo showing the full devtools panel wired up to an AI chat endpoint and a component catalog (#273)
-- **Action observer and devtools flag in core** — `@json-render/core` now exposes an action observer and a devtools enablement flag that adapters use to mirror actions and stream events into the panel (#273)
-
-### Bug Fixes
-
-- **Zod 4 schema formatting** — `formatZodType` now correctly handles `z.record()`, `z.default()`, and `z.literal()` types from Zod 4, which previously produced incorrect or empty output in generated prompts and schemas (#239)
-
-### Improvements
-
-- **Zod 4 test coverage** — Added unit tests for `formatZodType` covering record, default, and literal types to guard against regressions (#272)
-
-### Contributors
-
-- @ctate
-- @mvanhorn
-
-## 0.17.0
-
-### New Features
-
-- **Gaussian Splatting** — Added `GaussianSplat` component to `@json-render/react-three-fiber`, bringing the component count to 20. Composable with all existing R3F components (lights, controls, post-processing) via drei's Splat loader (#259)
-- **Standalone gsplat example** — Experimental demo app showcasing Gaussian Splatting with gsplat.js (no Three.js dependency), featuring scene selector, live JSON spec viewer, and progress indicator (#259)
-- **R3F gsplat example** — Demo app with five scenes: splat showroom, splat with primitives, multi-splat, post-processing effects, and animated floating splat (#259)
-
-### Improved
-
-- **AI output quality** — Improved prompt output and schema generation for more reliable AI-generated specs (#268)
-
-### Contributors
-
-- @ctate
-- @willmanzoli
-
-## 0.16.0
-
-### Improved
-
-- **Release process** — Switched from Changesets to a manual single-PR release workflow with changelog markers and automatic npm publish on version bump

README.md

@@ -1,52 +1,22 @@
 # json-render
 
-**The Generative UI framework.**
+**Predictable. Guardrailed. Fast.**
 
-Generate dynamic, personalized UIs from prompts without sacrificing reliability. Predefined components and actions for safe, predictable output.
-
-<p>
-  <a href="https://vercel.com/labs#labs-products"><img alt="Vercel Labs Product" src="https://img.shields.io/badge/LABS-PRODUCT-0a0a0a.svg?style=for-the-badge&amp;logo=Vercel&amp;labelColor=000000" height="28"></a>
-  <a href="https://www.npmjs.com/package/@json-render/core"><img alt="npm version: @json-render/core" src="https://img.shields.io/npm/v/%40json-render%2Fcore.svg?style=for-the-badge&amp;labelColor=000000" height="28"></a>
-  <a href="https://github.com/vercel-labs/json-render/blob/main/LICENSE"><img alt="License: Apache-2.0" src="https://img.shields.io/github/license/vercel-labs/json-render.svg?style=for-the-badge&amp;labelColor=000000" height="28"></a>
-  <a href="https://www.npmjs.com/package/@json-render/core"><img alt="npm downloads per month: @json-render/core" src="https://img.shields.io/npm/dm/%40json-render%2Fcore.svg?style=for-the-badge&amp;labelColor=000000&amp;label=npm%20downloads" height="28"></a>
-</p>
+Let end users generate dashboards, widgets, apps, and videos from prompts — safely constrained to components you define.
 
 ```bash
-# for React
 npm install @json-render/core @json-render/react
-# for React with pre-built shadcn/ui components
-npm install @json-render/shadcn
-# or for React Native
-npm install @json-render/core @json-render/react-native
 # or for video
 npm install @json-render/core @json-render/remotion
-# or for PDF documents
-npm install @json-render/core @json-render/react-pdf
-# or for HTML email
-npm install @json-render/core @json-render/react-email @react-email/components @react-email/render
-# or for Vue
-npm install @json-render/core @json-render/vue
-# or for Svelte
-npm install @json-render/core @json-render/svelte
-# or for SolidJS
-npm install @json-render/core @json-render/solid
-# or for terminal UIs
-npm install @json-render/core @json-render/ink ink react
-# or for full Next.js apps (routes, layouts, SSR, metadata)
-npm install @json-render/core @json-render/react @json-render/next
-# or for 3D scenes (and gaussian splatting via the GaussianSplat component)
-npm install @json-render/core @json-render/react-three-fiber @react-three/fiber @react-three/drei three
 ```
 
 ## Why json-render?
 
-json-render is a **Generative UI** framework: AI generates interfaces from natural language prompts, constrained to components you define. You set the guardrails, AI generates within them:
+When users prompt for UI, you need guarantees. json-render gives AI a **constrained vocabulary** so output is always predictable:
 
-- **Guardrailed** - AI can only use components in your catalog
-- **Predictable** - JSON output matches your schema, every time
-- **Fast** - Stream and render progressively as the model responds
-- **Cross-Platform** - React, Vue, Svelte, Solid (web), React Native (mobile) from the same catalog
-- **Batteries Included** - 36 pre-built shadcn/ui components ready to use
+- **Guardrailed** — AI can only use components in your catalog
+- **Predictable** — JSON output matches your schema, every time
+- **Fast** — Stream and render progressively as the model responds
 
 ## Quick Start
 
@@ -54,7 +24,7 @@ json-render is a **Generative UI** framework: AI generates interfaces from natur
 
 ```typescript
 import { defineCatalog } from "@json-render/core";
-import { schema } from "@json-render/react/schema";
+import { schema } from "@json-render/react";
 import { z } from "zod";
 
 const catalog = defineCatalog(schema, {
@@ -105,8 +75,10 @@ const { registry } = defineRegistry(catalog, {
         <span>{format(props.value, props.format)}</span>
       </div>
     ),
-    Button: ({ props, emit }) => (
-      <button onClick={() => emit("press")}>{props.label}</button>
+    Button: ({ props, onAction }) => (
+      <button onClick={() => onAction?.({ name: props.action })}>
+        {props.label}
+      </button>
     ),
   },
 });
@@ -126,37 +98,12 @@ function Dashboard({ spec }) {
 
 ## Packages
 
-| Package                     | Description                                                            |
-| --------------------------- | ---------------------------------------------------------------------- |
-| `@json-render/core`         | Schemas, catalogs, AI prompts, dynamic props, SpecStream utilities     |
-| `@json-render/react`        | React renderer, contexts, hooks                                        |
-| `@json-render/vue`          | Vue 3 renderer, composables, providers                                 |
-| `@json-render/svelte`       | Svelte 5 renderer with runes-based reactivity                          |
-| `@json-render/solid`        | SolidJS renderer with fine-grained reactive contexts                   |
-| `@json-render/shadcn`       | 36 pre-built shadcn/ui components (Radix UI + Tailwind CSS)            |
-| `@json-render/shadcn-svelte`| 36 pre-built shadcn-svelte components (Svelte 5 + Tailwind CSS)        |
-| `@json-render/react-three-fiber` | React Three Fiber renderer for 3D scenes (20 built-in components, including GaussianSplat)  |
-| `@json-render/react-native` | React Native renderer with standard mobile components                  |
-| `@json-render/next`         | Next.js renderer — JSON becomes full apps with routes, layouts, SSR    |
-| `@json-render/tanstack-start` | TanStack Start renderer — full apps with routes, layouts, SSR, and head metadata |
-| `@json-render/remotion`     | Remotion video renderer, timeline schema                               |
-| `@json-render/react-pdf`    | React PDF renderer for generating PDF documents from specs             |
-| `@json-render/react-email`  | React Email renderer for HTML/plain-text emails from specs             |
-| `@json-render/ink`          | Ink terminal renderer with built-in components for interactive TUIs.   |
-| `@json-render/image`        | Image renderer for SVG/PNG output (OG images, social cards) via Satori |
-| `@json-render/directives`   | Pre-built custom directives — $format, $math, $concat, $count, $truncate, $pluralize, $join, $t (i18n) |
-| `@json-render/codegen`      | Utilities for generating code from json-render UI trees                |
-| `@json-render/devtools`     | Framework-agnostic devtools core — panel UI, event store, picker, stream taps |
-| `@json-render/devtools-react`   | React adapter for `@json-render/devtools` (drop-in `<JsonRenderDevtools />`)     |
-| `@json-render/devtools-vue`     | Vue adapter for `@json-render/devtools`                                           |
-| `@json-render/devtools-svelte`  | Svelte adapter for `@json-render/devtools`                                        |
-| `@json-render/devtools-solid`   | SolidJS adapter for `@json-render/devtools`                                       |
-| `@json-render/redux`        | Redux / Redux Toolkit adapter for `StateStore`                         |
-| `@json-render/zustand`      | Zustand adapter for `StateStore`                                       |
-| `@json-render/jotai`        | Jotai adapter for `StateStore`                                         |
-| `@json-render/xstate`       | XState Store (atom) adapter for `StateStore`                           |
-| `@json-render/mcp`          | MCP Apps integration for Claude, ChatGPT, Cursor, VS Code              |
-| `@json-render/yaml`         | YAML wire format with streaming parser, edit modes, AI SDK transform   |
+| Package | Description |
+|---------|-------------|
+| `@json-render/core` | Schemas, catalogs, AI prompts, dynamic props, SpecStream utilities |
+| `@json-render/react` | React renderer, contexts, hooks |
+| `@json-render/react-native` | React Native renderer with standard mobile components |
+| `@json-render/remotion` | Remotion video renderer, timeline schema |
 
 ## Renderers
 
@@ -164,172 +111,38 @@ function Dashboard({ spec }) {
 
 ```tsx
 import { defineRegistry, Renderer } from "@json-render/react";
-import { schema } from "@json-render/react/schema";
+import { schema } from "@json-render/react";
 
-// Flat spec format (root key + elements map)
+// Element tree spec format
 const spec = {
-  root: "card-1",
-  elements: {
-    "card-1": {
-      type: "Card",
-      props: { title: "Hello" },
-      children: ["button-1"],
-    },
-    "button-1": {
-      type: "Button",
-      props: { label: "Click me" },
-      children: [],
-    },
-  },
+  root: {
+    type: "Card",
+    props: { title: "Hello" },
+    children: [
+      { type: "Button", props: { label: "Click me" } }
+    ]
+  }
 };
 
 // defineRegistry creates a type-safe component registry
 const { registry } = defineRegistry(catalog, { components });
-<Renderer spec={spec} registry={registry} />;
-```
-
-### Vue (UI)
-
-```typescript
-import { h } from "vue";
-import { defineRegistry, Renderer } from "@json-render/vue";
-import { schema } from "@json-render/vue/schema";
-
-const { registry } = defineRegistry(catalog, {
-  components: {
-    Card: ({ props, children }) =>
-      h("div", { class: "card" }, [h("h3", null, props.title), children]),
-    Button: ({ props, emit }) =>
-      h("button", { onClick: () => emit("press") }, props.label),
-  },
-});
-
-// In your Vue component template:
-// <Renderer :spec="spec" :registry="registry" />
-```
-
-### Svelte (UI)
-
-```typescript
-import { defineRegistry, Renderer } from "@json-render/svelte";
-import { schema } from "@json-render/svelte/schema";
-
-const { registry } = defineRegistry(catalog, {
-  components: {
-    Card: ({ props, children }) => /* Svelte 5 snippet */,
-    Button: ({ props, emit }) => /* Svelte 5 snippet */,
-  },
-});
-
-// In your Svelte component:
-// <Renderer spec={spec} registry={registry} />
-```
-
-### Solid (UI)
-
-```tsx
-import { defineRegistry, Renderer } from "@json-render/solid";
-import { schema } from "@json-render/solid/schema";
-
-const { registry } = defineRegistry(catalog, {
-  components: {
-    Card: (renderProps) => <div>{renderProps.children}</div>,
-    Button: (renderProps) => (
-      <button onClick={() => renderProps.emit("press")}>
-        {renderProps.element.props.label as string}
-      </button>
-    ),
-  },
-});
-
-<Renderer spec={spec} registry={registry} />;
-```
-
-### shadcn/ui (Web)
-
-```tsx
-import { defineCatalog } from "@json-render/core";
-import { schema } from "@json-render/react/schema";
-import { defineRegistry, Renderer } from "@json-render/react";
-import { shadcnComponentDefinitions } from "@json-render/shadcn/catalog";
-import { shadcnComponents } from "@json-render/shadcn";
-
-// Pick components from the 36 standard definitions
-const catalog = defineCatalog(schema, {
-  components: {
-    Card: shadcnComponentDefinitions.Card,
-    Stack: shadcnComponentDefinitions.Stack,
-    Heading: shadcnComponentDefinitions.Heading,
-    Button: shadcnComponentDefinitions.Button,
-  },
-  actions: {},
-});
-
-// Use matching implementations
-const { registry } = defineRegistry(catalog, {
-  components: {
-    Card: shadcnComponents.Card,
-    Stack: shadcnComponents.Stack,
-    Heading: shadcnComponents.Heading,
-    Button: shadcnComponents.Button,
-  },
-});
-
-<Renderer spec={spec} registry={registry} />;
-```
-
-### React Native (Mobile)
-
-```tsx
-import { defineCatalog } from "@json-render/core";
-import { schema } from "@json-render/react-native/schema";
-import {
-  standardComponentDefinitions,
-  standardActionDefinitions,
-} from "@json-render/react-native/catalog";
-import { defineRegistry, Renderer } from "@json-render/react-native";
-
-// 25+ standard components included
-const catalog = defineCatalog(schema, {
-  components: { ...standardComponentDefinitions },
-  actions: standardActionDefinitions,
-});
-
-const { registry } = defineRegistry(catalog, { components: {} });
-<Renderer spec={spec} registry={registry} />;
+<Renderer spec={spec} registry={registry} />
 ```
 
 ### Remotion (Video)
 
 ```tsx
 import { Player } from "@remotion/player";
-import {
-  Renderer,
-  schema,
-  standardComponentDefinitions,
-} from "@json-render/remotion";
+import { Renderer, schema, standardComponentDefinitions } from "@json-render/remotion";
 
 // Timeline spec format
 const spec = {
-  composition: {
-    id: "video",
-    fps: 30,
-    width: 1920,
-    height: 1080,
-    durationInFrames: 300,
-  },
+  composition: { id: "video", fps: 30, width: 1920, height: 1080, durationInFrames: 300 },
   tracks: [{ id: "main", name: "Main", type: "video", enabled: true }],
   clips: [
-    {
-      id: "clip-1",
-      trackId: "main",
-      component: "TitleCard",
-      props: { title: "Hello" },
-      from: 0,
-      durationInFrames: 90,
-    },
+    { id: "clip-1", trackId: "main", component: "TitleCard", props: { title: "Hello" }, from: 0, durationInFrames: 90 }
   ],
-  audio: { tracks: [] },
+  audio: { tracks: [] }
 };
 
 <Player
@@ -339,348 +152,7 @@ const spec = {
   fps={spec.composition.fps}
   compositionWidth={spec.composition.width}
   compositionHeight={spec.composition.height}
-/>;
-```
-
-### React PDF (Documents)
-
-```typescript
-import { renderToBuffer } from "@json-render/react-pdf";
-
-const spec = {
-  root: "doc",
-  elements: {
-    doc: {
-      type: "Document",
-      props: { title: "Invoice" },
-      children: ["page-1"],
-    },
-    "page-1": {
-      type: "Page",
-      props: { size: "A4" },
-      children: ["heading-1", "table-1"],
-    },
-    "heading-1": {
-      type: "Heading",
-      props: { text: "Invoice #1234", level: "h1" },
-      children: [],
-    },
-    "table-1": {
-      type: "Table",
-      props: {
-        columns: [
-          { header: "Item", width: "60%" },
-          { header: "Price", width: "40%", align: "right" },
-        ],
-        rows: [
-          ["Widget A", "$10.00"],
-          ["Widget B", "$25.00"],
-        ],
-      },
-      children: [],
-    },
-  },
-};
-
-// Render to buffer, stream, or file
-const buffer = await renderToBuffer(spec);
-```
-
-### React Email (Email)
-
-```typescript
-import { renderToHtml } from "@json-render/react-email";
-import { schema, standardComponentDefinitions } from "@json-render/react-email";
-import { defineCatalog } from "@json-render/core";
-
-const catalog = defineCatalog(schema, {
-  components: standardComponentDefinitions,
-});
-
-const spec = {
-  root: "html-1",
-  elements: {
-    "html-1": {
-      type: "Html",
-      props: { lang: "en", dir: "ltr" },
-      children: ["head-1", "body-1"],
-    },
-    "head-1": { type: "Head", props: {}, children: [] },
-    "body-1": {
-      type: "Body",
-      props: { style: { backgroundColor: "#f6f9fc" } },
-      children: ["container-1"],
-    },
-    "container-1": {
-      type: "Container",
-      props: {
-        style: { maxWidth: "600px", margin: "0 auto", padding: "20px" },
-      },
-      children: ["heading-1", "text-1"],
-    },
-    "heading-1": { type: "Heading", props: { text: "Welcome" }, children: [] },
-    "text-1": {
-      type: "Text",
-      props: { text: "Thanks for signing up." },
-      children: [],
-    },
-  },
-};
-
-const html = await renderToHtml(spec);
-```
-
-### Image (SVG/PNG)
-
-```typescript
-import { renderToPng } from "@json-render/image/render";
-
-const spec = {
-  root: "frame",
-  elements: {
-    frame: {
-      type: "Frame",
-      props: { width: 1200, height: 630, backgroundColor: "#1a1a2e" },
-      children: ["heading"],
-    },
-    heading: {
-      type: "Heading",
-      props: { text: "Hello World", level: "h1", color: "#ffffff" },
-      children: [],
-    },
-  },
-};
-
-// Render to PNG (requires @resvg/resvg-js)
-const png = await renderToPng(spec, { fonts });
-
-// Or render to SVG string
-import { renderToSvg } from "@json-render/image/render";
-const svg = await renderToSvg(spec, { fonts });
-```
-
-### Three.js (3D)
-
-```tsx
-import { defineCatalog } from "@json-render/core";
-import { schema, defineRegistry } from "@json-render/react";
-import {
-  threeComponentDefinitions,
-  threeComponents,
-  ThreeCanvas,
-} from "@json-render/react-three-fiber";
-
-const catalog = defineCatalog(schema, {
-  components: {
-    Box: threeComponentDefinitions.Box,
-    Sphere: threeComponentDefinitions.Sphere,
-    AmbientLight: threeComponentDefinitions.AmbientLight,
-    DirectionalLight: threeComponentDefinitions.DirectionalLight,
-    GaussianSplat: threeComponentDefinitions.GaussianSplat,
-    OrbitControls: threeComponentDefinitions.OrbitControls,
-  },
-  actions: {},
-});
-
-const { registry } = defineRegistry(catalog, {
-  components: {
-    Box: threeComponents.Box,
-    Sphere: threeComponents.Sphere,
-    AmbientLight: threeComponents.AmbientLight,
-    DirectionalLight: threeComponents.DirectionalLight,
-    GaussianSplat: threeComponents.GaussianSplat,
-    OrbitControls: threeComponents.OrbitControls,
-  },
-});
-
-<ThreeCanvas
-  spec={spec}
-  registry={registry}
-  shadows
-  camera={{ position: [5, 5, 5], fov: 50 }}
-  style={{ width: "100%", height: "100vh" }}
-/>;
-```
-
-### Next.js (Full Apps)
-
-```typescript
-import type { NextAppSpec } from "@json-render/next";
-import { createNextApp } from "@json-render/next/server";
-import { NextAppProvider } from "@json-render/next";
-
-const spec: NextAppSpec = {
-  metadata: { title: { default: "My App", template: "%s | My App" } },
-  layouts: {
-    main: {
-      root: "shell",
-      elements: {
-        shell: { type: "Container", props: {}, children: ["nav", "slot"] },
-        nav: { type: "NavBar", props: {}, children: [] },
-        slot: { type: "Slot", props: {}, children: [] },
-      },
-    },
-  },
-  routes: {
-    "/": {
-      layout: "main",
-      metadata: { title: "Home" },
-      page: {
-        root: "hero",
-        elements: {
-          hero: { type: "Card", props: { title: "Welcome" }, children: [] },
-        },
-      },
-    },
-  },
-};
-
-// Server: creates Page, generateMetadata, generateStaticParams
-const app = createNextApp({ spec });
-
-// Client: wrap your layout with NextAppProvider
-// <NextAppProvider registry={registry} handlers={handlers}>
-//   {children}
-// </NextAppProvider>
-```
-
-### TanStack Start (Full Apps)
-
-```tsx
-import { createFileRoute, notFound } from "@tanstack/react-router";
-import {
-  PageRenderer,
-  StartErrorBoundary,
-  StartLoading,
-  StartNotFound,
-  type StartAppSpec,
-} from "@json-render/tanstack-start";
-import { createStartApp } from "@json-render/tanstack-start/server";
-
-const spec: StartAppSpec = {
-  metadata: { title: { default: "My App", template: "%s | My App" } },
-  routes: {
-    "/": {
-      metadata: { title: "Home" },
-      page: {
-        root: "hero",
-        elements: {
-          hero: { type: "Card", props: { title: "Welcome" }, children: [] },
-        },
-      },
-    },
-  },
-};
-
-const { getPageData, getHead } = createStartApp({ spec });
-
-export const Route = createFileRoute("/$")({
-  loader: async ({ location }) => {
-    const data = await getPageData({ pathname: location.pathname });
-    if (!data) throw notFound();
-    return data;
-  },
-  head: ({ match }) => getHead({ pathname: match.pathname }),
-  component: () => <PageRenderer {...Route.useLoaderData()} />,
-  pendingComponent: StartLoading,
-  errorComponent: StartErrorBoundary,
-  notFoundComponent: StartNotFound,
-});
-```
-
-Wrap the root route's outlet with `<StartAppProvider spec={spec}>` so route
-fallback components can resolve the current route. Pass named `$computed`
-implementations through its `functions` prop.
-
-### shadcn-svelte (Svelte)
-
-```typescript
-import { defineCatalog } from "@json-render/core";
-import { schema } from "@json-render/svelte/schema";
-import { defineRegistry, Renderer } from "@json-render/svelte";
-import { shadcnComponentDefinitions } from "@json-render/shadcn-svelte/catalog";
-import { shadcnComponents } from "@json-render/shadcn-svelte";
-
-const catalog = defineCatalog(schema, {
-  components: {
-    Card: shadcnComponentDefinitions.Card,
-    Stack: shadcnComponentDefinitions.Stack,
-    Heading: shadcnComponentDefinitions.Heading,
-    Button: shadcnComponentDefinitions.Button,
-  },
-  actions: {},
-});
-
-const { registry } = defineRegistry(catalog, {
-  components: {
-    Card: shadcnComponents.Card,
-    Stack: shadcnComponents.Stack,
-    Heading: shadcnComponents.Heading,
-    Button: shadcnComponents.Button,
-  },
-});
-
-// In your Svelte component:
-// <Renderer spec={spec} registry={registry} />
-```
-
-### Devtools
-
-Drop-in inspector panel for any json-render app. Spec tree, state editor, action log, stream log, catalog browser, DOM picker.
-
-```tsx
-// React
-import { JsonRenderDevtools } from "@json-render/devtools-react";
-
-<JSONUIProvider registry={registry} handlers={handlers}>
-  <Renderer spec={spec} registry={registry} />
-  <JsonRenderDevtools spec={spec} catalog={catalog} messages={messages} />
-</JSONUIProvider>;
-```
-
-Floating toggle appears bottom-right. Hotkey: `Ctrl`/`Cmd` + `Shift` + `J`. Tree-shakes to `null` in production.
-
-Available for React, Vue, Svelte, and Solid — swap `@json-render/devtools-react` for the adapter that matches your renderer.
-
-### Ink (Terminal)
-
-```tsx
-import { defineCatalog } from "@json-render/core";
-import {
-  schema,
-  standardComponentDefinitions,
-  standardActionDefinitions,
-  defineRegistry,
-  Renderer,
-  JSONUIProvider,
-} from "@json-render/ink";
-
-const catalog = defineCatalog(schema, {
-  components: { ...standardComponentDefinitions },
-  actions: standardActionDefinitions,
-});
-
-const { registry } = defineRegistry(catalog, { components: {} });
-
-const spec = {
-  root: "card-1",
-  elements: {
-    "card-1": {
-      type: "Card",
-      props: { title: "Status" },
-      children: ["status-1"],
-    },
-    "status-1": {
-      type: "StatusLine",
-      props: { label: "Build", status: "success" },
-      children: [],
-    },
-  },
-};
-
-<JSONUIProvider initialState={{}}>
-  <Renderer spec={spec} registry={registry} />
-</JSONUIProvider>;
+/>
 ```
 
 ## Features
@@ -717,10 +189,12 @@ const systemPrompt = catalog.prompt();
 {
   "type": "Alert",
   "props": { "message": "Error occurred" },
-  "visible": [
-    { "$state": "/form/hasError" },
-    { "$state": "/form/errorDismissed", "not": true }
-  ]
+  "visible": {
+    "and": [
+      { "path": "/form/hasError" },
+      { "not": { "path": "/form/errorDismissed" } }
+    ]
+  }
 }
 ```
 
@@ -732,26 +206,16 @@ Any prop value can be data-driven using expressions:
 {
   "type": "Icon",
   "props": {
-    "name": {
-      "$cond": { "$state": "/activeTab", "eq": "home" },
-      "$then": "home",
-      "$else": "home-outline"
-    },
-    "color": {
-      "$cond": { "$state": "/activeTab", "eq": "home" },
-      "$then": "#007AFF",
-      "$else": "#8E8E93"
-    }
+    "name": { "$cond": { "eq": [{ "path": "/activeTab" }, "home"] }, "$then": "home", "$else": "home-outline" },
+    "color": { "$cond": { "eq": [{ "path": "/activeTab" }, "home"] }, "$then": "#007AFF", "$else": "#8E8E93" }
   }
 }
 ```
 
-Expression forms:
+Two expression forms:
 
-- **`{ "$state": "/state/key" }`** - reads a value from the state model
-- **`{ "$cond": <condition>, "$then": <value>, "$else": <value> }`** - evaluates a condition and picks a branch
-- **`{ "$template": "Hello, ${/user/name}!" }`** - interpolates state values into strings
-- **`{ "$computed": "fn", "args": { ... } }`** - calls a registered function with resolved args
+- **`{ "$path": "/state/key" }`** -- reads a value from the data model
+- **`{ "$cond": <condition>, "$then": <value>, "$else": <value> }`** -- evaluates a condition (same syntax as visibility conditions) and picks a branch
 
 ### Actions
 
@@ -760,37 +224,12 @@ Components can trigger actions, including the built-in `setState` action:
 ```json
 {
   "type": "Pressable",
-  "props": {
-    "action": "setState",
-    "actionParams": { "statePath": "/activeTab", "value": "home" }
-  },
+  "props": { "action": "setState", "actionParams": { "path": "/activeTab", "value": "home" } },
   "children": ["home-icon"]
 }
 ```
 
-The `setState` action updates the state model directly, which re-evaluates visibility conditions and dynamic prop expressions.
-
-### State Watchers
-
-React to state changes by triggering actions:
-
-```json
-{
-  "type": "Select",
-  "props": {
-    "value": { "$bindState": "/form/country" },
-    "options": ["US", "Canada", "UK"]
-  },
-  "watch": {
-    "/form/country": {
-      "action": "loadCities",
-      "params": { "country": { "$state": "/form/country" } }
-    }
-  }
-}
-```
-
-`watch` is a top-level field on elements (sibling of `type`/`props`/`children`). Watchers fire when the watched value changes, not on initial render.
+The `setState` action updates the data model directly, which re-evaluates visibility conditions and dynamic prop expressions.
 
 ---
 
@@ -803,18 +242,9 @@ pnpm install
 pnpm dev
 ```
 
-- http://json-render.localhost:1355 - Docs & Playground
-- http://dashboard-demo.json-render.localhost:1355 - Example Dashboard
-- http://react-email-demo.json-render.localhost:1355 - React Email Example
-- http://remotion-demo.json-render.localhost:1355 - Remotion Video Example
-- Chat Example: run `pnpm dev` in `examples/chat`
-- [Experimental Jev composition](https://json-render.dev/docs/jev): use `experimental_composeSpec` and `experimental_createEvaluator` from core with your own catalog, or select **Jev (Experimental)** in `/playground`. Unreleased; source-build instructions are in the guide.
-- Svelte Example: run `pnpm dev` in `examples/svelte` or `examples/svelte-chat`
-- Vue Example: run `pnpm dev` in `examples/vue`
-- Vite Renderers (React + Vue + Svelte + Solid): run `pnpm dev` in `examples/vite-renderers`
-- React Native example: run `npx expo start` in `examples/react-native`
-- Gaussian Splatting (R3F): run `pnpm dev` in `examples/react-three-fiber-gsplat`
-- Gaussian Splatting (experimental standalone gsplat.js demo): run `pnpm dev` in `examples/gsplat`
+- http://localhost:3000 — Docs & Playground
+- http://localhost:3001 — Example Dashboard
+- http://localhost:3002 — Remotion Video Example
 
 ## How It Works
 
@@ -823,16 +253,16 @@ flowchart LR
     A[User Prompt] --> B[AI + Catalog]
     B --> C[JSON Spec]
     C --> D[Renderer]
-
+    
     B -.- E([guardrailed])
     C -.- F([predictable])
     D -.- G([streamed])
 ```
 
-1. **Define the guardrails** - what components, actions, and data bindings AI can use
-2. **Prompt** - describe what you want in natural language
-3. **AI generates JSON** - output is always predictable, constrained to your catalog
-4. **Render fast** - stream and render progressively as the model responds
+1. **Define the guardrails** — what components, actions, and data bindings AI can use
+2. **Users prompt** — end users describe what they want in natural language
+3. **AI generates JSON** — output is always predictable, constrained to your catalog
+4. **Render fast** — stream and render progressively as the model responds
 
 ## License
 

apps/web/.env.example

@@ -3,10 +3,6 @@
 # For local development, get your key from https://vercel.com/ai-gateway
 AI_GATEWAY_API_KEY=
 
-# Dedicated AI Gateway key for the experimental Jev playground option
-# Required locally and on Vercel; no fallback to AI_GATEWAY_API_KEY
-JEV_AI_GATEWAY_API_KEY=
-
 # AI Model Configuration
 # Override the default model used for UI generation
 # Default: anthropic/claude-haiku-4.5
@@ -16,7 +12,3 @@ AI_GATEWAY_MODEL=anthropic/claude-haiku-4.5
 # Automatically populated when you add Vercel KV to your project
 KV_REST_API_URL=
 KV_REST_API_TOKEN=
-
-# Rate Limiting
-# RATE_LIMIT_PER_MINUTE=10
-# RATE_LIMIT_PER_DAY=100

apps/web/.gitignore

@@ -11,7 +11,6 @@
 
 # next.js
 /.next/
-/.source/
 /out/
 
 # production

apps/web/CHANGELOG.md

@@ -1,104 +0,0 @@
-# web
-
-## 0.1.11
-
-### Patch Changes
-
-- Updated dependencies [519a538]
-  - @json-render/core@0.16.0
-  - @json-render/codegen@0.16.0
-  - @json-render/react@0.16.0
-  - @json-render/yaml@0.16.0
-
-## 0.1.10
-
-### Patch Changes
-
-- Updated dependencies [bf3a7ec]
-  - @json-render/core@0.15.0
-  - @json-render/codegen@0.15.0
-  - @json-render/react@0.15.0
-  - @json-render/yaml@0.15.0
-
-## 0.1.9
-
-### Patch Changes
-
-- Updated dependencies [43b7515]
-  - @json-render/core@0.14.1
-  - @json-render/codegen@0.14.1
-  - @json-render/react@0.14.1
-  - @json-render/yaml@0.14.1
-
-## 0.1.8
-
-### Patch Changes
-
-- Updated dependencies [a8afd8b]
-  - @json-render/core@0.14.0
-  - @json-render/yaml@0.14.0
-  - @json-render/codegen@0.14.0
-  - @json-render/react@0.14.0
-
-## 0.1.7
-
-### Patch Changes
-
-- Updated dependencies [5b32de8]
-  - @json-render/core@0.13.0
-  - @json-render/codegen@0.13.0
-  - @json-render/react@0.13.0
-
-## 0.1.6
-
-### Patch Changes
-
-- Updated dependencies [54a1ecf]
-  - @json-render/core@0.12.1
-  - @json-render/codegen@0.12.1
-  - @json-render/react@0.12.1
-
-## 0.1.5
-
-### Patch Changes
-
-- Updated dependencies [63c339b]
-  - @json-render/core@0.12.0
-  - @json-render/codegen@0.12.0
-  - @json-render/react@0.12.0
-
-## 0.1.4
-
-### Patch Changes
-
-- Updated dependencies [3f1e71e]
-  - @json-render/core@0.11.0
-  - @json-render/codegen@0.11.0
-  - @json-render/react@0.11.0
-
-## 0.1.3
-
-### Patch Changes
-
-- Updated dependencies [9cef4e9]
-  - @json-render/core@0.10.0
-  - @json-render/react@0.10.0
-  - @json-render/codegen@0.10.0
-
-## 0.1.2
-
-### Patch Changes
-
-- Updated dependencies [b103676]
-  - @json-render/react@0.9.1
-  - @json-render/core@0.9.1
-  - @json-render/codegen@0.9.1
-
-## 0.1.1
-
-### Patch Changes
-
-- Updated dependencies [1d755c1]
-  - @json-render/core@0.9.0
-  - @json-render/react@0.9.0
-  - @json-render/codegen@0.9.0

apps/web/README.md

@@ -14,11 +14,7 @@ pnpm dev
 bun dev
 ```
 
-Open [http://json-render.localhost:1355](http://json-render.localhost:1355) with your browser to see the result.
-
-## Jev composition experiment
-
-The **default / jev** toggle in `/playground` includes an experimental Jev option; hover or focus its info icon segment for details. It is a reference consumer of core's reusable `experimental_composeSpec` and `experimental_createEvaluator` APIs. It lets Jev compose and edit UI trees from the playground's component catalog and allowed action bindings through Vercel AI Gateway. Set `JEV_AI_GATEWAY_API_KEY` on the server for Jev; the default model uses `AI_GATEWAY_API_KEY`. Follow-ups use the selected version as `initialSpec` and can add, replace, remove, or move elements; earlier versions remain unchanged. It uses the same prompt input, version history, spec/stream inspectors, and functional preview as the default model. The shared `/api/generate` endpoint streams spec patches and decision metadata. See [setup, architecture, and limits](lib/jev/README.md).
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
 
 You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.
 

apps/web/app/(main)/docs/a2ui/page.mdx

@@ -1,6 +1,6 @@
----
-title: "A2UI Integration"
----
+export const metadata = { title: "A2UI Integration" }
+
+# A2UI Integration
 
 Use `@json-render/core` to support [A2UI](https://a2ui.org) natively.
 
@@ -65,8 +65,7 @@ A2UI uses an adjacency list model - a flat list of components with ID references
 ## Define the A2UI Catalog
 
 ```typescript
-import { defineCatalog } from '@json-render/core';
-import { schema } from '@json-render/react/schema';
+import { createCatalog } from '@json-render/core';
 import { z } from 'zod';
 
 // A2UI BoundValue schema
@@ -84,7 +83,7 @@ const Children = z.object({
   }).optional(),
 }).refine(d => d.explicitList || d.template);
 
-export const a2uiCatalog = defineCatalog(schema, {
+export const a2uiCatalog = createCatalog({
   components: {
     Text: {
       description: 'Displays text content',

apps/web/app/(main)/docs/adaptive-cards/page.mdx

@@ -1,6 +1,6 @@
----
-title: "Adaptive Cards Integration"
----
+export const metadata = { title: "Adaptive Cards Integration" }
+
+# Adaptive Cards Integration
 
 Use json-render to render [Microsoft Adaptive Cards](https://adaptivecards.io) natively.
 
@@ -88,8 +88,7 @@ Adaptive Cards is a JSON-based format for platform-agnostic UI snippets. Cards h
 Define a catalog matching the Adaptive Cards element types:
 
 ```typescript
-import { defineCatalog } from '@json-render/core';
-import { schema } from '@json-render/react/schema';
+import { createCatalog } from '@json-render/core';
 import { z } from 'zod';
 
 // Common Adaptive Cards properties
@@ -109,7 +108,7 @@ const BaseElement = {
   spacing: Spacing.optional(),
 };
 
-export const adaptiveCardsCatalog = defineCatalog(schema, {
+export const adaptiveCardsCatalog = createCatalog({
   components: {
     // Root card
     AdaptiveCard: {

apps/web/app/(main)/docs/ag-ui/page.mdx

@@ -1,6 +1,6 @@
----
-title: "AG-UI Integration"
----
+export const metadata = { title: "AG-UI Integration" }
+
+# AG-UI Integration
 
 Use json-render to support [AG-UI](https://docs.copilotkit.ai/ag-ui) (Agent User Interaction Protocol) from CopilotKit.
 
@@ -149,11 +149,10 @@ export type AGUIEvent = z.infer<typeof AGUIEvent>;
 Create a catalog for UI components that agents can render:
 
 ```typescript
-import { defineCatalog } from '@json-render/core';
-import { schema } from '@json-render/react/schema';
+import { createCatalog } from '@json-render/core';
 import { z } from 'zod';
 
-export const aguiCatalog = defineCatalog(schema, {
+export const aguiCatalog = createCatalog({
   components: {
     Container: {
       description: 'A container for grouping elements',

apps/web/app/(main)/docs/ai-sdk/page.mdx

@@ -0,0 +1,97 @@
+export const metadata = { title: "AI SDK Integration" }
+
+# AI SDK Integration
+
+Use json-render with the Vercel AI SDK for seamless streaming.
+
+## Installation
+
+```bash
+npm install ai
+```
+
+## API Route Setup
+
+```typescript
+// app/api/generate/route.ts
+import { streamText } from 'ai';
+import { catalog } from '@/lib/catalog';
+
+export async function POST(req: Request) {
+  const { prompt, currentTree } = await req.json();
+  
+  // Generate system prompt from catalog
+  const systemPrompt = catalog.prompt();
+  
+  // Optionally include current UI state for context
+  const contextPrompt = currentTree 
+    ? `\n\nCurrent UI state:\n${JSON.stringify(currentTree, null, 2)}`
+    : '';
+
+  const result = streamText({
+    model: 'anthropic/claude-haiku-4.5',
+    system: systemPrompt + contextPrompt,
+    prompt,
+  });
+
+  return result.toTextStreamResponse();
+}
+```
+
+## Client-Side Hook
+
+Use `useUIStream` on the client:
+
+```tsx
+'use client';
+
+import { useUIStream, Renderer } from '@json-render/react';
+
+function GenerativeUI() {
+  const { spec, isStreaming, error, send } = useUIStream({
+    api: '/api/generate',
+  });
+
+  return (
+    <div>
+      <button 
+        onClick={() => send('Create a dashboard with metrics')}
+        disabled={isStreaming}
+      >
+        {isStreaming ? 'Generating...' : 'Generate'}
+      </button>
+      
+      {error && <p className="text-red-500">{error.message}</p>}
+      
+      <Renderer spec={spec} registry={registry} loading={isStreaming} />
+    </div>
+  );
+}
+```
+
+## Prompt Engineering
+
+The `catalog.prompt()` method creates an optimized system prompt that:
+
+- Lists all available components and their props
+- Describes available actions
+- Specifies the expected JSON output format
+- Includes examples for better generation
+
+## Custom System Prompts
+
+Pass custom rules to tailor AI behavior:
+
+```typescript
+const systemPrompt = catalog.prompt({
+  customRules: [
+    'Always use Card components for grouping related content',
+    'Prefer horizontal layouts (Row) for metrics',
+    'Use consistent spacing with padding="md"',
+  ],
+});
+```
+
+## Next
+
+Learn about [progressive streaming](/docs/streaming).

apps/web/app/(main)/docs/api/codegen/page.mdx

@@ -1,6 +1,6 @@
----
-title: "@json-render/codegen"
----
+export const metadata = { title: "@json-render/codegen API" }
+
+# @json-render/codegen
 
 Utilities for generating code from UI trees.
 
@@ -13,12 +13,12 @@ Walk the UI spec depth-first.
 ```typescript
 function traverseSpec(
   spec: Spec,
-  visitor: TreeVisitor,
+  visitor: SpecVisitor,
   startKey?: string
 ): void
 
-interface TreeVisitor {
-  (element: UIElement, key: string, depth: number, parent: UIElement | null): void;
+interface SpecVisitor {
+  (element: UIElement, depth: number, parent: UIElement | null): void;
 }
 ```
 
@@ -36,7 +36,7 @@ const components = collectUsedComponents(spec);
 
 ### collectStatePaths
 
-Get all state paths referenced in props (statePath, bindPath, etc.).
+Get all state paths referenced in props (statePath, bindPath, valuePath, etc.).
 
 ```typescript
 function collectStatePaths(spec: Spec): Set<string>
@@ -77,8 +77,8 @@ serializePropValue("hello")
 serializePropValue(42)
 // { value: '42', needsBraces: true }
 
-serializePropValue({ $state: '/user/name' })
-// { value: '{ $state: "/user/name" }', needsBraces: true }
+serializePropValue({ path: 'user/name' })
+// { value: '{ path: "user/name" }', needsBraces: true }
 ```
 
 ### serializeProps

apps/web/app/(main)/docs/api/core/page.mdx

@@ -0,0 +1,440 @@
+export const metadata = { title: "@json-render/core API" }
+
+# @json-render/core
+
+Core types, schemas, and utilities.
+
+## defineCatalog
+
+Creates a type-safe catalog definition with schema validation.
+
+```typescript
+import { defineCatalog } from '@json-render/core';
+import { schema } from '@json-render/react';
+
+function defineCatalog<T extends ZodType>(
+  s: T,
+  config: CatalogConfig
+): Catalog
+
+// Use the React schema for standard UI specs
+const catalog = defineCatalog(schema, {
+  components: {...},
+  actions: {...},
+});
+```
+
+### CatalogConfig
+
+```typescript
+interface CatalogConfig {
+  components: Record<string, ComponentDefinition>;
+  actions?: Record<string, ActionDefinition>;
+  functions?: Record<string, FunctionDefinition>;
+}
+
+interface ComponentDefinition {
+  props: ZodObject;         // Use .nullable() for optional props
+  slots?: string[];         // Named slots (e.g., ["default"])
+  description?: string;     // Help AI understand usage
+}
+
+interface ActionDefinition {
+  params?: ZodObject;
+  description?: string;
+}
+
+interface FunctionDefinition {
+  description?: string;
+}
+```
+
+### Catalog Instance
+
+The returned catalog provides methods for AI prompt generation, validation, and schema export:
+
+```typescript
+interface Catalog {
+  // Data
+  readonly data: CatalogConfig;         // The catalog configuration
+  readonly componentNames: string[];    // List of component names
+  readonly actionNames: string[];       // List of action names
+
+  // AI Prompt Generation
+  prompt(options?: PromptOptions): string;
+
+  // Validation
+  validate(spec: unknown): SpecValidationResult;
+  zodSchema(): z.ZodType;               // Get the Zod schema for specs
+
+  // Export
+  jsonSchema(): object;                 // Export as JSON Schema
+}
+
+interface PromptOptions {
+  system?: string;        // Custom system message intro
+  customRules?: string[]; // Additional rules to append
+}
+
+interface SpecValidationResult<T> {
+  success: boolean;
+  data?: T;               // Validated spec (if success)
+  error?: z.ZodError;     // Validation errors (if failed)
+}
+```
+
+### Catalog Methods
+
+```typescript
+// Generate AI system prompt
+const systemPrompt = catalog.prompt({
+  customRules: ["Always use Card as root element"],
+});
+
+// Validate a spec from AI
+const result = catalog.validate(aiOutput);
+if (result.success) {
+  render(result.data);
+} else {
+  console.error(result.error);
+}
+
+// Get Zod schema for custom validation
+const schema = catalog.zodSchema();
+const parsed = schema.safeParse(aiOutput);
+
+// Export as JSON Schema (for structured outputs)
+const jsonSchema = catalog.jsonSchema();
+```
+
+## Schema System
+
+json-render uses a flexible schema system that defines both the AI output format (spec) and what catalogs must provide. Each renderer package provides its own schema (e.g., @json-render/react exports `schema`).
+
+### schema
+
+The schema for flat UI element trees. This is exported from @json-render/react.
+
+```typescript
+import { defineCatalog } from '@json-render/core';
+import { schema } from '@json-render/react';
+
+// schema defines:
+// - Spec shape: { root: string, elements: Record<string, UIElement> }
+// - Catalog shape: { components: {...}, actions: {...} }
+
+const catalog = defineCatalog(schema, {
+  components: {
+    Card: {
+      props: z.object({ title: z.string() }),
+      slots: ["default"],
+      description: "Container card",
+    },
+  },
+  actions: {
+    submit: {
+      params: z.object({ formId: z.string() }),
+      description: "Submit a form",
+    },
+  },
+});
+```
+
+### defineSchema
+
+Create custom schemas for different output formats (e.g., page-based, block-based).
+
+```typescript
+import { defineSchema } from '@json-render/core';
+
+const mySchema = defineSchema((s) => ({
+  // What the AI outputs (spec)
+  spec: s.object({
+    title: s.string(),
+    blocks: s.array(s.object({
+      type: s.ref("catalog.blocks"),
+      content: s.any(),
+    })),
+  }),
+
+  // What the catalog must provide
+  catalog: s.object({
+    blocks: s.map({
+      props: s.zod(),
+      description: s.string(),
+    }),
+  }),
+}));
+```
+
+### Schema Builder API
+
+The schema builder provides these methods:
+
+```typescript
+// Primitive types
+s.string()           // String value
+s.number()           // Number value
+s.boolean()          // Boolean value
+s.any()              // Any value
+
+// Compound types
+s.array(item)        // Array of items
+s.object({ ... })    // Object with shape
+s.record(value)      // Record/map with value type
+
+// Catalog references (for type safety)
+s.ref("catalog.components")      // Reference to catalog key (becomes enum)
+s.propsOf("catalog.components")  // Props schema from catalog entry
+
+// Catalog definitions
+s.map({ props: s.zod(), ... })   // Map of named entries with shared shape
+s.zod()                          // Placeholder for user-provided Zod schema
+
+// Modifiers
+s.optional()         // Mark field as optional
+```
+
+## Zod Schemas
+
+Pre-built Zod schemas for common json-render types:
+
+### Dynamic Value Schemas
+
+```typescript
+import {
+  DynamicValueSchema,    // string | number | boolean | null | { path: string }
+  DynamicStringSchema,   // string | { path: string }
+  DynamicNumberSchema,   // number | { path: string }
+  DynamicBooleanSchema,  // boolean | { path: string }
+} from '@json-render/core';
+
+// Dynamic values can be literals or data path references
+type DynamicValue<T> = T | { path: string };
+
+// Example: a prop that can be a literal or bound to data
+const schema = z.object({
+  label: DynamicStringSchema,  // "Hello" or { path: "/user/name" }
+});
+```
+
+### Visibility & Logic Schemas
+
+```typescript
+import {
+  VisibilityConditionSchema,  // Full visibility condition
+  LogicExpressionSchema,      // Logic operators (and, or, not, eq, gt, etc.)
+} from '@json-render/core';
+
+// Use in component props that need conditional rendering
+const schema = z.object({
+  visible: VisibilityConditionSchema.optional(),
+});
+```
+
+### Action Schemas
+
+```typescript
+import {
+  ActionSchema,           // Full action definition
+  ActionConfirmSchema,    // Confirmation dialog config
+  ActionOnSuccessSchema,  // Success handler config
+  ActionOnErrorSchema,    // Error handler config
+} from '@json-render/core';
+```
+
+### Validation Schemas
+
+```typescript
+import {
+  ValidationCheckSchema,   // Single validation check
+  ValidationConfigSchema,  // Full validation config with checks array
+} from '@json-render/core';
+```
+
+## SpecStream
+
+SpecStream is json-render's streaming format for progressively building specs from JSONL patches.
+
+### createSpecStreamCompiler
+
+Create a streaming compiler that incrementally builds a spec:
+
+```typescript
+import { createSpecStreamCompiler } from '@json-render/core';
+
+const compiler = createSpecStreamCompiler<MySpec>();
+
+// Process streaming chunks
+const { result, newPatches } = compiler.push(chunk);
+
+// Get final result
+const spec = compiler.getResult();
+
+// Reset for reuse
+compiler.reset();
+```
+
+### compileSpecStream
+
+Compile an entire SpecStream string at once:
+
+```typescript
+import { compileSpecStream } from '@json-render/core';
+
+const jsonl = `{"op":"add","path":"/root","value":{}}
+{"op":"add","path":"/root/type","value":"Card"}`;
+
+const spec = compileSpecStream<MySpec>(jsonl);
+```
+
+### Low-Level Utilities
+
+```typescript
+import {
+  parseSpecStreamLine,
+  applySpecStreamPatch,
+} from '@json-render/core';
+
+// Parse a single line
+const patch = parseSpecStreamLine('{"op":"add","path":"/root","value":{}}');
+
+// Apply patch to object (mutates in place)
+const obj = {};
+applySpecStreamPatch(obj, patch);
+```
+
+### SpecStream Types
+
+Fully compliant with [RFC 6902](https://datatracker.ietf.org/doc/html/rfc6902):
+
+```typescript
+interface SpecStreamLine {
+  op: 'add' | 'remove' | 'replace' | 'move' | 'copy' | 'test';
+  path: string;
+  value?: unknown;  // Required for add, replace, test
+  from?: string;    // Required for move, copy
+}
+
+interface SpecStreamCompiler<T> {
+  push(chunk: string): { result: T; newPatches: SpecStreamLine[] };
+  getResult(): T;
+  getPatches(): SpecStreamLine[];
+  reset(): void;
+}
+```
+
+## Utility Functions
+
+### Path Utilities
+
+```typescript
+import { getByPath, setByPath } from '@json-render/core';
+
+// Get value by JSON Pointer path
+const value = getByPath(data, '/user/name');  // "Alice"
+
+// Set value by path (mutates object)
+setByPath(data, '/user/email', 'alice@example.com');
+```
+
+### resolveDynamicValue
+
+```typescript
+import { resolveDynamicValue } from '@json-render/core';
+
+// Resolve a dynamic value against data
+const name = resolveDynamicValue("Hello", data);        // "Hello"
+const name2 = resolveDynamicValue({ path: "/user/name" }, data);  // "Alice"
+```
+
+### findFormValue
+
+```typescript
+import { findFormValue } from '@json-render/core';
+
+// Find form values regardless of path format
+// Checks: params.name, params["form.name"], data["form.name"], data.form.name
+const value = findFormValue("name", params, data);
+```
+
+## evaluateVisibility
+
+Evaluates a visibility condition against data and auth state.
+
+```typescript
+function evaluateVisibility(
+  condition: VisibilityCondition | undefined,
+  data: Record<string, unknown>,
+  auth?: AuthState
+): boolean
+
+type VisibilityCondition =
+  | { path: string }
+  | { auth: 'signedIn' | 'signedOut' | string }
+  | { and: VisibilityCondition[] }
+  | { or: VisibilityCondition[] }
+  | { not: VisibilityCondition }
+  | { eq: [DynamicValue, DynamicValue] }
+  | { gt: [DynamicValue, DynamicValue] }
+  | { gte: [DynamicValue, DynamicValue] }
+  | { lt: [DynamicValue, DynamicValue] }
+  | { lte: [DynamicValue, DynamicValue] };
+```
+
+## Types
+
+### UIElement
+
+```typescript
+interface UIElement {
+  key: string;
+  type: string;
+  props: Record<string, unknown>;
+  children?: string[];          // Keys of child elements
+  visible?: VisibilityCondition;
+  validation?: ValidationSchema;
+}
+```
+
+### Spec (Element Tree)
+
+```typescript
+interface Spec {
+  root: string | null;         // Key of root element
+  elements: Record<string, UIElement>;
+}
+```
+
+Elements are stored as a flat map with string keys. The tree structure is built by following the `children` arrays.
+
+### Action
+
+```typescript
+interface Action {
+  name: string;
+  params?: Record<string, unknown>;
+  confirm?: {
+    title: string;
+    message: string;
+    variant?: 'default' | 'danger';
+  };
+  onSuccess?: { set: Record<string, unknown> };
+  onError?: { set: Record<string, unknown> };
+}
+```
+
+### ValidationSchema
+
+```typescript
+interface ValidationSchema {
+  checks: ValidationCheck[];
+  validateOn?: 'change' | 'blur' | 'submit';
+}
+
+interface ValidationCheck {
+  fn: string;
+  args?: Record<string, unknown>;
+  message: string;
+}
+```

apps/web/app/(main)/docs/api/react/page.mdx

@@ -0,0 +1,169 @@
+export const metadata = { title: "@json-render/react API" }
+
+# @json-render/react
+
+React components, providers, and hooks.
+
+## Providers
+
+### StateProvider
+
+```tsx
+<StateProvider initialState={object}>
+  {children}
+</StateProvider>
+```
+
+### ActionProvider
+
+```tsx
+<ActionProvider handlers={Record<string, ActionHandler>}>
+  {children}
+</ActionProvider>
+
+type ActionHandler = (params: Record<string, unknown>) => void | Promise<void>;
+```
+
+### VisibilityProvider
+
+```tsx
+<VisibilityProvider auth={AuthState}>
+  {children}
+</VisibilityProvider>
+
+interface AuthState {
+  isSignedIn: boolean;
+  roles?: string[];
+}
+```
+
+### ValidationProvider
+
+```tsx
+<ValidationProvider functions={Record<string, ValidatorFn>}>
+  {children}
+</ValidationProvider>
+
+type ValidatorFn = (value: unknown, args?: object) => boolean | Promise<boolean>;
+```
+
+## defineRegistry
+
+Create a type-safe component registry from a catalog. Components receive `props`, `children`, `onAction`, and `loading` with catalog-inferred types.
+
+```tsx
+import { defineRegistry } from '@json-render/react';
+
+const { registry } = defineRegistry(catalog, {
+  components: {
+    Card: ({ props, children }) => <div>{props.title}{children}</div>,
+    Button: ({ props, onAction }) => (
+      <button onClick={() => onAction?.({ name: props.action })}>
+        {props.label}
+      </button>
+    ),
+  },
+});
+
+// Pass to <Renderer>
+<Renderer spec={spec} registry={registry} />
+```
+
+## Components
+
+### Renderer
+
+```tsx
+<Renderer
+  spec={Spec}           // The UI spec to render
+  registry={Registry}   // Component registry (from defineRegistry)
+  loading={boolean}     // Optional loading state
+  fallback={Component}  // Optional fallback for unknown types
+/>
+
+type Registry = Record<string, React.ComponentType<ComponentRenderProps>>;
+```
+
+### Component Props (via defineRegistry)
+
+```tsx
+interface ComponentContext<P> {
+  props: P;                    // Typed props from catalog
+  children?: React.ReactNode;  // Rendered children (for slot components)
+  onAction?: (action: { name: string; params?: object }) => void;
+  loading?: boolean;
+}
+```
+
+## Hooks
+
+### useUIStream
+
+```typescript
+const {
+  spec,         // Spec | null - current UI state
+  isStreaming,  // boolean - true while streaming
+  error,        // Error | null
+  send,         // (prompt: string, context?: Record<string, unknown>) => Promise<void>
+  clear,        // () => void - reset spec and error
+} = useUIStream({
+  api: string,                         // API endpoint URL
+  onComplete?: (spec: Spec) => void,   // Called when streaming completes
+  onError?: (error: Error) => void,    // Called when an error occurs
+});
+```
+
+### useStateStore
+
+```typescript
+const {
+  data,      // Record<string, unknown>
+  setState,   // (data: object) => void
+  getValue,  // (path: string) => unknown
+  setValue,  // (path: string, value: unknown) => void
+} = useStateStore();
+```
+
+### useStateValue
+
+```typescript
+const value = useStateValue(path: string);
+```
+
+### useStateBinding
+
+```typescript
+const [value, setValue] = useStateBinding(path: string);
+```
+
+### useActions
+
+```typescript
+const { dispatch } = useActions();
+// dispatch(actionName: string, params: object)
+```
+
+### useAction
+
+```typescript
+const submitForm = useAction('submit_form');
+// submitForm(params: object)
+```
+
+### useIsVisible
+
+```typescript
+const isVisible = useIsVisible(condition?: VisibilityCondition);
+```
+
+### useFieldValidation
+
+```typescript
+const {
+  value,     // unknown
+  setValue,  // (value: unknown) => void
+  errors,    // string[]
+  validate,  // () => Promise<boolean>
+  isValid,   // boolean
+} = useFieldValidation(path: string, checks: ValidationCheck[]);
+```

apps/web/app/(main)/docs/api/remotion/page.mdx

@@ -1,6 +1,6 @@
----
-title: "@json-render/remotion"
----
+export const metadata = { title: "@json-render/remotion API" }
+
+# @json-render/remotion
 
 Remotion video renderer. Turn JSON timeline specs into video compositions.
 

apps/web/app/(main)/docs/catalog/page.mdx

@@ -1,12 +1,12 @@
----
-title: "Catalog"
----
+export const metadata = { title: "Catalog" }
+
+# Catalog
 
 The catalog defines what AI can generate. It's your guardrail.
 
 ## What is a Catalog?
 
-A catalog is the vocabulary for your UI. While the [schema](/docs/schemas) defines the grammar (how specs are structured), the catalog defines the vocabulary (what components and actions are available). It lists:
+A catalog is a schema that defines:
 
 - **Components** — UI elements AI can create (with props and optional slots)
 - **Actions** — Operations AI can trigger
@@ -14,12 +14,10 @@ A catalog is the vocabulary for your UI. While the [schema](/docs/schemas) defin
 
 ## Creating a Catalog
 
-`defineCatalog` is from `@json-render/core`. The `schema` import comes from your platform package (`@json-render/react` or `@json-render/react-native`) and defines the element structure the catalog targets. The catalog definition itself is framework-agnostic.
-
 ```typescript
-import { defineCatalog } from "@json-render/core";
-import { schema } from "@json-render/react/schema"; // or '@json-render/react-native/schema'
-import { z } from "zod";
+import { defineCatalog } from '@json-render/core';
+import { schema } from '@json-render/react';
+import { z } from 'zod';
 
 const catalog = defineCatalog(schema, {
   components: {
@@ -28,35 +26,35 @@ const catalog = defineCatalog(schema, {
       props: z.object({
         title: z.string(),
         description: z.string().nullable(),
-        padding: z.enum(["sm", "md", "lg"]).nullable(),
+        padding: z.enum(['sm', 'md', 'lg']).nullable(),
       }),
       slots: ["default"], // Can contain other components
       description: "Container card for grouping content",
     },
-
+    
     Metric: {
       props: z.object({
         label: z.string(),
-        value: z.union([z.string(), z.number()]),
-        format: z.enum(["currency", "percent", "number"]),
+        valuePath: z.string(), // JSON Pointer to data
+        format: z.enum(['currency', 'percent', 'number']),
       }),
       description: "Display a single metric value",
     },
   },
-
+  
   actions: {
     submit_form: {
       params: z.object({
         formId: z.string(),
       }),
-      description: "Submit a form",
+      description: 'Submit a form',
     },
-
+    
     export_data: {
       params: z.object({
-        format: z.enum(["csv", "pdf", "json"]),
+        format: z.enum(['csv', 'pdf', 'json']),
       }),
-      description: "Export data in various formats",
+      description: 'Export data in various formats',
     },
   },
 });
@@ -69,22 +67,12 @@ Each component in the catalog has:
 ```typescript
 {
   props: z.object({...}),  // Zod schema for props (use .nullable() for optional)
-  slots?: string[],        // Available slots (e.g., ["default", "header", "footer"])
+  slots?: string[],        // Named slots for children (e.g., ["default"])
   description?: string,    // Help AI understand when to use it
 }
 ```
 
-Use `"default"` for regular children. Add named slots when a component places content in multiple regions:
-
-```typescript
-Layout: {
-  props: z.object({}),
-  slots: ["default", "header", "footer"],
-  description: "Page layout with header, content, and footer regions",
-}
-```
-
-React specs use `children` for the default slot and a `slots` object for the other names.
+Use `slots: ["default"]` for components that can contain children. The slot name corresponds to where child elements are rendered.
 
 ## Generating AI Prompts
 

apps/web/app/(main)/docs/changelog/page.mdx

@@ -0,0 +1,166 @@
+export const metadata = { title: "Changelog" }
+
+# Changelog
+
+Notable changes and updates to json-render.
+
+## v0.4.0
+
+February 2026
+
+### New: Custom Schema System
+
+Create custom output formats with `defineSchema`. Each renderer now defines its own schema, enabling completely different spec formats for different use cases.
+
+```typescript
+import { defineSchema } from "@json-render/core";
+
+const mySchema = defineSchema((s) => ({
+  spec: s.object({
+    pages: s.array(s.object({
+      title: s.string(),
+      blocks: s.array(s.ref("catalog.blocks")),
+    })),
+  }),
+  catalog: s.object({
+    blocks: s.map({ props: s.zod(), description: s.string() }),
+  }),
+}), {
+  promptTemplate: myPromptTemplate,
+});
+```
+
+### New: Component Slots
+
+Components can now define which slots they accept. Use `["default"]` for regular children, or named slots like `["header", "footer"]` for more complex layouts.
+
+```typescript
+const catalog = defineCatalog(schema, {
+  components: {
+    Card: {
+      props: z.object({ title: z.string() }),
+      slots: ["default"],  // accepts children
+      description: "A card container",
+    },
+    Layout: {
+      props: z.object({}),
+      slots: ["header", "content", "footer"],  // named slots
+      description: "Page layout with header, content, footer",
+    },
+  },
+});
+```
+
+### New: AI Prompt Generation
+
+Catalogs now generate AI system prompts automatically with `catalog.prompt()`. The prompt includes all component definitions, props schemas, and action descriptions - ensuring the AI only generates valid specs.
+
+```typescript
+import { defineCatalog } from "@json-render/core";
+import { schema } from "@json-render/react/schema";
+
+const catalog = defineCatalog(schema, {
+  components: { /* ... */ },
+  actions: { /* ... */ },
+});
+
+// Generate system prompt for AI
+const systemPrompt = catalog.prompt();
+
+// Use with any AI SDK
+const result = await streamText({
+  model: "claude-haiku-4.5",
+  system: systemPrompt,
+  prompt: userMessage,
+});
+```
+
+### New: @json-render/remotion
+
+Generate AI-powered videos with Remotion. Define video catalogs, stream timeline specs, and render with the Remotion Player.
+
+```tsx
+import { Player } from "@remotion/player";
+import { Renderer, schema, standardComponentDefinitions } from "@json-render/remotion";
+
+const catalog = defineCatalog(schema, {
+  components: standardComponentDefinitions,
+  transitions: standardTransitionDefinitions,
+});
+
+<Player
+  component={Renderer}
+  inputProps={{ spec }}
+  durationInFrames={spec.composition.durationInFrames}
+  fps={spec.composition.fps}
+  compositionWidth={spec.composition.width}
+  compositionHeight={spec.composition.height}
+/>
+```
+
+Includes 10 standard video components (TitleCard, TypingText, SplitScreen, etc.), 7 transition types, and the ClipWrapper utility for custom components.
+
+### New: SpecStream
+
+SpecStream is json-render's streaming format for progressively building specs from JSONL patches. The new compiler API makes it easy to process streaming AI responses.
+
+```typescript
+import { createSpecStreamCompiler } from "@json-render/core";
+
+const compiler = createSpecStreamCompiler<MySpec>();
+
+// Process streaming chunks
+const { result, newPatches } = compiler.push(chunk);
+setSpec(result); // Update UI with partial result
+```
+
+### Improved: Dashboard Example
+
+The dashboard example is now a full-featured accounting dashboard with:
+
+- Persistent SQLite database with Drizzle ORM
+- RESTful API for customers, invoices, expenses, accounts
+- Draggable widget reordering
+- AI-powered widget generation with streaming
+- Real data binding to database records
+
+### Improved: Documentation
+
+- Interactive playground for testing specs
+- New guides: Custom Schema, Streaming, Code Export
+- Full API reference for all packages
+- Integration guides: A2UI, AG-UI, Adaptive Cards, OpenAPI
+
+### Breaking Changes
+
+- `UITree` type renamed to `Spec`
+- Schema is now imported from renderer packages (`@json-render/react`) not core
+- `defineCatalog` now requires a schema as first argument
+
+---
+
+## v0.3.0
+
+January 2026
+
+Internal release with codegen foundations.
+
+- Added `@json-render/codegen` package (spec traversal and JSX serialization)
+- Configurable AI model via environment variables
+- Documentation improvements and bug fixes
+
+*Note: Only @json-render/core was published to npm for this release.*
+
+---
+
+## v0.2.0
+
+January 2026
+
+Initial public release.
+
+- Core catalog and spec types
+- React renderer with contexts for data, actions, visibility
+- AI prompt generation from catalogs
+- Basic streaming support
+- Dashboard example application

apps/web/app/(main)/docs/code-export/page.mdx

@@ -1,6 +1,6 @@
----
-title: "Code Export"
----
+export const metadata = { title: "Code Export" }
+
+# Code Export
 
 Export generated UI as standalone code for your framework.
 
@@ -70,12 +70,12 @@ The exported components are standalone with no json-render dependencies. They re
 // Generated component (standalone)
 interface MetricProps {
   label: string;
-  statePath: string;
+  valuePath: string;
   data?: Record<string, unknown>;
 }
 
-export function Metric({ label, statePath, data }: MetricProps) {
-  const value = data ? getByPath(data, statePath) : undefined;
+export function Metric({ label, valuePath, data }: MetricProps) {
+  const value = data ? getByPath(data, valuePath) : undefined;
   return (
     <div>
       <span>{label}</span>
@@ -92,8 +92,8 @@ export function Metric({ label, statePath, data }: MetricProps) {
 ```typescript
 import { traverseSpec } from '@json-render/codegen';
 
-traverseSpec(spec, (element, key, depth, parent) => {
-  console.log(' '.repeat(depth * 2) + `${key}: ${element.type}`);
+traverseSpec(spec, (element, depth, parent) => {
+  console.log(' '.repeat(depth * 2) + element.type);
 });
 ```
 
@@ -134,6 +134,6 @@ Run the dashboard example and click "Export Project" to see code generation in a
 ```bash
 cd examples/dashboard
 pnpm dev
-# Open http://dashboard-demo.json-render.localhost:1355
+# Open http://localhost:3001
 # Generate a widget, then click "Export Project"
 ```

apps/web/app/(main)/docs/custom-schema/page.mdx

@@ -1,6 +1,6 @@
----
-title: "Custom Schema & Renderer"
----
+export const metadata = { title: "Custom Schema & Renderer" }
+
+# Custom Schema & Renderer
 
 Build your own schema and renderer with `@json-render/core`.
 
@@ -41,13 +41,13 @@ Start by defining the JSON structure your system will use. Here's an example of
 
 ## 2. Create the Catalog
 
-Define a catalog that describes your components and validates props using `defineCatalog` — see [Catalog](/docs/catalog).
+Define a catalog that describes your components and validates props:
 
 ```typescript
-import { defineCatalog } from '@json-render/core';
+import { createCatalog } from '@json-render/core';
 import { z } from 'zod';
 
-export const dashboardCatalog = defineCatalog(mySchema, {
+export const dashboardCatalog = createCatalog({
   components: {
     metric: {
       description: 'Displays a single metric value',
@@ -240,9 +240,11 @@ const response = await generateText({
 
 ## 6. Validate Specs
 
-Validate incoming specs against your schema. Use `catalog.validate()` to check AI output against the catalog's Zod schema:
+Validate incoming specs against your schema:
 
 ```typescript
+import { validate } from '@json-render/core';
+
 function validateDashboard(spec: unknown) {
   // Validate root structure
   const rootResult = DashboardSchema.safeParse(spec);
@@ -250,13 +252,19 @@ function validateDashboard(spec: unknown) {
     return { valid: false, errors: rootResult.error.errors };
   }
 
-  // Validate each widget's props against the catalog
-  const result = dashboardCatalog.validate(spec);
-  if (!result.success) {
-    return { valid: false, errors: result.error.errors };
+  // Validate each widget against catalog
+  const errors: string[] = [];
+  for (const widget of rootResult.data.widgets) {
+    const result = validate(
+      { type: widget.type, props: widget },
+      dashboardCatalog
+    );
+    if (!result.valid) {
+      errors.push(...result.errors.map(e => `${widget.type}: ${e}`));
+    }
   }
 
-  return { valid: true, errors: [] };
+  return { valid: errors.length === 0, errors };
 }
 ```
 

apps/web/app/(main)/docs/data-binding/page.mdx

@@ -0,0 +1,124 @@
+export const metadata = { title: "Data Binding" }
+
+# Data Binding
+
+Connect UI components to your application data using JSON Pointer paths.
+
+## JSON Pointer Paths
+
+json-render uses JSON Pointer (RFC 6901) for data paths:
+
+```json
+// Given this data:
+{
+  "user": {
+    "name": "Alice",
+    "email": "alice@example.com"
+  },
+  "metrics": {
+    "revenue": 125000,
+    "growth": 0.15
+  }
+}
+
+// These paths access:
+"/user/name"        -> "Alice"
+"/metrics/revenue"  -> 125000
+"/metrics/growth"   -> 0.15
+```
+
+## StateProvider
+
+Wrap your app with StateProvider to enable data binding:
+
+```tsx
+import { StateProvider } from '@json-render/react';
+
+function App() {
+  const initialState = {
+    user: { name: 'Alice' },
+    form: { email: '', message: '' },
+  };
+
+  return (
+    <StateProvider initialState={initialState}>
+      {/* Your UI */}
+    </StateProvider>
+  );
+}
+```
+
+## Reading Data
+
+Use `useStateValue` for read-only access:
+
+```tsx
+import { useStateValue } from '@json-render/react';
+
+function UserGreeting() {
+  const name = useStateValue('/user/name');
+  return <h1>Hello, {name}!</h1>;
+}
+```
+
+## Two-Way Binding
+
+Use `useStateBinding` for read-write access:
+
+```tsx
+import { useStateBinding } from '@json-render/react';
+
+function EmailInput() {
+  const [email, setEmail] = useStateBinding('/form/email');
+  
+  return (
+    <input
+      type="email"
+      value={email || ''}
+      onChange={(e) => setEmail(e.target.value)}
+    />
+  );
+}
+```
+
+## Using the State Context
+
+Access the full state context for advanced use cases:
+
+```tsx
+import { useStateStore } from '@json-render/react';
+
+function StateDebugger() {
+  const { data, setState, getValue, setValue } = useStateStore();
+  
+  // Read any path
+  const revenue = getValue('/metrics/revenue');
+  
+  // Write any path
+  const updateRevenue = () => setValue('/metrics/revenue', 150000);
+  
+  // Replace all state
+  const resetState = () => setState({ user: {}, form: {} });
+  
+  return <pre>{JSON.stringify(data, null, 2)}</pre>;
+}
+```
+
+## In JSON UI Trees
+
+AI can reference data paths in component props:
+
+```json
+{
+  "type": "Metric",
+  "props": {
+    "label": "Total Revenue",
+    "valuePath": "/metrics/revenue",
+    "format": "currency"
+  }
+}
+```
+
+## Next
+
+Learn about [actions](/docs/actions) for user interactions.

apps/web/app/(main)/docs/installation/page.mdx

@@ -0,0 +1,28 @@
+export const metadata = { title: "Installation" }
+
+# Installation
+
+Install the core package plus your renderer of choice.
+
+## For React UI
+
+<PackageInstall packages="@json-render/core @json-render/react" />
+
+## For Remotion Video
+
+<PackageInstall packages="@json-render/core @json-render/remotion remotion @remotion/player" />
+
+## Peer Dependencies
+
+json-render requires the following peer dependencies:
+
+- `react` ^19.0.0
+- `zod` ^4.0.0
+
+<PackageInstall packages="react zod" />
+
+## For AI Integration
+
+To use json-render with AI models, you'll also need the Vercel AI SDK:
+
+<PackageInstall packages="ai" />

apps/web/app/(main)/docs/layout.tsx

@@ -0,0 +1,31 @@
+import { DocsMobileNav } from "@/components/docs-mobile-nav";
+import { DocsSidebar } from "@/components/docs-sidebar";
+import { CopyPageButton } from "@/components/copy-page-button";
+import { DocsChat } from "@/components/docs-chat";
+
+export default function DocsLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <>
+      <DocsMobileNav />
+      <div className="max-w-5xl mx-auto px-6 py-8 lg:py-12 flex gap-16">
+        {/* Sidebar */}
+        <aside className="w-48 shrink-0 hidden lg:block sticky top-28 h-[calc(100vh-7rem)] overflow-y-auto">
+          <DocsSidebar />
+        </aside>
+
+        {/* Content */}
+        <div className="flex-1 min-w-0 max-w-2xl pb-20">
+          <div className="flex justify-end mb-4">
+            <CopyPageButton />
+          </div>
+          <article>{children}</article>
+        </div>
+      </div>
+      <DocsChat />
+    </>
+  );
+}

apps/web/app/(main)/docs/openapi/page.mdx

@@ -1,6 +1,6 @@
----
-title: "OpenAPI Integration"
----
+export const metadata = { title: "OpenAPI Integration" }
+
+# OpenAPI Integration
 
 Use json-render to generate dynamic forms and UIs from [OpenAPI/Swagger](https://swagger.io/specification/) schemas.
 
@@ -98,11 +98,10 @@ A typical OpenAPI schema for a request body:
 Create components that map to OpenAPI data types:
 
 ```typescript
-import { defineCatalog } from '@json-render/core';
-import { schema } from '@json-render/react/schema';
+import { createCatalog } from '@json-render/core';
 import { z } from 'zod';
 
-export const openapiCatalog = defineCatalog(schema, {
+export const openapiCatalog = createCatalog({
   components: {
     Form: {
       description: 'API form container',

apps/web/app/(main)/docs/page.mdx

@@ -0,0 +1,30 @@
+export const metadata = { title: "Introduction" }
+
+# Introduction
+
+Predictable. Guardrailed. Fast. Let users generate dashboards, widgets, apps, and data visualizations from prompts.
+
+## What is json-render?
+
+json-render lets end users generate UI from natural language prompts — safely constrained to components you define. You set the guardrails: what components exist, what props they take, what actions are available. AI generates JSON that matches your schema, and your components render it natively.
+
+## Why json-render?
+
+### Guardrailed
+
+AI can only use components in your catalog. No arbitrary code generation.
+
+### Predictable
+
+JSON output matches your schema, every time. Actions are declared by name, you control what they do.
+
+### Fast
+
+Stream and render progressively as the model responds. No waiting for completion.
+
+## How it works
+
+1. Define the guardrails — what components, actions, and data bindings AI can use
+2. Users prompt — end users describe what they want in natural language
+3. AI generates JSON — output is always predictable, constrained to your catalog
+4. Render fast — stream and render progressively as the model responds

apps/web/app/(main)/docs/quick-start/page.mdx

@@ -1,6 +1,6 @@
----
-title: "Quick Start"
----
+export const metadata = { title: "Quick Start" }
+
+# Quick Start
 
 Get up and running with json-render in 5 minutes.
 
@@ -11,7 +11,7 @@ Create a catalog that defines what components AI can use:
 ```typescript
 // lib/catalog.ts
 import { defineCatalog } from '@json-render/core';
-import { schema } from '@json-render/react/schema';
+import { schema } from '@json-render/react';
 import { z } from 'zod';
 
 export const catalog = defineCatalog(schema, {
@@ -53,7 +53,7 @@ export const catalog = defineCatalog(schema, {
 
 ## 2. Define your components
 
-Use `defineRegistry` to map catalog types to React components. Each component receives type-safe `props`, `children`, and `emit`:
+Use `defineRegistry` to map catalog types to React components. Each component receives type-safe `props`, `children`, and `onAction`:
 
 ```tsx
 // lib/registry.tsx
@@ -71,10 +71,10 @@ export const { registry } = defineRegistry(catalog, {
         {children}
       </div>
     ),
-    Button: ({ props, emit }) => (
+    Button: ({ props, onAction }) => (
       <button
         className="px-4 py-2 bg-blue-500 text-white rounded"
-        onClick={() => emit("press")}
+        onClick={() => onAction?.({ name: props.action })}
       >
         {props.label}
       </button>
@@ -119,7 +119,7 @@ Use providers and the `Renderer` with your registry to display AI-generated UI:
 // app/page.tsx
 'use client';
 
-import { Renderer, StateProvider, ActionProvider, VisibilityProvider, ValidationProvider, useUIStream } from '@json-render/react';
+import { Renderer, StateProvider, ActionProvider, VisibilityProvider, useUIStream } from '@json-render/react';
 import { registry } from '@/lib/registry';
 
 export default function Page() {
@@ -140,22 +140,20 @@ export default function Page() {
           submit: (params) => console.log('Submit:', params),
           navigate: (params) => console.log('Navigate:', params),
         }}>
-          <ValidationProvider customFunctions={{}}>
-            <form onSubmit={handleSubmit}>
-              <input
-                name="prompt"
-                placeholder="Describe what you want..."
-                className="border p-2 rounded"
-              />
-              <button type="submit" disabled={isStreaming}>
-                Generate
-              </button>
-            </form>
+          <form onSubmit={handleSubmit}>
+            <input
+              name="prompt"
+              placeholder="Describe what you want..."
+              className="border p-2 rounded"
+            />
+            <button type="submit" disabled={isStreaming}>
+              Generate
+            </button>
+          </form>
 
-            <div className="mt-8">
-              <Renderer spec={spec} registry={registry} loading={isStreaming} />
-            </div>
-          </ValidationProvider>
+          <div className="mt-8">
+            <Renderer spec={spec} registry={registry} loading={isStreaming} />
+          </div>
         </ActionProvider>
       </VisibilityProvider>
     </StateProvider>
@@ -163,51 +161,9 @@ export default function Page() {
 }
 ```
 
-## Quick Start with shadcn/ui
-
-If you want to skip defining components from scratch, use `@json-render/shadcn` for 36 pre-built components:
-
-```typescript
-// lib/catalog.ts
-import { defineCatalog } from '@json-render/core';
-import { schema } from '@json-render/react/schema';
-import { shadcnComponentDefinitions } from '@json-render/shadcn/catalog';
-
-export const catalog = defineCatalog(schema, {
-  components: {
-    Card: shadcnComponentDefinitions.Card,
-    Stack: shadcnComponentDefinitions.Stack,
-    Heading: shadcnComponentDefinitions.Heading,
-    Button: shadcnComponentDefinitions.Button,
-    Input: shadcnComponentDefinitions.Input,
-  },
-  actions: {},
-});
-```
-
-```tsx
-// lib/registry.tsx
-import { defineRegistry } from '@json-render/react';
-import { shadcnComponents } from '@json-render/shadcn';
-import { catalog } from './catalog';
-
-export const { registry } = defineRegistry(catalog, {
-  components: {
-    Card: shadcnComponents.Card,
-    Stack: shadcnComponents.Stack,
-    Heading: shadcnComponents.Heading,
-    Button: shadcnComponents.Button,
-    Input: shadcnComponents.Input,
-  },
-});
-```
-
-See the [@json-render/shadcn API reference](/docs/api/shadcn) for the full component list.
-
 ## Next steps
 
 - Learn about [catalogs](/docs/catalog) in depth
 - Explore [data binding](/docs/data-binding) for dynamic values
-- Add [action handlers](/docs/registry#action-handlers) for interactivity
+- Add [actions](/docs/actions) for interactivity
 - Implement [conditional visibility](/docs/visibility)
-- Use [pre-built shadcn/ui components](/docs/api/shadcn) for fast prototyping

apps/web/app/(main)/docs/registry/page.mdx

@@ -0,0 +1,210 @@
+export const metadata = { title: "Registry" }
+
+# Registry
+
+Register React components and action handlers to bring your catalog to life.
+
+## defineRegistry
+
+Use `defineRegistry` to create a type-safe registry from your catalog. Pass your components, actions, or both in a single call:
+
+```tsx
+import { defineRegistry } from '@json-render/react';
+import { myCatalog } from './catalog';
+
+export const { registry, handlers, executeAction } = defineRegistry(myCatalog, {
+  components: {
+    Card: ({ props, children }) => (
+      <div className="card">
+        <h2>{props.title}</h2>
+        {props.description && <p>{props.description}</p>}
+        {children}
+      </div>
+    ),
+
+    Button: ({ props, onAction }) => (
+      <button onClick={() => onAction?.({ name: props.action })}>
+        {props.label}
+      </button>
+    ),
+  },
+
+  actions: {
+    submit_form: async (params, setState) => {
+      const res = await fetch('/api/submit', {
+        method: 'POST',
+        body: JSON.stringify(params),
+      });
+      const result = await res.json();
+      setState((prev) => ({ ...prev, formResult: result }));
+    },
+
+    export_data: async (params) => {
+      const blob = await generateExport(params.format);
+      downloadBlob(blob, `export.${params.format}`);
+    },
+  },
+});
+```
+
+The returned object contains:
+
+- `registry` - component registry for `<Renderer />`
+- `handlers` - factory for ActionProvider-compatible handlers
+- `executeAction` - imperative action dispatch (for use outside the React tree)
+
+## Component Props
+
+Each component in the registry receives a `ComponentContext` object:
+
+```typescript
+interface ComponentContext {
+  props: T;                    // Type-safe props from your catalog
+  children?: React.ReactNode;  // Rendered children (for slot components)
+  onAction?: (action: ActionTrigger) => void;  // Dispatch an action
+  loading?: boolean;           // Whether the renderer is in a loading state
+}
+```
+
+Props are automatically inferred from your catalog, so `props.title` is typed as `string` if your catalog defines it that way.
+
+## Action Handlers
+
+Instead of AI generating arbitrary code, it declares *intent* by name. Your application provides the implementation. This is a core guardrail.
+
+### Defining Actions
+
+Define available actions in your catalog:
+
+```typescript
+import { defineCatalog } from '@json-render/core';
+import { schema } from '@json-render/react';
+import { z } from 'zod';
+
+const catalog = defineCatalog(schema, {
+  components: { /* ... */ },
+  actions: {
+    submit_form: {
+      params: z.object({
+        formId: z.string(),
+      }),
+      description: 'Submit a form',
+    },
+    export_data: {
+      params: z.object({
+        format: z.enum(['csv', 'pdf', 'json']),
+      }),
+    },
+    navigate: {
+      params: z.object({
+        url: z.string(),
+      }),
+    },
+  },
+});
+```
+
+### Implementing Action Handlers
+
+Action handlers receive `(params, setState, data)` and are defined inside `defineRegistry`:
+
+```tsx
+export const { handlers, executeAction } = defineRegistry(catalog, {
+  actions: {
+    submit_form: async (params, setState) => {
+      const response = await fetch('/api/submit', {
+        method: 'POST',
+        body: JSON.stringify({ formId: params.formId }),
+      });
+      const result = await response.json();
+      setState((prev) => ({ ...prev, formResult: result }));
+    },
+
+    export_data: async (params) => {
+      const blob = await generateExport(params.format);
+      downloadBlob(blob, `export.${params.format}`);
+    },
+
+    navigate: (params) => {
+      window.location.href = params.url;
+    },
+  },
+});
+```
+
+## Using Data Binding
+
+Use hooks inside your registry components to read and write data:
+
+```tsx
+import { useStateStore } from '@json-render/react';
+import { getByPath } from '@json-render/core';
+
+// Inside defineRegistry components:
+
+Metric: ({ props }) => {
+  const { data } = useStateStore();
+  const value = getByPath(data, props.valuePath);
+
+  return (
+    <div className="metric">
+      <span className="label">{props.label}</span>
+      <span className="value">{formatValue(value)}</span>
+    </div>
+  );
+},
+
+TextField: ({ props }) => {
+  const { data, set } = useStateStore();
+  const value = getByPath(data, props.valuePath) as string;
+
+  return (
+    <input
+      value={value || ''}
+      onChange={(e) => set(props.valuePath, e.target.value)}
+      placeholder={props.placeholder}
+    />
+  );
+},
+```
+
+## Using the Renderer
+
+Wire everything together with providers and the `<Renderer />` component:
+
+```tsx
+import { useMemo, useRef } from 'react';
+import {
+  Renderer,
+  StateProvider,
+  VisibilityProvider,
+  ActionProvider,
+} from '@json-render/react';
+import { registry, handlers } from './registry';
+
+function App({ spec, data, setState }) {
+  const dataRef = useRef(data);
+  const setStateRef = useRef(setState);
+  dataRef.current = data;
+  setStateRef.current = setState;
+
+  const actionHandlers = useMemo(
+    () => handlers(() => setStateRef.current, () => dataRef.current),
+    [],
+  );
+
+  return (
+    <StateProvider initialState={data}>
+      <VisibilityProvider>
+        <ActionProvider handlers={actionHandlers}>
+          <Renderer spec={spec} registry={registry} />
+        </ActionProvider>
+      </VisibilityProvider>
+    </StateProvider>
+  );
+}
+```
+
+## Next
+
+Learn about [data binding](/docs/data-binding) for dynamic values.

apps/web/app/(main)/docs/schemas/page.mdx

@@ -1,6 +1,6 @@
----
-title: "Schemas"
----
+export const metadata = { title: "Schemas" }
+
+# Schemas
 
 Schemas define the structure and validation rules for your UI specs.
 
@@ -41,7 +41,7 @@ See the [Custom Schema guide](/docs/custom-schema) to learn how to implement sup
     },
     "text-1": {
       "type": "Text",
-      "props": { "content": { "$state": "/user/name" } },
+      "props": { "content": "Welcome, $data.user.name" },
       "children": []
     },
     "button-1": {
@@ -64,27 +64,25 @@ interface Element {
   type: string;                // Component type from catalog
   props: Record<string, any>;  // Component properties
   children: string[];          // Array of child element keys
-  visible?: VisibilityCondition;  // Conditional display
+  visible?: VisibilityRule;    // Conditional display
 }
 ```
 
 ### Data Binding Syntax
 
-Reference dynamic data using `$state` expressions in props. The value is a JSON Pointer path into the state model:
+Reference dynamic data using the `$data` prefix in props:
 
 ```json
 {
   "type": "Text",
   "props": {
-    "content": { "$state": "/user/name" },
-    "count": { "$state": "/items/count" }
+    "content": "$data.user.name",
+    "count": "$data.items.length"
   },
   "children": []
 }
 ```
 
-json-render also supports `$item` and `$index` expressions for lists, two-way binding via `$bindState` / `$bindItem`, and conditional props. See [Data Binding](/docs/data-binding) for the full reference.
-
 ### Action Format
 
 Actions are defined in the catalog and referenced from components. The renderer handles action execution:
@@ -123,7 +121,7 @@ const MyElementSchema = z.object({
 // Define your own data binding format
 const BoundValue = z.object({
   literal: z.string().optional(),
-  source: z.string().optional(),  // e.g., "/users/0/name"
+  path: z.string().optional(),  // e.g., "/users/0/name"
 });
 
 // Define your own action format

apps/web/app/(main)/docs/specs/page.mdx

@@ -1,12 +1,12 @@
----
-title: "Specs"
----
+export const metadata = { title: "Specs" }
+
+# Specs
 
 A spec is a JSON document that describes your UI.
 
 ## What is a Spec?
 
-A spec (specification) is the actual JSON that describes a UI. It uses components from a [catalog](/docs/catalog) and can optionally follow a [schema](/docs/schemas). Specs can be:
+A spec (specification) is the actual JSON that describes a UI. It conforms to a [schema](/docs/schemas) and uses components from a [catalog](/docs/catalog). Specs can be:
 
 - Generated by AI in real-time
 - Stored in a database
@@ -32,7 +32,7 @@ A basic spec using the `@json-render/react` schema. Note the flat structure with
     },
     "text-1": {
       "type": "Text",
-      "props": { "content": { "$state": "/user/greeting" } },
+      "props": { "content": "Hello, $data.user.name!" },
       "children": []
     }
   }
@@ -59,10 +59,7 @@ A more complex spec with multiple nested elements:
     },
     "avatar-1": {
       "type": "Avatar",
-      "props": {
-        "src": { "$state": "/user/avatar" },
-        "alt": { "$state": "/user/name" }
-      },
+      "props": { "src": "$data.user.avatar", "alt": "$data.user.name" },
       "children": []
     },
     "stack-1": {
@@ -72,12 +69,12 @@ A more complex spec with multiple nested elements:
     },
     "name-text": {
       "type": "Text",
-      "props": { "content": { "$state": "/user/name" }, "variant": "heading" },
+      "props": { "content": "$data.user.name", "variant": "heading" },
       "children": []
     },
     "email-text": {
       "type": "Text",
-      "props": { "content": { "$state": "/user/email" }, "variant": "caption" },
+      "props": { "content": "$data.user.email", "variant": "caption" },
       "children": []
     },
     "button-1": {
@@ -104,10 +101,7 @@ A high-level spec using semantic blocks for page layouts:
     },
     "header": {
       "type": "Header",
-      "props": {
-        "logo": "/logo.svg",
-        "navItems": ["Products", "Pricing", "Docs"]
-      },
+      "props": { "logo": "/logo.svg", "navItems": ["Products", "Pricing", "Docs"] },
       "children": []
     },
     "hero": {
@@ -127,37 +121,22 @@ A high-level spec using semantic blocks for page layouts:
     },
     "feature-1": {
       "type": "Feature",
-      "props": {
-        "icon": "zap",
-        "title": "Fast",
-        "description": "Render UIs in milliseconds"
-      },
+      "props": { "icon": "zap", "title": "Fast", "description": "Render UIs in milliseconds" },
       "children": []
     },
     "feature-2": {
       "type": "Feature",
-      "props": {
-        "icon": "shield",
-        "title": "Secure",
-        "description": "Validate all specs against your catalog"
-      },
+      "props": { "icon": "shield", "title": "Secure", "description": "Validate all specs against your catalog" },
       "children": []
     },
     "feature-3": {
       "type": "Feature",
-      "props": {
-        "icon": "sparkles",
-        "title": "AI-Ready",
-        "description": "Generate prompts from your catalog"
-      },
+      "props": { "icon": "sparkles", "title": "AI-Ready", "description": "Generate prompts from your catalog" },
       "children": []
     },
     "footer": {
       "type": "Footer",
-      "props": {
-        "copyright": "2025 Acme Inc",
-        "links": ["Privacy", "Terms", "Contact"]
-      },
+      "props": { "copyright": "2025 Acme Inc", "links": ["Privacy", "Terms", "Contact"] },
       "children": []
     }
   }
@@ -166,11 +145,9 @@ A high-level spec using semantic blocks for page layouts:
 
 ## Spec Anatomy
 
-Specs are schema-agnostic — the JSON structure is entirely up to you. The examples below use the `root` + `elements` flat tree format from the `@json-render/react` schema, which is optimized for AI generation and streaming.
-
 ### Root and Elements
 
-In the React schema, a spec has a `root` key pointing to the entry element, and an `elements` map containing all elements:
+Every spec has a `root` key pointing to the entry element, and an `elements` map containing all elements:
 
 ```json
 {
@@ -194,37 +171,30 @@ Each element in the map has a consistent shape:
 {
   "type": "ComponentName",
   "props": { "label": "Hello" },
-  "children": ["child-1", "child-2"],
-  "slots": {
-    "header": ["heading-1"],
-    "footer": ["actions-1"]
-  }
+  "children": ["child-1", "child-2"]
 }
 ```
 
 - `type` — Component type from your catalog
 - `props` — Component properties
 - `children` — Array of child element keys
-- `slots`: Optional map of named slots to child element keys. Use `children` for the default slot. Named slot rendering is supported by `@json-render/react` and `@json-render/vue`.
 
 ### Dynamic Data
 
-Props can reference data from the state model using `$state` expressions. The value is a JSON Pointer (RFC 6901) path into the state:
+Props can reference data using `$data` paths:
 
 ```json
 {
   "type": "Metric",
   "props": {
     "label": "Total Revenue",
-    "value": { "$state": "/metrics/revenue" },
-    "change": { "$state": "/metrics/revenueChange" }
+    "value": "$data.metrics.revenue",
+    "change": "$data.metrics.revenueChange"
   },
   "children": []
 }
 ```
 
-See [Data Binding](/docs/data-binding) for the full reference including `$item`, `$index`, repeat, and two-way binding.
-
 ### Conditional Visibility
 
 Control when elements appear using the `visible` property:
@@ -237,70 +207,64 @@ Control when elements appear using the `visible` property:
   },
   "children": [],
   "visible": {
-    "$state": "/form/isDirty",
-    "eq": true
+    "path": "$data.form.isDirty",
+    "operator": "eq",
+    "value": true
   }
 }
 ```
 
 ## Working with Specs
 
-### Validating a Spec
-
-Use `validateSpec` from `@json-render/core` to check a spec for structural issues:
-
-```typescript
-import { validateSpec } from "@json-render/core";
-
-const result = validateSpec(spec);
-
-if (!result.valid) {
-  console.error("Invalid spec:", result.issues);
-}
-```
-
-### Rendering a Spec (React)
-
-With `@json-render/react`, wrap the `Renderer` in providers to supply state and visibility:
+### Rendering a Spec
 
 ```tsx
-import {
-  Renderer,
-  StateProvider,
-  VisibilityProvider,
-} from "@json-render/react";
-import { registry } from "./registry";
+import { Renderer } from '@json-render/react';
 
-function MyApp({ spec, initialState }) {
+function MyApp({ spec, data }) {
   return (
-    <StateProvider initialState={initialState}>
-      <VisibilityProvider>
-        <Renderer spec={spec} registry={registry} />
-      </VisibilityProvider>
-    </StateProvider>
+    <Renderer
+      spec={spec}
+      data={data}
+      registry={registry}
+    />
   );
 }
 ```
 
-See the [@json-render/react API reference](/docs/api/react) for full provider and hook documentation.
+### Validating a Spec
 
-### Streaming a Spec (React)
+```typescript
+import { validate } from '@json-render/core';
 
-With `@json-render/react`, use the `useUIStream` hook to stream specs incrementally:
+const result = validate(spec, catalog);
 
-```tsx
-import { useUIStream } from "@json-render/react";
-
-function GenerativeUI() {
-  const { spec, isStreaming } = useUIStream({
-    api: "/api/generate",
-  });
-
-  return <Renderer spec={spec} registry={registry} loading={isStreaming} />;
+if (!result.valid) {
+  console.error('Invalid spec:', result.errors);
 }
 ```
 
-See [Streaming](/docs/streaming) for the full SpecStream format and server-side setup.
+### Streaming Specs
+
+Specs can be streamed incrementally for progressive rendering:
+
+```tsx
+import { useUIStream } from '@json-render/react';
+
+function GenerativeUI() {
+  const { spec, isStreaming } = useUIStream({
+    api: '/api/generate',
+  });
+
+  return (
+    <Renderer
+      spec={spec}
+      registry={registry}
+      loading={isStreaming}
+    />
+  );
+}
+```
 
 ## Spec Sources
 

apps/web/app/(main)/docs/streaming/page.mdx

@@ -1,6 +1,6 @@
----
-title: "Streaming"
----
+export const metadata = { title: "Streaming" }
+
+# Streaming
 
 Progressively render UI as AI generates it.
 
@@ -15,6 +15,28 @@ json-render uses **SpecStream**, a JSONL-based streaming format where each line
 {"op":"add","path":"/elements/metric-2","value":{"type":"Metric","props":{"label":"Users"}}}
 ```
 
+## useUIStream Hook
+
+The hook handles parsing and state management:
+
+```tsx
+import { useUIStream } from '@json-render/react';
+
+function App() {
+  const {
+    spec,          // Current UI spec state
+    isStreaming,   // True while streaming
+    error,         // Any error that occurred
+    send,          // Function to start generation
+    clear,         // Function to reset spec and error
+  } = useUIStream({
+    api: '/api/generate',
+    onComplete: (spec) => {},  // Optional: called when streaming completes
+    onError: (error) => {},    // Optional: called when an error occurs
+  });
+}
+```
+
 ## Patch Operations (RFC 6902)
 
 SpecStream uses [RFC 6902 JSON Patch](https://datatracker.ietf.org/doc/html/rfc6902) operations:
@@ -28,13 +50,13 @@ SpecStream uses [RFC 6902 JSON Patch](https://datatracker.ietf.org/doc/html/rfc6
 
 ## Path Format
 
-Paths follow JSON Pointer (RFC 6901) into the spec object:
+Paths use a key-based format for elements:
 
 ```bash
-/root                       -> Root element key (string)
-/elements/card-1            -> Element with key "card-1"
-/elements/card-1/props      -> Props of card-1
-/elements/card-1/children   -> Children of card-1
+/root              -> Root element
+/root/children     -> Children of root
+/elements/card-1   -> Element with key "card-1"
+/elements/card-1/children -> Children of card-1
 ```
 
 ## Server-Side Setup
@@ -59,77 +81,7 @@ export async function POST(req: Request) {
 }
 ```
 
-## Low-Level SpecStream API
-
-For custom or framework-agnostic streaming implementations, use the SpecStream compiler from `@json-render/core` directly:
-
-```typescript
-import { createSpecStreamCompiler } from '@json-render/core';
-
-// Create a compiler for your spec type
-const compiler = createSpecStreamCompiler<MySpec>();
-const decoder = new TextDecoder();
-
-// Process streaming chunks from AI
-async function processStream(reader: ReadableStreamDefaultReader<Uint8Array>) {
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-
-    // Decode the Uint8Array chunk to a string
-    const chunk = decoder.decode(value, { stream: true });
-    const { result, newPatches } = compiler.push(chunk);
-    
-    if (newPatches.length > 0) {
-      // Update UI with partial result
-      setSpec(result);
-    }
-  }
-  
-  // Get final compiled result
-  return compiler.getResult();
-}
-```
-
-### One-Shot Compilation
-
-For non-streaming scenarios, compile entire SpecStream at once:
-
-```typescript
-import { compileSpecStream } from '@json-render/core';
-
-const jsonl = `{"op":"add","path":"/root","value":"card-1"}
-{"op":"add","path":"/elements/card-1","value":{"type":"Card","props":{"title":"Hello"},"children":[]}}`;
-
-const spec = compileSpecStream<Spec>(jsonl);
-// { root: "card-1", elements: { "card-1": { type: "Card", props: { title: "Hello" }, children: [] } } }
-```
-
-## Usage with React
-
-`@json-render/react` provides the `useUIStream` hook, which wraps the low-level compiler in a React-friendly API with state management, error handling, and abort support.
-
-### useUIStream Hook
-
-```tsx
-import { useUIStream } from '@json-render/react';
-
-function App() {
-  const {
-    spec,          // Current UI spec state
-    isStreaming,   // True while streaming
-    error,         // Any error that occurred
-    send,          // Function to start generation
-    clear,         // Function to reset spec and error
-  } = useUIStream({
-    api: '/api/generate',
-    onComplete: (spec) => {},  // Optional: called when streaming completes
-    onError: (error) => {},    // Optional: called when an error occurs
-  });
-}
-```
-
-### Progressive Rendering
+## Progressive Rendering
 
 The Renderer automatically updates as the spec changes:
 
@@ -146,7 +98,7 @@ function App() {
 }
 ```
 
-### Aborting Streams
+## Aborting Streams
 
 Calling `send` again automatically aborts the previous request. Use `clear` to reset the spec and error state:
 
@@ -167,4 +119,45 @@ function App() {
 }
 ```
 
-See the [@json-render/react API reference](/docs/api/react) for full `useUIStream` documentation.
+## Low-Level SpecStream API
+
+For custom streaming implementations, use the SpecStream compiler directly:
+
+```typescript
+import { createSpecStreamCompiler } from '@json-render/core';
+
+// Create a compiler for your spec type
+const compiler = createSpecStreamCompiler<MySpec>();
+
+// Process streaming chunks from AI
+async function processStream(reader: ReadableStreamDefaultReader) {
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    
+    const { result, newPatches } = compiler.push(value);
+    
+    if (newPatches.length > 0) {
+      // Update UI with partial result
+      setSpec(result);
+    }
+  }
+  
+  // Get final compiled result
+  return compiler.getResult();
+}
+```
+
+### One-Shot Compilation
+
+For non-streaming scenarios, compile entire SpecStream at once:
+
+```typescript
+import { compileSpecStream } from '@json-render/core';
+
+const jsonl = `{"op":"add","path":"/root","value":{"type":"Card"}}
+{"op":"add","path":"/root/props","value":{"title":"Hello"}}`;
+
+const spec = compileSpecStream<MySpec>(jsonl);
+// { root: { type: "Card", props: { title: "Hello" } } }
+```

apps/web/app/(main)/docs/validation/page.mdx

@@ -0,0 +1,146 @@
+export const metadata = { title: "Validation" }
+
+# Validation
+
+Validate form inputs with built-in and custom functions.
+
+## Built-in Validators
+
+json-render includes common validation functions:
+
+- `required` — Value must be non-empty
+- `email` — Valid email format
+- `minLength` — Minimum string length
+- `maxLength` — Maximum string length
+- `pattern` — Match a regex pattern
+- `min` — Minimum numeric value
+- `max` — Maximum numeric value
+
+## Using Validation in JSON
+
+```json
+{
+  "type": "TextField",
+  "props": {
+    "label": "Email",
+    "valuePath": "/form/email",
+    "checks": [
+      { "fn": "required", "message": "Email is required" },
+      { "fn": "email", "message": "Invalid email format" }
+    ],
+    "validateOn": "blur"
+  }
+}
+```
+
+## Validation with Parameters
+
+```json
+{
+  "type": "TextField",
+  "props": {
+    "label": "Password",
+    "valuePath": "/form/password",
+    "checks": [
+      { "fn": "required", "message": "Password is required" },
+      { 
+        "fn": "minLength", 
+        "args": { "length": 8 },
+        "message": "Password must be at least 8 characters"
+      },
+      {
+        "fn": "pattern",
+        "args": { "pattern": "[A-Z]" },
+        "message": "Must contain at least one uppercase letter"
+      }
+    ]
+  }
+}
+```
+
+## Custom Validation Functions
+
+Define custom validators in your catalog:
+
+```typescript
+import { defineCatalog } from '@json-render/core';
+import { schema } from '@json-render/react';
+import { z } from 'zod';
+
+const catalog = defineCatalog(schema, {
+  components: { /* ... */ },
+  functions: {
+    isValidPhone: {
+      description: 'Validates phone number format',
+    },
+    isUniqueEmail: {
+      description: 'Checks if email is not already registered',
+    },
+  },
+});
+```
+
+Then implement them in your ValidationProvider:
+
+```tsx
+import { ValidationProvider } from '@json-render/react';
+
+function App() {
+  const customValidators = {
+    isValidPhone: (value) => {
+      const phoneRegex = /^\+?[1-9]\d{1,14}$/;
+      return phoneRegex.test(value);
+    },
+    isUniqueEmail: async (value) => {
+      const response = await fetch(`/api/check-email?email=${value}`);
+      const { available } = await response.json();
+      return available;
+    },
+  };
+
+  return (
+    <ValidationProvider functions={customValidators}>
+      {/* Your UI */}
+    </ValidationProvider>
+  );
+}
+```
+
+## Using in Components
+
+```tsx
+import { useFieldValidation } from '@json-render/react';
+
+function TextField({ props }) {
+  const { value, setValue, errors, validate } = useFieldValidation(
+    props.valuePath,
+    props.checks
+  );
+
+  return (
+    <div>
+      <label>{props.label}</label>
+      <input
+        value={value || ''}
+        onChange={(e) => setValue(e.target.value)}
+        onBlur={() => validate()}
+      />
+      {errors.map((error, i) => (
+        <p key={i} className="text-red-500 text-sm">{error}</p>
+      ))}
+    </div>
+  );
+}
+```
+
+## Validation Timing
+
+Control when validation runs with `validateOn`:
+
+- `change` — Validate on every input change
+- `blur` — Validate when field loses focus
+- `submit` — Validate only on form submission
+
+## Next
+
+Learn about [AI SDK integration](/docs/ai-sdk).

apps/web/app/(main)/docs/visibility/page.mdx

@@ -0,0 +1,141 @@
+export const metadata = { title: "Visibility" }
+
+# Visibility
+
+Conditionally show or hide components based on data, auth, or logic.
+
+## VisibilityProvider
+
+Wrap your app with VisibilityProvider to enable conditional rendering:
+
+```tsx
+import { VisibilityProvider } from '@json-render/react';
+
+function App() {
+  return (
+    <StateProvider initialState={data}>
+      <VisibilityProvider>
+        {/* Components can now use visibility conditions */}
+      </VisibilityProvider>
+    </StateProvider>
+  );
+}
+```
+
+## Path-Based Visibility
+
+Show/hide based on data values:
+
+```json
+{
+  "type": "Alert",
+  "props": { "message": "Form has errors" },
+  "visible": { "path": "/form/hasErrors" }
+}
+
+// Visible when /form/hasErrors is truthy
+```
+
+## Auth-Based Visibility
+
+Show/hide based on authentication state:
+
+```json
+{
+  "type": "AdminPanel",
+  "visible": { "auth": "signedIn" }
+}
+
+// Options: "signedIn", "signedOut", "admin", etc.
+```
+
+## Logic Expressions
+
+Combine conditions with logic operators:
+
+```json
+// AND - all conditions must be true
+{
+  "type": "SubmitButton",
+  "visible": {
+    "and": [
+      { "path": "/form/isValid" },
+      { "path": "/form/hasChanges" }
+    ]
+  }
+}
+
+// OR - any condition must be true
+{
+  "type": "HelpText",
+  "visible": {
+    "or": [
+      { "path": "/user/isNew" },
+      { "path": "/settings/showHelp" }
+    ]
+  }
+}
+
+// NOT - invert a condition
+{
+  "type": "WelcomeBanner",
+  "visible": {
+    "not": { "path": "/user/hasSeenWelcome" }
+  }
+}
+```
+
+## Comparison Operators
+
+```json
+// Equal
+{
+  "visible": {
+    "eq": [{ "path": "/user/role" }, "admin"]
+  }
+}
+
+// Greater than
+{
+  "visible": {
+    "gt": [{ "path": "/cart/total" }, 100]
+  }
+}
+
+// Available: eq, ne, gt, gte, lt, lte
+```
+
+## Complex Example
+
+```json
+{
+  "type": "RefundButton",
+  "props": { "label": "Process Refund" },
+  "visible": {
+    "and": [
+      { "auth": "signedIn" },
+      { "eq": [{ "path": "/user/role" }, "support"] },
+      { "gt": [{ "path": "/order/amount" }, 0] },
+      { "not": { "path": "/order/isRefunded" } }
+    ]
+  }
+}
+```
+
+## Using in Components
+
+```tsx
+import { useIsVisible } from '@json-render/react';
+
+// The Renderer handles visibility automatically, but you can also use the hook
+function ConditionalContent({ condition, children }) {
+  const isVisible = useIsVisible(condition);
+  
+  if (!isVisible) return null;
+  return <div>{children}</div>;
+}
+```
+
+## Next
+
+Learn about [form validation](/docs/validation).

apps/web/app/(main)/examples/layout.tsx

@@ -1,8 +0,0 @@
-import type { ReactNode } from "react";
-import { pageMetadata } from "@/lib/page-metadata";
-
-export const metadata = pageMetadata("examples");
-
-export default function ExamplesLayout({ children }: { children: ReactNode }) {
-  return children;
-}

apps/web/app/(main)/examples/page.tsx

@@ -1,133 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import { Badge } from "@/components/ui/badge";
-import { examples, allTags, getGitHubUrl, type Example } from "@/lib/examples";
-import { cn } from "@/lib/utils";
-
-function ExampleCard({ example }: { example: Example }) {
-  return (
-    <div className="group flex flex-col rounded-xl border border-border bg-card text-card-foreground overflow-hidden transition-colors hover:border-foreground/25">
-      <div className="flex flex-1 flex-col gap-3 p-5">
-        <h3 className="font-semibold leading-none">{example.title}</h3>
-
-        <p className="text-sm text-muted-foreground leading-relaxed">
-          {example.description}
-        </p>
-
-        <div className="flex flex-wrap gap-1.5">
-          {example.tags.map((tag) => (
-            <Badge key={tag} variant="secondary" className="text-[11px]">
-              {tag}
-            </Badge>
-          ))}
-        </div>
-
-        <div className="mt-auto flex items-center gap-3 pt-2">
-          {example.demoUrl && (
-            <a
-              href={example.demoUrl}
-              target="_blank"
-              rel="noopener noreferrer"
-              className="inline-flex items-center gap-1.5 text-sm text-foreground hover:text-primary transition-colors"
-            >
-              <svg
-                xmlns="http://www.w3.org/2000/svg"
-                width="14"
-                height="14"
-                viewBox="0 0 24 24"
-                fill="none"
-                stroke="currentColor"
-                strokeWidth="2"
-                strokeLinecap="round"
-                strokeLinejoin="round"
-              >
-                <path d="M15 3h6v6" />
-                <path d="M10 14 21 3" />
-                <path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6" />
-              </svg>
-              Live Demo
-            </a>
-          )}
-          <a
-            href={getGitHubUrl(example)}
-            target="_blank"
-            rel="noopener noreferrer"
-            className="inline-flex items-center gap-1.5 text-sm text-muted-foreground hover:text-foreground transition-colors"
-          >
-            <svg
-              viewBox="0 0 16 16"
-              className="h-3.5 w-3.5"
-              fill="currentColor"
-              aria-hidden="true"
-            >
-              <path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z" />
-            </svg>
-            Source
-          </a>
-        </div>
-      </div>
-    </div>
-  );
-}
-
-export default function ExamplesPage() {
-  const [activeTag, setActiveTag] = useState<string | null>(null);
-
-  const filtered = activeTag
-    ? examples.filter((e) => e.tags.includes(activeTag))
-    : examples;
-
-  return (
-    <section className="mx-auto max-w-6xl px-6 py-16">
-      <div className="mb-10">
-        <h1 className="text-3xl font-bold tracking-tight sm:text-4xl">
-          Examples
-        </h1>
-        <p className="mt-3 text-lg text-muted-foreground">
-          Explore json-render across frameworks, renderers, and use cases.
-        </p>
-      </div>
-
-      <div className="mb-8 flex flex-wrap gap-2">
-        <button
-          onClick={() => setActiveTag(null)}
-          className={cn(
-            "rounded-full border px-3 py-1 text-xs font-medium transition-colors",
-            activeTag === null
-              ? "border-foreground bg-foreground text-background"
-              : "border-border text-muted-foreground hover:text-foreground hover:border-foreground/50",
-          )}
-        >
-          All
-        </button>
-        {allTags.map((tag) => (
-          <button
-            key={tag}
-            onClick={() => setActiveTag(activeTag === tag ? null : tag)}
-            className={cn(
-              "rounded-full border px-3 py-1 text-xs font-medium transition-colors",
-              activeTag === tag
-                ? "border-foreground bg-foreground text-background"
-                : "border-border text-muted-foreground hover:text-foreground hover:border-foreground/50",
-            )}
-          >
-            {tag}
-          </button>
-        ))}
-      </div>
-
-      <div className="grid gap-6 sm:grid-cols-2 lg:grid-cols-3">
-        {filtered.map((example) => (
-          <ExampleCard key={example.slug} example={example} />
-        ))}
-      </div>
-
-      {filtered.length === 0 && (
-        <p className="py-12 text-center text-muted-foreground">
-          No examples match the selected filter.
-        </p>
-      )}
-    </section>
-  );
-}

apps/web/app/(main)/layout.tsx

@@ -1,7 +1,14 @@
+import { Header } from "@/components/header";
+
 export default function MainLayout({
   children,
 }: {
   children: React.ReactNode;
 }) {
-  return <main className="min-h-[calc(100dvh-4rem)]">{children}</main>;
+  return (
+    <div className="min-h-screen flex flex-col">
+      <Header />
+      <main className="flex-1">{children}</main>
+    </div>
+  );
 }

apps/web/app/(main)/page.tsx

@@ -9,16 +9,12 @@ export default function Home() {
     <>
       {/* Hero */}
       <section className="max-w-5xl mx-auto px-6 pt-24 pb-16 text-center">
-        <p className="text-xs sm:text-sm font-medium text-muted-foreground tracking-widest uppercase mb-4">
-          The Generative UI Framework
-        </p>
-        <h1 className="text-4xl sm:text-6xl md:text-7xl font-bold tracking-tighter mb-6">
+        <h1 className="text-5xl sm:text-6xl md:text-7xl font-bold tracking-tighter mb-6">
           AI → json-render → UI
         </h1>
         <p className="text-lg text-muted-foreground max-w-2xl mx-auto mb-12 leading-relaxed">
-          Generate dynamic, personalized UIs from prompts without sacrificing
-          reliability. Predefined components and actions for safe, predictable
-          output.
+          Define a component catalog. Users prompt. AI outputs JSON constrained
+          to your catalog. Your components render it.
         </p>
 
         <Demo />
@@ -69,10 +65,10 @@ export default function Home() {
               <div className="text-xs text-muted-foreground font-mono mb-3">
                 02
               </div>
-              <h3 className="text-lg font-semibold mb-2">AI Generates</h3>
+              <h3 className="text-lg font-semibold mb-2">Users Prompt</h3>
               <p className="text-sm text-muted-foreground leading-relaxed">
-                Describe what you want. AI generates JSON constrained to your
-                catalog. Every interface is unique.
+                End users describe what they want. AI generates JSON constrained
+                to your catalog.
               </p>
             </div>
             <div>
@@ -100,12 +96,10 @@ export default function Home() {
               <p className="text-muted-foreground mb-6">
                 Components, actions, and validation functions.
               </p>
-              <Code lang="typescript">{`import { defineSchema, defineCatalog } from '@json-render/core';
+              <Code lang="typescript">{`import { createCatalog } from '@json-render/core';
 import { z } from 'zod';
 
-const schema = defineSchema({ /* ... */ });
-
-export const catalog = defineCatalog(schema, {
+export const catalog = createCatalog({
   components: {
     Card: {
       props: z.object({
@@ -117,7 +111,7 @@ export const catalog = defineCatalog(schema, {
     Metric: {
       props: z.object({
         label: z.string(),
-        statePath: z.string(),
+        valuePath: z.string(),
         format: z.enum(['currency', 'percent']),
       }),
     },
@@ -146,7 +140,7 @@ export const catalog = defineCatalog(schema, {
       "type": "Metric",
       "props": {
         "label": "Total Revenue",
-        "statePath": "/metrics/revenue",
+        "valuePath": "/metrics/revenue",
         "format": "currency"
       }
     }
@@ -185,7 +179,7 @@ export const catalog = defineCatalog(schema, {
       "type": "Metric",
       "props": {
         "label": "Total Revenue",
-        "statePath": "analytics/revenue",
+        "valuePath": "analytics/revenue",
         "format": "currency"
       }
     },
@@ -225,7 +219,7 @@ export default function Page() {
       <Metric
         data={data}
         label="Total Revenue"
-        statePath="analytics/revenue"
+        valuePath="analytics/revenue"
         format="currency"
       />
       <Chart data={data} statePath="analytics/salesByRegion" />
@@ -250,10 +244,6 @@ export default function Page() {
           <h2 className="text-2xl font-semibold mb-12 text-center">Features</h2>
           <div className="grid sm:grid-cols-2 lg:grid-cols-3 gap-8">
             {[
-              {
-                title: "Generative UI",
-                desc: "Generate dynamic, personalized interfaces from prompts with AI",
-              },
               {
                 title: "Guardrails",
                 desc: "AI can only use components you define in the catalog",
@@ -263,16 +253,20 @@ export default function Page() {
                 desc: "Progressive rendering as JSON streams from the model",
               },
               {
-                title: "React & React Native",
-                desc: "Render on web and mobile from the same catalog and spec format",
+                title: "Code Export",
+                desc: "Export as standalone React code with no runtime dependencies",
               },
               {
                 title: "Data Binding",
-                desc: "Connect props to state with $state, $item, $index, and two-way binding",
+                desc: "Two-way binding with JSON Pointer paths",
               },
               {
-                title: "Code Export",
-                desc: "Export as standalone React code with no runtime dependencies",
+                title: "Actions",
+                desc: "Named actions handled by your application",
+              },
+              {
+                title: "Visibility",
+                desc: "Conditional show/hide based on data or auth",
               },
             ].map((feature) => (
               <div key={feature.title}>

apps/web/app/[lang]/docs/[[...slug]]/page.tsx

@@ -1,43 +0,0 @@
-import { MobileDocsBar } from "@vercel/geistdocs/mobile-docs-bar";
-import { createDocsPage } from "@vercel/geistdocs/pages/docs";
-import { notFound } from "next/navigation";
-import { GenerationModesDiagram } from "@/components/generation-modes-diagram";
-import { PackageInstall } from "@/components/package-install";
-import { isSafePathSegments } from "@/lib/docs-source";
-import { config } from "@/lib/geistdocs/config";
-import { geistdocsSource } from "@/lib/geistdocs/source";
-import { pageMetadata } from "@/lib/page-metadata";
-
-type PageProps = { params: Promise<{ lang: string; slug?: string[] }> };
-
-async function validate(params: PageProps["params"]) {
-  const resolved = await params;
-  if (resolved.lang !== "en" || !isSafePathSegments(resolved.slug ?? []))
-    notFound();
-  try {
-    if (!geistdocsSource.source.getPage(resolved.slug, resolved.lang))
-      notFound();
-  } catch (error) {
-    if (error instanceof URIError) notFound();
-    throw error;
-  }
-  return resolved;
-}
-
-const docsPage = createDocsPage({
-  config,
-  source: geistdocsSource,
-  mdx: { GenerationModesDiagram, PackageInstall },
-  renderTop: ({ data }) => <MobileDocsBar toc={data.toc} />,
-});
-
-export default async function Page({ params }: PageProps) {
-  return <docsPage.Page params={Promise.resolve(await validate(params))} />;
-}
-
-export async function generateMetadata({ params }: PageProps) {
-  const { slug = [] } = await validate(params);
-  return pageMetadata(["docs", ...slug].join("/"));
-}
-
-export const generateStaticParams = docsPage.generateStaticParams;

apps/web/app/[lang]/docs/layout.tsx

@@ -1,25 +0,0 @@
-import type { ReactNode } from "react";
-import { notFound } from "next/navigation";
-import { GeistdocsDocsLayout } from "@vercel/geistdocs/layout";
-import { config } from "@/lib/geistdocs/config";
-import { geistdocsSource } from "@/lib/geistdocs/source";
-
-export default async function DocsLayout({
-  children,
-  params,
-}: {
-  children: ReactNode;
-  params: Promise<{ lang: string }>;
-}) {
-  const { lang } = await params;
-  if (lang !== "en") notFound();
-  return (
-    <GeistdocsDocsLayout
-      config={config}
-      tree={geistdocsSource.source.getPageTree(lang)}
-      containerProps={{ className: "mx-auto max-w-[1448px]" }}
-    >
-      {children}
-    </GeistdocsDocsLayout>
-  );
-}

apps/web/app/api/docs-chat/route.ts

@@ -1,8 +1,11 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
 import { convertToModelMessages, stepCountIs, streamText } from "ai";
 import type { ModelMessage, UIMessage } from "ai";
 import { createBashTool } from "bash-tool";
 import { headers } from "next/headers";
-import { loadAllDocsSources } from "@/lib/docs-source";
+import { allDocsPages } from "@/lib/docs-navigation";
+import { mdxToCleanMarkdown } from "@/lib/mdx-to-markdown";
 import { minuteRateLimit, dailyRateLimit } from "@/lib/rate-limit";
 
 export const maxDuration = 60;
@@ -13,31 +16,50 @@ const SYSTEM_PROMPT = `You are a helpful documentation assistant for json-render
 
 GitHub repository: https://github.com/vercel-labs/json-render
 Documentation: https://json-render.dev/docs
-npm packages: @json-render/core, @json-render/react, @json-render/next, @json-render/tanstack-start, @json-render/ink, @json-render/vue, @json-render/svelte, @json-render/solid, @json-render/shadcn, @json-render/shadcn-svelte, @json-render/react-three-fiber, @json-render/react-native, @json-render/react-email, @json-render/react-pdf, @json-render/image, @json-render/remotion, @json-render/directives, @json-render/codegen, @json-render/devtools, @json-render/devtools-react, @json-render/devtools-vue, @json-render/devtools-svelte, @json-render/devtools-solid, @json-render/mcp, @json-render/redux, @json-render/zustand, @json-render/jotai, @json-render/xstate, @json-render/yaml
-Skills: json-render ships AI agent skills that teach coding agents how to use each package. Install with "npx skills add vercel-labs/json-render --skill <name>". Available skills: core, react, next, tanstack-start, ink, react-pdf, react-email, react-native, shadcn, shadcn-svelte, react-three-fiber, image, remotion, vue, svelte, solid, directives, codegen, devtools, devtools-react, devtools-vue, devtools-svelte, devtools-solid, mcp, redux, zustand, jotai, xstate, yaml. See /docs/skills for details.
+npm packages: @json-render/core, @json-render/react, @json-render/remotion, @json-render/codegen
 
-Experimental Jev composition: core exports experimental_composeSpec and experimental_createEvaluator for app-owned catalogs/candidates through Vercel AI Gateway. See /docs/jev for availability, source-build setup, and limits; do not assume the currently published npm version includes it.
-
-You have access to the full json-render documentation via the bash and readFile tools. The docs are available as markdown files in the /workspace/docs/ directory.
+You have access to the full json-render documentation via the bash and readFile tools. The docs are available as markdown files in the /docs/ directory.
 
 When answering questions:
-- Use the bash tool to list files (ls /workspace/docs/) or search for content (grep -r "keyword" /workspace/docs/)
-- Use the readFile tool to read specific documentation pages (e.g. readFile with path "/workspace/docs/index.md")
-- Do NOT use bash to write, create, modify, or delete files (no tee, cat >, sed -i, echo >, cp, mv, rm, mkdir, touch, etc.) — you are read-only
+- Use the bash tool to list files (ls /docs/) or search for content (grep -r "keyword" /docs/)
+- Use the readFile tool to read specific documentation pages
 - Always base your answers on the actual documentation content
 - Be concise and accurate
 - If the docs don't cover a topic, say so honestly
-- Do NOT include source references or file paths in your response
-- Do NOT use emojis in your responses`;
+- Do NOT include source references or file paths in your response`;
 
 async function loadDocsFiles(): Promise<Record<string, string>> {
-  const pages = await loadAllDocsSources();
-  return Object.fromEntries(
-    pages.map((page) => [
-      page.href === "/docs" ? "/docs/index.md" : `${page.href}.md`,
-      page.markdown,
-    ]),
+  const files: Record<string, string> = {};
+
+  const results = await Promise.allSettled(
+    allDocsPages.map(async (page) => {
+      const slug =
+        page.href === "/docs" ? "" : page.href.replace(/^\/docs\/?/, "");
+      const filePath = slug
+        ? join(
+            process.cwd(),
+            "app",
+            "(main)",
+            "docs",
+            ...slug.split("/"),
+            "page.mdx",
+          )
+        : join(process.cwd(), "app", "(main)", "docs", "page.mdx");
+
+      const raw = await readFile(filePath, "utf-8");
+      const md = mdxToCleanMarkdown(raw);
+      const fileName = slug ? `/docs/${slug}.md` : "/docs/index.md";
+      return { fileName, md };
+    }),
   );
+
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      files[result.value.fileName] = result.value.md;
+    }
+  }
+
+  return files;
 }
 
 function addCacheControl(messages: ModelMessage[]): ModelMessage[] {
@@ -84,19 +106,14 @@ export async function POST(req: Request) {
   const { messages }: { messages: UIMessage[] } = await req.json();
 
   const docsFiles = await loadDocsFiles();
-  const {
-    tools: { bash, readFile },
-  } = await createBashTool({ files: docsFiles });
+  const { tools } = await createBashTool({ files: docsFiles });
 
   const result = streamText({
     model: DEFAULT_MODEL,
     system: SYSTEM_PROMPT,
     messages: await convertToModelMessages(messages),
     stopWhen: stepCountIs(5),
-    tools: {
-      bash,
-      readFile,
-    },
+    tools,
     prepareStep: ({ messages: stepMessages }) => ({
       messages: addCacheControl(stepMessages),
     }),

apps/web/app/api/docs-markdown/route.ts

@@ -1,25 +1,55 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
 import { NextRequest, NextResponse } from "next/server";
-import { loadDocsSource } from "@/lib/docs-source";
+import { mdxToCleanMarkdown } from "@/lib/mdx-to-markdown";
 
 export async function GET(req: NextRequest) {
-  const docPath = req.nextUrl.searchParams.get("path");
-  if (!docPath)
+  const { searchParams } = new URL(req.url);
+  const docPath = searchParams.get("path");
+
+  if (!docPath) {
     return NextResponse.json(
       { error: "Missing ?path= parameter" },
       { status: 400 },
     );
-  const path = docPath.startsWith("/") ? docPath : `/${docPath}`;
-  if (!/^\/docs(?:\/[a-zA-Z0-9_-]+)*\/?$/.test(path)) {
+  }
+
+  // Sanitize path: only allow docs paths, no traversal
+  const normalized = docPath
+    .replace(/^\//, "")
+    .replace(/\.\./g, "")
+    .replace(/[^a-zA-Z0-9/-]/g, "");
+
+  if (!normalized.startsWith("docs")) {
     return NextResponse.json({ error: "Invalid path" }, { status: 400 });
   }
-  const page = await loadDocsSource(path);
-  if (!page)
+
+  // Map URL path to file path
+  // /docs -> /app/(main)/docs/page.mdx
+  // /docs/installation -> /app/(main)/docs/installation/page.mdx
+  const slug = normalized === "docs" ? "" : normalized.replace(/^docs\/?/, "");
+  const filePath = slug
+    ? join(
+        process.cwd(),
+        "app",
+        "(main)",
+        "docs",
+        ...slug.split("/"),
+        "page.mdx",
+      )
+    : join(process.cwd(), "app", "(main)", "docs", "page.mdx");
+
+  try {
+    const raw = await readFile(filePath, "utf-8");
+    const markdown = mdxToCleanMarkdown(raw);
+
+    return new NextResponse(markdown, {
+      headers: {
+        "Content-Type": "text/markdown; charset=utf-8",
+        "Cache-Control": "public, max-age=3600",
+      },
+    });
+  } catch {
     return NextResponse.json({ error: "Page not found" }, { status: 404 });
-  return new NextResponse(page.markdown, {
-    headers: {
-      "Content-Type": "text/markdown; charset=utf-8",
-      "Cache-Control": "public, max-age=3600",
-      Link: `<${page.canonicalUrl}>; rel="canonical"`,
-    },
-  });
+  }
 }

apps/web/app/api/docs-md/[[...slug]]/route.ts

@@ -1,21 +0,0 @@
-import { loadDocsSource, isSafePathSegments } from "@/lib/docs-source";
-import { applyDocsResponseHeaders } from "@/lib/docs-response-headers";
-
-export async function GET(
-  _request: Request,
-  { params }: { params: Promise<{ slug?: string[] }> },
-) {
-  const { slug = [] } = await params;
-  const path = `/docs${slug.length ? `/${slug.join("/")}` : ""}`;
-  const page = isSafePathSegments(slug) ? await loadDocsSource(path) : null;
-  const headers = new Headers({
-    "Content-Type": "text/markdown; charset=utf-8",
-  });
-  applyDocsResponseHeaders(headers);
-  if (page) headers.set("Link", `<${page.canonicalUrl}>; rel="canonical"`);
-  return new Response(
-    page?.markdown ??
-      "# Page Not Found\n\nSee [the documentation index](/llms.txt).\n",
-    { status: page ? 200 : 404, headers },
-  );
-}

apps/web/app/api/generate/route.ts

@@ -1,77 +1,31 @@
 import { streamText } from "ai";
 import { headers } from "next/headers";
-import type { Spec, EditMode } from "@json-render/core";
-import {
-  buildUserPrompt,
-  buildEditUserPrompt,
-  isNonEmptySpec,
-} from "@json-render/core";
-import { yamlPrompt } from "@json-render/yaml";
-import { stringify as yamlStringify } from "yaml";
+import { buildUserPrompt } from "@json-render/core";
 import { minuteRateLimit, dailyRateLimit } from "@/lib/rate-limit";
 import { playgroundCatalog } from "@/lib/render/catalog";
-import { createCompositionResponse } from "@/lib/jev/response";
 
-export const maxDuration = 60;
+export const maxDuration = 30;
 
-const PLAYGROUND_RULES = [
-  "NEVER use viewport height classes (min-h-screen, h-screen) - the UI renders inside a fixed-size container.",
-  "NEVER use page background colors (bg-gray-50) - the container has its own background.",
-  "For forms or small UIs: use Card as root with maxWidth:'sm' or 'md' and centered:true.",
-  "For content-heavy UIs (blogs, dashboards, product listings): use Stack or Grid as root. Use Grid with 2-3 columns for card layouts. Keep the total UI compact — avoid sprawling multi-section pages. Prefer a single focused Card over a full page layout.",
-  "Wrap each repeated item in a Card for visual separation and structure.",
-  "Use realistic, professional sample data. Include 3-5 items with varied content. Never leave state arrays empty.",
-  'For form inputs (Input, Textarea, Select), always include checks for validation (e.g. required, email, minLength). Always pair checks with a $bindState expression on the value prop (e.g. { "$bindState": "/path" }).',
-  "NEVER use emoji characters. Use the Icon component with Lucide icon names instead. For example, use Icon with name:'MapPin' instead of a pin emoji, Icon with name:'Mail' instead of an envelope emoji, etc.",
-  "For icon+label patterns, use a horizontal Stack with gap:'sm' and align:'center' containing an Icon and a Text.",
-  "For any tabular or list data with consistent columns (items, orders, stats), ALWAYS use the Table component. Never simulate tables with Stacks — the columns won't align.",
-];
+const SYSTEM_PROMPT = playgroundCatalog.prompt({
+  customRules: [
+    "NEVER use viewport height classes (min-h-screen, h-screen) - the UI renders inside a fixed-size container.",
+    "NEVER use page background colors (bg-gray-50) - the container has its own background.",
+    "For forms or small UIs: use Card as root with maxWidth:'sm' or 'md' and centered:true.",
+    "For content-heavy UIs (blogs, dashboards, product listings): use Stack or Grid as root. Use Grid with 2-3 columns for card layouts.",
+    "Wrap each repeated item in a Card for visual separation and structure.",
+    "Use realistic, professional sample data. Include 3-5 items with varied content. Never leave state arrays empty.",
+  ],
+});
 
 const MAX_PROMPT_LENGTH = 500;
 const DEFAULT_MODEL = "anthropic/claude-haiku-4.5";
 
-function getSystemPrompt(isYaml: boolean, editModes?: EditMode[]): string {
-  if (isYaml) {
-    return yamlPrompt(playgroundCatalog, {
-      mode: "standalone",
-      customRules: PLAYGROUND_RULES,
-      editModes: editModes ?? ["merge"],
-    });
-  }
-  return playgroundCatalog.prompt({
-    customRules: PLAYGROUND_RULES,
-    editModes,
-  });
-}
-
-function buildYamlUserPrompt(
-  prompt: string,
-  previousSpec?: Spec | null,
-  editModes?: EditMode[],
-): string {
-  if (isNonEmptySpec(previousSpec)) {
-    return buildEditUserPrompt({
-      prompt,
-      currentSpec: previousSpec,
-      config: { modes: editModes ?? ["merge"] },
-      format: "yaml",
-      maxPromptLength: MAX_PROMPT_LENGTH,
-      serializer: (s) => yamlStringify(s, { indent: 2 }).trimEnd(),
-    });
-  }
-
-  const userText = prompt.slice(0, MAX_PROMPT_LENGTH);
-  return [
-    userText,
-    "",
-    "Output the full spec in a ```yaml-spec fence. Stream progressively — output elements one at a time.",
-  ].join("\n");
-}
-
 export async function POST(req: Request) {
+  // Get client IP for rate limiting
   const headersList = await headers();
   const ip = headersList.get("x-forwarded-for")?.split(",")[0] ?? "anonymous";
 
+  // Check rate limits (minute and daily)
   const [minuteResult, dailyResult] = await Promise.all([
     minuteRateLimit.limit(ip),
     dailyRateLimit.limit(ip),
@@ -93,37 +47,22 @@ export async function POST(req: Request) {
     );
   }
 
-  const { prompt, context, format, editModes, model } = await req.json();
-  if (model === "typesafe-ai/jev")
-    return createCompositionResponse(req, prompt, context?.previousSpec);
-  const isYaml = format === "yaml";
+  const { prompt, context } = await req.json();
 
-  const systemPrompt = getSystemPrompt(isYaml, editModes);
-  const userPrompt = isYaml
-    ? buildYamlUserPrompt(prompt, context?.previousSpec, editModes)
-    : buildUserPrompt({
-        prompt,
-        currentSpec: context?.previousSpec,
-        maxPromptLength: MAX_PROMPT_LENGTH,
-        editModes,
-      });
+  const userPrompt = buildUserPrompt({
+    prompt,
+    currentSpec: context?.previousSpec,
+    maxPromptLength: MAX_PROMPT_LENGTH,
+  });
 
   const result = streamText({
     model: process.env.AI_GATEWAY_MODEL || DEFAULT_MODEL,
-    abortSignal: req.signal,
-    system: [
-      {
-        role: "system",
-        content: systemPrompt,
-        providerOptions: {
-          anthropic: { cacheControl: { type: "ephemeral" } },
-        },
-      },
-    ],
+    system: SYSTEM_PROMPT,
     prompt: userPrompt,
     temperature: 0.7,
   });
 
+  // Stream the text, then append token usage metadata at the end
   const encoder = new TextEncoder();
   const textStream = result.textStream;
 
@@ -132,6 +71,7 @@ export async function POST(req: Request) {
       for await (const chunk of textStream) {
         controller.enqueue(encoder.encode(chunk));
       }
+      // Append usage metadata after stream completes
       try {
         const usage = await result.usage;
         const meta = JSON.stringify({
@@ -139,12 +79,10 @@ export async function POST(req: Request) {
           promptTokens: usage.inputTokens,
           completionTokens: usage.outputTokens,
           totalTokens: usage.totalTokens,
-          cachedTokens: usage.inputTokenDetails?.cacheReadTokens ?? 0,
-          cacheWriteTokens: usage.inputTokenDetails?.cacheWriteTokens ?? 0,
         });
         controller.enqueue(encoder.encode(`\n${meta}\n`));
       } catch {
-        // Usage not available
+        // Usage not available -- skip silently
       }
       controller.close();
     },

apps/web/app/api/mcp/route.ts

@@ -1,7 +0,0 @@
-import { createMcpRoute } from "@vercel/geistdocs/routes/mcp";
-import { config } from "@/lib/geistdocs/config";
-import { GET as search } from "../search/route";
-
-const handler = createMcpRoute({ config, search });
-
-export { handler as GET, handler as POST };

apps/web/app/api/search/route.ts

@@ -1,80 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { getSearchIndex } from "@/lib/search-index";
-import { createSearchRoute } from "@vercel/geistdocs/routes/search";
-import { geistdocsSource } from "@/lib/geistdocs/source";
-import { config } from "@/lib/geistdocs/config";
-
-const docsSearch = createSearchRoute({ config, source: geistdocsSource });
-
-export async function GET(req: NextRequest) {
-  if (req.nextUrl.searchParams.has("query")) return docsSearch(req);
-  const q = req.nextUrl.searchParams.get("q")?.trim().toLowerCase();
-
-  if (!q) {
-    return NextResponse.json({ results: [] });
-  }
-
-  const index = await getSearchIndex();
-  const terms = q.split(/\s+/).filter(Boolean);
-
-  const results = index
-    .map((entry) => {
-      const titleLower = entry.title.toLowerCase();
-      const contentLower = entry.content.toLowerCase();
-
-      const titleMatch = terms.every((t) => titleLower.includes(t));
-      const contentMatch = terms.every((t) => contentLower.includes(t));
-
-      if (!titleMatch && !contentMatch) return null;
-
-      let snippet = "";
-      if (contentMatch) {
-        const firstTermIdx = Math.min(
-          ...terms.map((t) => {
-            const idx = contentLower.indexOf(t);
-            return idx === -1 ? Infinity : idx;
-          }),
-        );
-        if (firstTermIdx !== Infinity) {
-          const start = Math.max(0, firstTermIdx - 40);
-          const end = Math.min(entry.content.length, firstTermIdx + 120);
-          snippet =
-            (start > 0 ? "..." : "") +
-            entry.content.slice(start, end).replace(/\n/g, " ") +
-            (end < entry.content.length ? "..." : "");
-        }
-      }
-
-      return {
-        title: entry.title,
-        href: entry.href,
-        section: entry.section,
-        snippet,
-        score: titleMatch ? 2 : 1,
-      };
-    })
-    .filter(
-      (
-        r,
-      ): r is {
-        title: string;
-        href: string;
-        section: string;
-        snippet: string;
-        score: number;
-      } => r !== null,
-    )
-    .sort((a, b) => b.score - a.score)
-    .slice(0, 20)
-    .map(({ title, href, section, snippet }) => ({
-      title,
-      href,
-      section,
-      snippet,
-    }));
-
-  return NextResponse.json(
-    { results },
-    { headers: { "Cache-Control": "public, max-age=60" } },
-  );
-}

apps/web/app/globals.css

@@ -1,16 +1,9 @@
-@import "@vercel/geistdocs/styles.css";
-
-@theme {
-  --breakpoint-sm: 40rem;
-  --breakpoint-md: 48rem;
-  --breakpoint-lg: 64rem;
-  --breakpoint-xl: 80rem;
-  --breakpoint-2xl: 96rem;
-}
+@import "tailwindcss";
+@import "tw-animate-css";
 
 @source "../node_modules/streamdown/dist/index.js";
 
-@custom-variant dark (&:is(.dark-theme *));
+@custom-variant dark (&:is(.dark *));
 
 :root {
   --radius: 0.5rem;
@@ -35,10 +28,9 @@
   --border: oklch(0.85 0 0);
   --input: oklch(0.85 0 0);
   --ring: oklch(0.6 0 0);
-  --chat-bg: oklch(0.95 0 0);
 }
 
-.dark-theme {
+.dark {
   --ds-gray-500: oklch(0.39 0 0);
   /* Monochrome dark theme */
   --background: oklch(0.0 0 0);
@@ -60,7 +52,6 @@
   --border: oklch(0.25 0 0);
   --input: oklch(0.25 0 0);
   --ring: oklch(0.4 0 0);
-  --chat-bg: oklch(0.25 0 0);
 }
 
 @theme inline {
@@ -118,77 +109,29 @@
     @apply bg-transparent p-0;
   }
 
-  /* Hide page scrollbar */
-  html {
-    scrollbar-width: none;
+  /* Custom scrollbar */
+  ::-webkit-scrollbar {
+    width: 8px;
+    height: 8px;
   }
 
-  html::-webkit-scrollbar {
-    display: none;
+  ::-webkit-scrollbar-track {
+    @apply bg-background;
   }
 
+  ::-webkit-scrollbar-thumb {
+    @apply bg-border rounded;
+  }
+
+  ::-webkit-scrollbar-thumb:hover {
+    @apply bg-muted-foreground;
+  }
 }
 
 button {
   cursor: pointer;
 }
 
-/* Tool call shimmer animation */
-@keyframes tool-shimmer {
-  0% { opacity: 0.5; }
-  50% { opacity: 1; }
-  100% { opacity: 0.5; }
-}
-
-.animate-tool-shimmer {
-  animation: tool-shimmer 1.5s ease-in-out infinite;
-}
-
-/* Fix list rendering in chat content */
-.docs-chat-content ul,
-.docs-chat-content ol {
-  list-style-position: outside;
-  padding-left: 1.25em;
-}
-
-.docs-chat-content li > p {
-  display: inline;
-  margin: 0;
-}
-
-.docs-chat-content li {
-  margin-top: 0.5em;
-  margin-bottom: 0.5em;
-}
-
-/* MDX table styles — applies to both GFM pipe tables and raw HTML tables */
-.mdx-table th,
-.mdx-table td,
-article table th,
-article table td {
-  border: 1px solid var(--border);
-  padding: 0.75rem 1rem;
-  text-align: left;
-}
-
-.mdx-table th,
-article table th {
-  font-weight: 600;
-  background-color: var(--muted);
-}
-
-.mdx-table td,
-article table td {
-  color: var(--muted-foreground);
-}
-
-article table {
-  width: 100%;
-  font-size: 0.875rem;
-  border-collapse: collapse;
-  margin: 1.5rem 0;
-}
-
 /* Shiki dual theme support */
 .shiki,
 .shiki span {
@@ -196,31 +139,8 @@ article table {
   background-color: var(--shiki-light-bg) !important;
 }
 
-.dark-theme .shiki,
-.dark-theme .shiki span {
+.dark .shiki,
+.dark .shiki span {
   color: var(--shiki-dark) !important;
   background-color: var(--shiki-dark-bg) !important;
 }
-
-@container (width < 1200px) {
-  #nd-page { @apply px-6 pt-6; }
-  #nd-page > [data-mobile-docs-bar],
-  #nd-page > div:has([data-mobile-toc-trigger]) { display: flex; }
-  #nd-page [data-mobile-toc-trigger] { width: 44px; height: 44px; }
-  #nd-page > div:has(> h1) { padding-inline-end: 3.5rem; }
-  #nd-page > div:has(> h1) + div,
-  #nd-page > div:has(> h1) + p + div { margin-top: 0; }
-}
-
-@container (961px <= width < 1200px) {
-  #nd-page > [data-mobile-docs-bar] { display: none; }
-}
-
-header .pointer-events-none.opacity-0 {
-  visibility: hidden;
-}
-
-#nd-page div:has(> [aria-live="polite"]) > div > .max-sm\:hidden {
-  display: flex;
-}
-

apps/web/app/layout.tsx

@@ -1,18 +1,10 @@
 import type { Metadata } from "next";
 import localFont from "next/font/local";
-import { GeistPixelSquare } from "geist/font/pixel";
 import "./globals.css";
 import { ThemeProvider } from "@/components/theme-provider";
-import { DocsProvider } from "@/components/geistdocs-provider";
-import { Navbar } from "@vercel/geistdocs/navbar";
-import { Footer } from "@vercel/geistdocs/footer";
-import { config } from "@/lib/geistdocs/config";
-import { DocsChat } from "@/components/docs-chat";
 import { Analytics } from "@vercel/analytics/next";
 import { SpeedInsights } from "@vercel/speed-insights/next";
 import { PAGE_TITLES } from "@/lib/page-titles";
-import { cookies } from "next/headers";
-import { isPreview, siteUrl, siteDescription } from "@/lib/site";
 
 const geistSans = localFont({
   src: "./fonts/GeistVF.woff",
@@ -24,21 +16,17 @@ const geistMono = localFont({
 });
 
 export const metadata: Metadata = {
-  metadataBase: new URL(siteUrl),
-  alternates: { canonical: "/" },
+  metadataBase: new URL("https://json-render.dev"),
   title: {
     default: `json-render | ${PAGE_TITLES[""]}`,
     template: "%s | json-render",
   },
   description:
-    "The Generative UI framework. Generate dashboards, widgets, and apps from prompts — safely constrained to components you define.",
+    "Let users generate dashboards, widgets, apps, and data visualizations from prompts — safely constrained to components you define.",
   keywords: [
     "json-render",
-    "generative UI",
     "AI UI generation",
-    "user-generated interfaces",
     "React components",
-    "React Native",
     "guardrails",
     "structured output",
     "dashboard builder",
@@ -50,80 +38,44 @@ export const metadata: Metadata = {
     locale: "en_US",
     url: "https://json-render.dev",
     siteName: "json-render",
-    title: "json-render | The Generative UI Framework",
+    title: "json-render | AI-generated UI with guardrails",
     description:
-      "The Generative UI framework. Generate dashboards, widgets, and apps from prompts — safely constrained to components you define.",
+      "Let users generate dashboards, widgets, apps, and data visualizations from prompts — safely constrained to components you define.",
     images: [
       {
         url: "/og",
         width: 1200,
         height: 630,
-        alt: "json-render - The Generative UI Framework",
+        alt: "json-render - AI-generated UI with guardrails",
       },
     ],
   },
   twitter: {
     card: "summary_large_image",
-    title: "json-render | The Generative UI Framework",
+    title: "json-render | AI-generated UI with guardrails",
     description:
-      "The Generative UI framework. Generate dashboards, widgets, and apps from prompts — safely constrained to components you define.",
+      "Let users generate dashboards, widgets, apps, and data visualizations from prompts — safely constrained to components you define.",
     images: ["/og"],
+    creator: "@verabornnot",
   },
   robots: {
-    index: !isPreview,
-    follow: !isPreview,
+    index: true,
+    follow: true,
   },
   icons: {
     icon: "/favicon.ico",
   },
 };
 
-export default async function RootLayout({
+export default function RootLayout({
   children,
 }: Readonly<{
   children: React.ReactNode;
 }>) {
-  const cookieStore = await cookies();
-  const chatOpen = cookieStore.get("docs-chat-open")?.value === "true";
-  const chatWidth = Math.min(
-    700,
-    Math.max(300, Number(cookieStore.get("docs-chat-width")?.value) || 400),
-  );
-
   return (
     <html lang="en" suppressHydrationWarning>
-      <head>
-        <script
-          type="application/ld+json"
-          dangerouslySetInnerHTML={{
-            __html: JSON.stringify({
-              "@context": "https://schema.org",
-              "@type": "WebSite",
-              name: "json-render",
-              url: siteUrl,
-              description: siteDescription,
-            }),
-          }}
-        />
-        {chatOpen && (
-          <style
-            dangerouslySetInnerHTML={{
-              __html: `@media(min-width:640px){body{padding-right:min(${chatWidth}px, calc(100vw - 320px))}}`,
-            }}
-          />
-        )}
-      </head>
-      <body
-        className={`${geistSans.variable} ${geistMono.variable} ${GeistPixelSquare.variable}`}
-      >
-        <ThemeProvider>
-          <DocsProvider>
-            <Navbar config={config} />
-            {children}
-            <Footer />
-          </DocsProvider>
-          <DocsChat defaultOpen={chatOpen} defaultWidth={chatWidth} />
-        </ThemeProvider>
+      <body className={`${geistSans.variable} ${geistMono.variable}`}>
+        <ThemeProvider>{children}</ThemeProvider>
         <Analytics />
         <SpeedInsights />
       </body>

apps/web/app/llms.txt/route.ts

@@ -1,10 +0,0 @@
-import { loadAllDocsSources } from "@/lib/docs-source";
-import { siteDescription, siteUrl } from "@/lib/site";
-
-export async function GET() {
-  const pages = await loadAllDocsSources();
-  const body = `# json-render\n\n${siteDescription}\n\n## Documentation\n\n${pages.map((page) => `- [${page.title}](${siteUrl}${page.markdownUrl})`).join("\n")}\n`;
-  return new Response(body, {
-    headers: { "Content-Type": "text/plain; charset=utf-8" },
-  });
-}

apps/web/app/og/og-image.tsx

@@ -5,20 +5,19 @@ import { join } from "node:path";
 export { getPageTitle } from "@/lib/page-titles";
 
 // Cache font data in memory after first load
-let fontCache: { geistRegular: Buffer; geistPixelSquare: Buffer } | null = null;
+let fontCache: { geistRegular: Buffer } | null = null;
 
 async function loadFonts() {
   if (fontCache) return fontCache;
-  const [geistRegular, geistPixelSquare] = await Promise.all([
-    readFile(join(process.cwd(), "public/Geist-Regular.ttf")),
-    readFile(join(process.cwd(), "public/GeistPixel-Square.ttf")),
-  ]);
-  fontCache = { geistRegular, geistPixelSquare };
+  const geistRegular = await readFile(
+    join(process.cwd(), "public/Geist-Regular.ttf"),
+  );
+  fontCache = { geistRegular };
   return fontCache;
 }
 
 export async function renderOgImage(title: string) {
-  const { geistRegular, geistPixelSquare } = await loadFonts();
+  const { geistRegular } = await loadFonts();
 
   return new ImageResponse(
     <div
@@ -54,8 +53,8 @@ export async function renderOgImage(title: string) {
         <span
           style={{
             fontSize: 36,
-            fontFamily: "Geist Pixel Square",
-            fontWeight: 500,
+            fontFamily: "Geist",
+            fontWeight: 400,
             color: "white",
           }}
         >
@@ -67,27 +66,23 @@ export async function renderOgImage(title: string) {
         style={{
           display: "flex",
           flex: 1,
-          flexDirection: "column",
           alignItems: "center",
           justifyContent: "center",
         }}
       >
-        {title.split("\n").map((line, i) => (
-          <span
-            key={i}
-            style={{
-              fontSize: 72,
-              fontFamily: "Geist",
-              fontWeight: 400,
-              color: "white",
-              letterSpacing: "-0.02em",
-              textAlign: "center",
-              lineHeight: 1.2,
-            }}
-          >
-            {line}
-          </span>
-        ))}
+        <span
+          style={{
+            fontSize: 72,
+            fontFamily: "Geist",
+            fontWeight: 400,
+            color: "white",
+            letterSpacing: "-0.02em",
+            textAlign: "center",
+            lineHeight: 1.2,
+          }}
+        >
+          {title}
+        </span>
       </div>
     </div>,
     {
@@ -100,12 +95,6 @@ export async function renderOgImage(title: string) {
           style: "normal",
           weight: 400,
         },
-        {
-          name: "Geist Pixel Square",
-          data: geistPixelSquare.buffer as ArrayBuffer,
-          style: "normal",
-          weight: 500,
-        },
       ],
     },
   );

apps/web/app/playground/layout.tsx

@@ -3,9 +3,5 @@ export default function PlaygroundLayout({
 }: {
   children: React.ReactNode;
 }) {
-  return (
-    <main className="h-[calc(100dvh-4rem)] flex flex-col overflow-hidden">
-      {children}
-    </main>
-  );
+  return <div className="h-dvh flex flex-col overflow-hidden">{children}</div>;
 }

apps/web/app/playground/page.tsx

@@ -1,7 +1,10 @@
 import { Playground } from "@/components/playground";
-import { pageMetadata } from "@/lib/page-metadata";
 
-export const metadata = pageMetadata("playground");
+import { PAGE_TITLES } from "@/lib/page-titles";
+
+export const metadata = {
+  title: PAGE_TITLES["playground"],
+};
 
 export default function PlaygroundPage() {
   return <Playground />;

apps/web/app/robots.ts

@@ -1,11 +0,0 @@
-import type { MetadataRoute } from "next";
-import { isPreview, siteUrl } from "@/lib/site";
-
-export default function robots(): MetadataRoute.Robots {
-  return {
-    rules: isPreview
-      ? { userAgent: "*", disallow: "/" }
-      : { userAgent: "*", allow: "/" },
-    sitemap: `${siteUrl}/sitemap.xml`,
-  };
-}

apps/web/app/sitemap.md/route.ts

@@ -1,10 +0,0 @@
-import { docsPages } from "@/lib/docs-source";
-
-export function GET() {
-  return new Response(
-    `# json-render documentation\n\n${docsPages.map((page) => `- [${page.title}](${page.href})`).join("\n")}\n`,
-    {
-      headers: { "Content-Type": "text/markdown; charset=utf-8" },
-    },
-  );
-}

apps/web/app/sitemap.ts

@@ -1,9 +0,0 @@
-import type { MetadataRoute } from "next";
-import { PAGE_TITLES } from "@/lib/page-titles";
-import { siteUrl } from "@/lib/site";
-
-export default function sitemap(): MetadataRoute.Sitemap {
-  return Object.keys(PAGE_TITLES).map((slug) => ({
-    url: `${siteUrl}/${slug}`,
-  }));
-}

apps/web/components/code-block.tsx

@@ -145,7 +145,7 @@ function getHighlighter() {
   if (!highlighterPromise) {
     highlighterPromise = createHighlighter({
       themes: [vercelLightTheme, vercelDarkTheme],
-      langs: ["json", "tsx", "typescript", "yaml"],
+      langs: ["json", "tsx", "typescript"],
     });
   }
   return highlighterPromise;
@@ -158,7 +158,7 @@ if (typeof window !== "undefined") {
 
 interface CodeBlockProps {
   code: string;
-  lang: "json" | "tsx" | "typescript" | "yaml";
+  lang: "json" | "tsx" | "typescript";
   fillHeight?: boolean;
   hideCopyButton?: boolean;
 }

apps/web/components/demo.tsx

@@ -16,64 +16,22 @@ import { CopyButton } from "./copy-button";
 import { Toaster } from "./ui/sonner";
 import { PlaygroundRenderer } from "@/lib/render/renderer";
 import { playgroundCatalog } from "@/lib/render/catalog";
-import { buildCatalogDisplayData } from "@/lib/render/catalog-display";
 
-const SIMULATION_PROMPT = "Show a team performance dashboard";
+const SIMULATION_PROMPT = "Create a contact form with name, email, and message";
 
 interface SimulationStage {
   tree: Spec;
   stream: string;
 }
 
-const DASH_STATE = {
-  chartData: [
-    { label: "Mon", value: 12 },
-    { label: "Tue", value: 28 },
-    { label: "Wed", value: 19 },
-    { label: "Thu", value: 34 },
-    { label: "Fri", value: 45 },
-    { label: "Sat", value: 38 },
-    { label: "Sun", value: 52 },
-  ],
-};
-
-const METRIC_REVENUE = {
-  type: "Metric",
-  props: {
-    label: "Weekly Revenue",
-    value: "12,400",
-    prefix: "$",
-    change: "+18%",
-    changeType: "positive",
-  },
-} as const;
-
-const CHART = {
-  type: "LineGraph",
-  props: { data: { $state: "/chartData" } },
-} as const;
-
-const SEP = { type: "Separator", props: {} } as const;
-
-const PROGRESS_DEALS = {
-  type: "Progress",
-  props: { value: 72, label: "Deals Closed -- 72%" },
-} as const;
-
-const PROGRESS_RETENTION = {
-  type: "Progress",
-  props: { value: 91, label: "Retention -- 91%" },
-} as const;
-
 const SIMULATION_STAGES: SimulationStage[] = [
   {
     tree: {
       root: "card",
-      state: DASH_STATE,
       elements: {
         card: {
           type: "Card",
-          props: { title: "Team Performance", maxWidth: "sm", centered: true },
+          props: { title: "Contact Us", maxWidth: "md" },
           children: [],
         },
       },
@@ -83,74 +41,98 @@ const SIMULATION_STAGES: SimulationStage[] = [
   {
     tree: {
       root: "card",
-      state: DASH_STATE,
       elements: {
         card: {
           type: "Card",
-          props: { title: "Team Performance", maxWidth: "sm", centered: true },
-          children: ["m1"],
+          props: { title: "Contact Us", maxWidth: "md" },
+          children: ["name"],
+        },
+        name: {
+          type: "Input",
+          props: { label: "Name", name: "name" },
         },
-        m1: METRIC_REVENUE,
       },
     },
     stream:
-      '{"op":"add","path":"/elements/m1","value":{"type":"Metric","props":{"label":"Weekly Revenue","value":"12,400","prefix":"$","change":"+18%","changeType":"positive"}}}',
+      '{"op":"add","path":"/elements/card","value":{"type":"Card","props":{"title":"Contact Us","maxWidth":"md"},"children":["name"]}}',
   },
   {
     tree: {
       root: "card",
-      state: DASH_STATE,
       elements: {
         card: {
           type: "Card",
-          props: { title: "Team Performance", maxWidth: "sm", centered: true },
-          children: ["m1", "chart"],
+          props: { title: "Contact Us", maxWidth: "md" },
+          children: ["name", "email"],
+        },
+        name: {
+          type: "Input",
+          props: { label: "Name", name: "name" },
+        },
+        email: {
+          type: "Input",
+          props: { label: "Email", name: "email" },
         },
-        m1: METRIC_REVENUE,
-        chart: CHART,
       },
     },
     stream:
-      '{"op":"add","path":"/elements/chart","value":{"type":"LineGraph","props":{"data":{"$state":"/chartData"}}}}',
+      '{"op":"add","path":"/elements/email","value":{"type":"Input","props":{"label":"Email","name":"email"}}}',
   },
   {
     tree: {
       root: "card",
-      state: DASH_STATE,
       elements: {
         card: {
           type: "Card",
-          props: { title: "Team Performance", maxWidth: "sm", centered: true },
-          children: ["m1", "chart", "sep", "p1"],
+          props: { title: "Contact Us", maxWidth: "md" },
+          children: ["name", "email", "message"],
+        },
+        name: {
+          type: "Input",
+          props: { label: "Name", name: "name" },
+        },
+        email: {
+          type: "Input",
+          props: { label: "Email", name: "email" },
+        },
+        message: {
+          type: "Textarea",
+          props: { label: "Message", name: "message" },
         },
-        m1: METRIC_REVENUE,
-        chart: CHART,
-        sep: SEP,
-        p1: PROGRESS_DEALS,
       },
     },
     stream:
-      '{"op":"add","path":"/elements/p1","value":{"type":"Progress","props":{"value":72,"label":"Deals Closed -- 72%"}}}',
+      '{"op":"add","path":"/elements/message","value":{"type":"Textarea","props":{"label":"Message","name":"message"}}}',
   },
   {
     tree: {
       root: "card",
-      state: DASH_STATE,
       elements: {
         card: {
           type: "Card",
-          props: { title: "Team Performance", maxWidth: "sm", centered: true },
-          children: ["m1", "chart", "sep", "p1", "p2"],
+          props: { title: "Contact Us", maxWidth: "md" },
+          children: ["name", "email", "message", "submit"],
+        },
+        name: {
+          type: "Input",
+          props: { label: "Name", name: "name" },
+        },
+        email: {
+          type: "Input",
+          props: { label: "Email", name: "email" },
+        },
+        message: {
+          type: "Textarea",
+          props: { label: "Message", name: "message" },
+        },
+        submit: {
+          type: "Button",
+          props: { label: "Send Message", variant: "primary" },
         },
-        m1: METRIC_REVENUE,
-        chart: CHART,
-        sep: SEP,
-        p1: PROGRESS_DEALS,
-        p2: PROGRESS_RETENTION,
       },
     },
     stream:
-      '{"op":"add","path":"/elements/p2","value":{"type":"Progress","props":{"value":91,"label":"Retention -- 91%"}}}',
+      '{"op":"add","path":"/elements/submit","value":{"type":"Button","props":{"label":"Send Message","variant":"primary"}}}',
   },
 ];
 
@@ -195,15 +177,6 @@ function specToNested(spec: Spec): Record<string, unknown> {
       node.children = el.children.map(resolve);
     }
 
-    if (el.slots && Object.keys(el.slots).length > 0) {
-      node.slots = Object.fromEntries(
-        Object.entries(el.slots).map(([slotName, childKeys]) => [
-          slotName,
-          childKeys.map(resolve),
-        ]),
-      );
-    }
-
     return node;
   }
 
@@ -219,10 +192,10 @@ function specToNested(spec: Spec): Record<string, unknown> {
 }
 
 const EXAMPLE_PROMPTS = [
-  "Recipe card with rating and ingredients",
-  "Order receipt with item list and total",
-  "Team member profile card",
-  "Notification inbox with alerts",
+  "Create a login form with email and password",
+  "Build a feedback form with rating stars",
+  "Design a contact card with avatar",
+  "Make a settings panel with toggles",
 ];
 
 export function Demo({
@@ -257,10 +230,87 @@ export function Demo({
   >("components");
 
   // Catalog data for the catalog tab
-  const catalogData = useMemo(
-    () => buildCatalogDisplayData(playgroundCatalog.data),
-    [],
-  );
+  const catalogData = useMemo(() => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const raw = playgroundCatalog.data as any;
+
+    function extractFields(zodObj: unknown): { name: string; type: string }[] {
+      if (!zodObj) return [];
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const obj = zodObj as any;
+        const shape =
+          typeof obj.shape === "object"
+            ? obj.shape
+            : typeof obj._def?.shape === "function"
+              ? obj._def.shape()
+              : typeof obj._def?.shape === "object"
+                ? obj._def.shape
+                : null;
+        if (!shape) return [];
+
+        return Object.entries(shape).map(([name, schema]) => {
+          let type = "unknown";
+          try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const s = schema as any;
+            const typeName: string =
+              s?._zod?.def?.type ?? s?._def?.typeName ?? "";
+            if (typeName.includes("string")) type = "string";
+            else if (typeName.includes("number")) type = "number";
+            else if (typeName.includes("boolean")) type = "boolean";
+            else if (typeName.includes("array")) type = "array";
+            else if (typeName.includes("enum")) {
+              const values = s?._zod?.def?.values ?? s?._def?.values;
+              type = Array.isArray(values) ? values.join(" | ") : "enum";
+            } else if (typeName.includes("union")) type = "union";
+            else if (typeName.includes("nullable")) {
+              const inner = s?._zod?.def?.innerType ?? s?._def?.innerType;
+              const innerName: string =
+                inner?._zod?.def?.type ?? inner?._def?.typeName ?? "";
+              if (innerName.includes("string")) type = "string?";
+              else if (innerName.includes("number")) type = "number?";
+              else if (innerName.includes("boolean")) type = "boolean?";
+              else if (innerName.includes("array")) type = "array?";
+              else if (innerName.includes("enum")) {
+                const values = inner?._zod?.def?.values ?? inner?._def?.values;
+                type = Array.isArray(values)
+                  ? `(${values.join(" | ")})?`
+                  : "enum?";
+              } else type = "optional";
+            }
+          } catch {
+            // ignore
+          }
+          return { name, type };
+        });
+      } catch {
+        return [];
+      }
+    }
+
+    const components = Object.entries(raw.components ?? {})
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .map(([name, def]: [string, any]) => ({
+        name,
+        description: (def.description as string) ?? "",
+        props: extractFields(def.props),
+        slots: (def.slots as string[]) ?? [],
+        events: (def.events as string[]) ?? [],
+      }))
+      .sort((a, b) => a.name.localeCompare(b.name));
+
+    const actions = Object.entries(raw.actions ?? {})
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .map(([name, def]: [string, any]) => ({
+        name,
+        description: (def.description as string) ?? "",
+        params: extractFields(def.params),
+      }))
+      .sort((a, b) => a.name.localeCompare(b.name));
+
+    return { components, actions };
+  }, []);
 
   // Disable body scroll when any modal is open
   useEffect(() => {
@@ -402,45 +452,21 @@ export function Demo({
 
       const propsStr = serializeProps(propsObj);
       const hasChildren = element.children && element.children.length > 0;
-      const hasSlots = element.slots && Object.keys(element.slots).length > 0;
 
-      if (!hasChildren && !hasSlots) {
+      if (!hasChildren) {
         return propsStr
           ? `${spaces}<${componentName} ${propsStr} />`
           : `${spaces}<${componentName} />`;
       }
 
       const lines: string[] = [];
-      if (hasSlots) {
-        lines.push(`${spaces}<${componentName}`);
-        if (propsStr) {
-          lines.push(`${spaces}  ${propsStr}`);
-        }
-        for (const [slotName, childKeys] of Object.entries(element.slots!)) {
-          const slotChildren = childKeys
-            .map((childKey) => generateJSX(childKey, indent + 2))
-            .filter(Boolean);
-          if (slotChildren.length === 0) continue;
-          lines.push(`${spaces}  ${slotName}={`);
-          if (slotChildren.length > 1) {
-            lines.push(`${spaces}    <>`);
-          }
-          lines.push(...slotChildren);
-          if (slotChildren.length > 1) {
-            lines.push(`${spaces}    </>`);
-          }
-          lines.push(`${spaces}  }`);
-        }
-        lines.push(`${spaces}>`);
-      } else {
-        lines.push(
-          propsStr
-            ? `${spaces}<${componentName} ${propsStr}>`
-            : `${spaces}<${componentName}>`,
-        );
-      }
+      lines.push(
+        propsStr
+          ? `${spaces}<${componentName} ${propsStr}>`
+          : `${spaces}<${componentName}>`,
+      );
 
-      for (const childKey of element.children ?? []) {
+      for (const childKey of element.children!) {
         lines.push(generateJSX(childKey, indent + 1));
       }
 
@@ -1149,7 +1175,7 @@ Open [http://localhost:3000](http://localhost:3000) to view.
             ))}
           </div>
           <div
-            className={`border border-border rounded bg-background font-mono text-xs text-left grid relative group ${fullscreen ? "flex-1 min-h-0" : "h-[36rem]"}`}
+            className={`border border-border rounded bg-background font-mono text-xs text-left grid relative group ${fullscreen ? "flex-1 min-h-0" : "h-[28rem]"}`}
           >
             {activeTab !== "catalog" && (
               <div className="absolute top-2 right-2 z-10">
@@ -1389,7 +1415,7 @@ Open [http://localhost:3000](http://localhost:3000) to view.
             </div>
           </div>
           <div
-            className={`border border-border rounded bg-background grid relative group ${fullscreen ? "flex-1 min-h-0" : "h-[36rem]"}`}
+            className={`border border-border rounded bg-background grid relative group ${fullscreen ? "flex-1 min-h-0" : "h-[28rem]"}`}
           >
             {renderView === "static" && (
               <div className="absolute top-2 right-2 z-10">

apps/web/components/docs-chat.tsx

@@ -1,272 +1,24 @@
 "use client";
 
-import {
-  useRef,
-  useEffect,
-  useState,
-  useCallback,
-  type PointerEvent as ReactPointerEvent,
-} from "react";
+import { useRef, useEffect, useState } from "react";
 import { useChat } from "@ai-sdk/react";
 import { DefaultChatTransport } from "ai";
 import { Streamdown } from "streamdown";
-import Link from "next/link";
-import { Sheet, SheetContent, SheetTitle } from "@/components/ui/sheet";
 
 const STORAGE_KEY = "docs-chat-messages";
 const transport = new DefaultChatTransport({ api: "/api/docs-chat" });
 
-const DESKTOP_DEFAULT_WIDTH = 400;
-const DESKTOP_MIN_WIDTH = 300;
-const DESKTOP_MAX_WIDTH = 700;
-
-function setCookie(name: string, value: string) {
-  document.cookie = `${name}=${encodeURIComponent(value)};path=/;max-age=${60 * 60 * 24 * 365};samesite=lax`;
-}
-
-const TOOL_LABELS: Record<
-  string,
-  { label: string; pastLabel: string; argKey?: string }
-> = {
-  readFile: { label: "Reading", pastLabel: "Read", argKey: "path" },
-  bash: { label: "Running", pastLabel: "Ran", argKey: "command" },
-};
-
-function isToolPart(part: { type: string }): part is {
-  type: string;
-  toolCallId: string;
-  toolName?: string;
-  state: string;
-  input?: Record<string, unknown>;
-  output?: unknown;
-  errorText?: string;
-} {
-  return part.type.startsWith("tool-") || part.type === "dynamic-tool";
-}
-
-function getToolName(part: { type: string; toolName?: string }): string {
-  if (part.type === "dynamic-tool") return part.toolName ?? "tool";
-  return part.type.replace(/^tool-/, "");
-}
-
-function ToolCallDisplay({
-  part,
-}: {
-  part: {
-    type: string;
-    toolCallId: string;
-    toolName?: string;
-    state: string;
-    input?: Record<string, unknown>;
-    output?: unknown;
-    errorText?: string;
-  };
-}) {
-  const toolName = getToolName(part);
-  const config = TOOL_LABELS[toolName] ?? {
-    label: toolName,
-    pastLabel: toolName,
-  };
-  const isDone = part.state === "output-available";
-  const isError = part.state === "output-error";
-  const isRunning = !isDone && !isError;
-  const displayLabel = isRunning ? config.label : config.pastLabel;
-
-  const args = (part.input ?? {}) as Record<string, unknown>;
-  const argValue = config.argKey ? args[config.argKey] : undefined;
-  const argPreview =
-    argValue != null
-      ? String(argValue)
-          .replace(/\/workspace\//g, "/")
-          .replace(/\.md$/, "")
-          .replace(/\/index$/, "")
-      : "";
-
-  // Link to the docs page if it's a /docs/ path from readFile
-  const docsLink =
-    toolName === "readFile" &&
-    (argPreview === "/docs" || argPreview.startsWith("/docs/"))
-      ? argPreview
-      : null;
-
-  const argEl = argPreview ? (
-    docsLink ? (
-      <Link href={docsLink} className="truncate underline underline-offset-2">
-        {argPreview}
-      </Link>
-    ) : (
-      <span className="truncate">{argPreview}</span>
-    )
-  ) : null;
-
-  return (
-    <div className="text-xs py-0.5 min-w-0">
-      {isRunning ? (
-        <span className="inline-flex items-center gap-1 font-mono text-muted-foreground animate-tool-shimmer min-w-0 max-w-full">
-          <span className="shrink-0">{displayLabel}</span>
-          {argEl}
-        </span>
-      ) : (
-        <span className="inline-flex items-center gap-1 font-mono text-muted-foreground/60 min-w-0 max-w-full">
-          <span className="shrink-0">{displayLabel}</span>
-          {argEl}
-          {isError && <span className="text-destructive">failed</span>}
-        </span>
-      )}
-    </div>
-  );
-}
-
-const SUGGESTIONS = [
-  "What is json-render?",
-  "How do I install it?",
-  "How does streaming work?",
-  "What components are available?",
-  "How do I create a custom schema?",
-];
-
-export function DocsChat({
-  defaultOpen = false,
-  defaultWidth = DESKTOP_DEFAULT_WIDTH,
-}: {
-  defaultOpen?: boolean;
-  defaultWidth?: number;
-}) {
-  const [open, setOpen] = useState(defaultOpen);
+export function DocsChat() {
+  const [open, setOpen] = useState(false);
   const [input, setInput] = useState("");
-  const [isDesktop, setIsDesktop] = useState(false);
-  const [hasMounted, setHasMounted] = useState(false);
-  const [desktopWidth, setDesktopWidth] = useState(
-    Math.min(DESKTOP_MAX_WIDTH, Math.max(DESKTOP_MIN_WIDTH, defaultWidth)),
-  );
-  const messagesScrollRef = useRef<HTMLDivElement>(null);
+  const messagesEndRef = useRef<HTMLDivElement>(null);
   const inputRef = useRef<HTMLTextAreaElement>(null);
-  const launcherRef = useRef<HTMLButtonElement>(null);
+  const containerRef = useRef<HTMLDivElement>(null);
   const restoredRef = useRef(false);
-  const isDraggingRef = useRef(false);
 
-  const { messages, sendMessage, status, setMessages, error } = useChat({
-    transport,
-  });
+  const { messages, sendMessage, status, setMessages } = useChat({ transport });
 
   const isLoading = status === "streaming" || status === "submitted";
-  const showMessages = messages.length > 0 || !!error || isLoading;
-
-  // Detect desktop vs mobile. Close sidebar on mobile if it was open from cookie.
-  useEffect(() => {
-    const mq = window.matchMedia("(min-width: 640px)");
-    setIsDesktop(mq.matches);
-    setHasMounted(true);
-    // If on mobile but sidebar was open from cookie, close it
-    if (!mq.matches && defaultOpen) {
-      setOpen(false);
-    }
-    const handler = (e: MediaQueryListEvent) => setIsDesktop(e.matches);
-    mq.addEventListener("change", handler);
-    return () => mq.removeEventListener("change", handler);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-
-  // Persist open state to cookie (only after mount to avoid overwriting on mobile)
-  useEffect(() => {
-    if (hasMounted) {
-      setCookie("docs-chat-open", String(open));
-    }
-  }, [open, hasMounted]);
-
-  useEffect(() => {
-    const launcher = launcherRef.current;
-    if (!hasMounted || open || !launcher) return;
-    const footer = document.querySelector("footer");
-    let frame = 0;
-    const update = () => {
-      frame = 0;
-      const rect = document
-        .querySelector("footer fieldset")
-        ?.getBoundingClientRect();
-      const overlap =
-        rect && rect.width > 0 && rect.bottom > 0
-          ? Math.max(0, innerHeight - rect.top)
-          : 0;
-      launcher.style.setProperty("--chat-launcher-bottom", `${24 + overlap}px`);
-    };
-    const schedule = () => {
-      if (!frame) frame = requestAnimationFrame(update);
-    };
-    const resize = new ResizeObserver(schedule);
-    resize.observe(document.body);
-    const mutation = new MutationObserver(schedule);
-    if (footer) {
-      resize.observe(footer);
-      mutation.observe(footer, { childList: true, subtree: true });
-    }
-    window.addEventListener("scroll", schedule, { passive: true });
-    window.addEventListener("resize", schedule);
-    update();
-    return () => {
-      cancelAnimationFrame(frame);
-      resize.disconnect();
-      mutation.disconnect();
-      window.removeEventListener("scroll", schedule);
-      window.removeEventListener("resize", schedule);
-    };
-  }, [hasMounted, open]);
-
-  // Push page content on desktop when pane is open.
-  // Use padding on body so the page scrollbar stays at the viewport edge (behind the sidebar)
-  // instead of appearing right next to the sidebar's scrollbar.
-  useEffect(() => {
-    const body = document.body;
-    if (isDesktop && open) {
-      body.style.paddingRight = `min(${desktopWidth}px, calc(100vw - 320px))`;
-      if (!isDraggingRef.current) {
-        body.style.transition = "padding-right 150ms ease";
-      }
-    } else if (isDesktop) {
-      body.style.paddingRight = "0px";
-      body.style.transition = "padding-right 150ms ease";
-    }
-    return () => {
-      body.style.paddingRight = "0px";
-      body.style.transition = "";
-    };
-  }, [isDesktop, open, desktopWidth]);
-
-  // Resize handle drag
-  const handleResizePointerDown = useCallback(
-    (e: ReactPointerEvent<HTMLDivElement>) => {
-      e.preventDefault();
-      isDraggingRef.current = true;
-      document.documentElement.style.transition = "none";
-      const startX = e.clientX;
-      const startWidth = desktopWidth;
-
-      const onPointerMove = (ev: globalThis.PointerEvent) => {
-        const delta = startX - ev.clientX;
-        const newWidth = Math.min(
-          DESKTOP_MAX_WIDTH,
-          Math.max(DESKTOP_MIN_WIDTH, startWidth + delta),
-        );
-        setDesktopWidth(newWidth);
-      };
-
-      const onPointerUp = () => {
-        isDraggingRef.current = false;
-        document.documentElement.style.transition = "";
-        document.removeEventListener("pointermove", onPointerMove);
-        document.removeEventListener("pointerup", onPointerUp);
-      };
-
-      document.addEventListener("pointermove", onPointerMove);
-      document.addEventListener("pointerup", onPointerUp);
-    },
-    [desktopWidth],
-  );
-
-  // Persist width to cookie
-  useEffect(() => {
-    setCookie("docs-chat-width", String(desktopWidth));
-  }, [desktopWidth]);
 
   // Restore messages from sessionStorage on mount
   useEffect(() => {
@@ -300,101 +52,144 @@ export function DocsChat({
     }
   }, [messages, isLoading]);
 
-  // Cmd+I to open sidebar and focus prompt, Escape to close
+  // Auto-open when new messages arrive
+  const prevMessageCount = useRef(0);
   useEffect(() => {
-    const handleKeyDown = (e: KeyboardEvent) => {
-      if (e.key === "i" && (e.metaKey || e.ctrlKey)) {
-        e.preventDefault();
-        setOpen((prev) => {
-          if (!prev) {
-            setTimeout(() => inputRef.current?.focus(), 200);
-          }
-          return !prev;
-        });
-      }
+    if (messages.length > prevMessageCount.current) {
+      setOpen(true);
+    }
+    prevMessageCount.current = messages.length;
+  }, [messages.length]);
+
+  // Scroll to bottom when messages change
+  useEffect(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [messages]);
+
+  // Close message area when clicking outside
+  useEffect(() => {
+    if (!open) return;
+    const handleClickOutside = (e: MouseEvent) => {
       if (
-        e.key === "Escape" &&
-        open &&
-        (isDesktop ||
-          (e.target instanceof Element &&
-            e.target.closest("#json-render-chat-mobile")))
+        containerRef.current &&
+        !containerRef.current.contains(e.target as Node)
       ) {
         setOpen(false);
       }
     };
-    document.addEventListener("keydown", handleKeyDown);
-    return () => document.removeEventListener("keydown", handleKeyDown);
-  }, [open, isDesktop]);
-
-  // Auto-focus input when opened
-  useEffect(() => {
-    if (open) {
-      const timer = setTimeout(() => inputRef.current?.focus(), 200);
-      return () => clearTimeout(timer);
-    }
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => document.removeEventListener("mousedown", handleClickOutside);
   }, [open]);
 
-  // Auto-open when error occurs
-  useEffect(() => {
-    if (error) setOpen(true);
-  }, [error]);
-
-  // Scroll to bottom when messages change or error occurs
-  useEffect(() => {
-    const el = messagesScrollRef.current;
-    if (!el) return;
-    requestAnimationFrame(() => {
-      el.scrollTop = el.scrollHeight;
-    });
-  }, [messages, error]);
-
-  const handleSubmit = useCallback(
-    (e: React.FormEvent) => {
-      e.preventDefault();
-      if (!input.trim() || isLoading) return;
-      sendMessage({ text: input });
-      setInput("");
-    },
-    [input, isLoading, sendMessage],
-  );
-
-  const handleClear = useCallback(() => {
-    setMessages([]);
-    sessionStorage.removeItem(STORAGE_KEY);
-  }, [setMessages]);
-
-  const hasVisibleContent = (
-    parts: (typeof messages)[number]["parts"],
-  ): boolean => {
-    return parts.some(
-      (p) => (p.type === "text" && p.text.length > 0) || isToolPart(p),
-    );
+  const handleSubmit = (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!input.trim() || isLoading) return;
+    sendMessage({ text: input });
+    setInput("");
   };
 
-  // Shared chat panel content used by both desktop and mobile
-  const chatPanel = (
-    <>
-      {/* Header */}
-      <div className="flex items-center justify-between px-4 py-3 border-b shrink-0">
-        <span className="text-sm font-medium">json-render Docs</span>
-        <div className="flex items-center gap-3">
-          {showMessages && (
-            <button
-              onClick={handleClear}
-              className="text-xs text-muted-foreground hover:text-foreground transition-colors"
-              aria-label="Clear conversation"
-            >
-              Clear
-            </button>
-          )}
+  const handleClear = () => {
+    setMessages([]);
+    sessionStorage.removeItem(STORAGE_KEY);
+    setOpen(false);
+    inputRef.current?.focus();
+  };
+
+  const getTextFromParts = (
+    parts: (typeof messages)[number]["parts"],
+  ): string => {
+    return parts
+      .filter(
+        (p): p is Extract<typeof p, { type: "text" }> => p.type === "text",
+      )
+      .map((p) => p.text)
+      .join("");
+  };
+
+  return (
+    <div className="fixed bottom-0 left-0 right-0 z-50 pointer-events-none">
+      <div
+        ref={containerRef}
+        className="max-w-xl mx-auto px-4 pb-4 [&>*]:pointer-events-auto"
+      >
+        {/* Messages panel */}
+        {open && messages.length > 0 && (
+          <div className="mb-2 bg-background border border-border rounded-lg shadow-lg max-h-[60vh] flex flex-col">
+            <div className="flex items-center justify-between px-4 py-2 border-b border-border shrink-0">
+              <span className="text-xs font-medium text-muted-foreground">
+                json-render Docs
+              </span>
+              <button
+                onClick={handleClear}
+                className="text-xs text-muted-foreground hover:text-foreground transition-colors"
+                aria-label="Clear conversation"
+              >
+                Clear
+              </button>
+            </div>
+            <div className="p-4 space-y-4 overflow-y-auto">
+              {messages.map((message) => {
+                const text = getTextFromParts(message.parts);
+                if (!text) return null;
+                return (
+                  <div key={message.id}>
+                    {message.role === "assistant" ? (
+                      <div className="text-sm text-foreground/90 leading-relaxed prose prose-sm dark:prose-invert max-w-none">
+                        <Streamdown>{text}</Streamdown>
+                      </div>
+                    ) : (
+                      <div className="text-sm text-muted-foreground whitespace-pre-wrap leading-relaxed">
+                        {text}
+                      </div>
+                    )}
+                  </div>
+                );
+              })}
+              <div ref={messagesEndRef} />
+            </div>
+          </div>
+        )}
+
+        {/* Input bar */}
+        <form
+          onSubmit={handleSubmit}
+          onClick={() => inputRef.current?.focus()}
+          className="flex items-end gap-2 bg-background border border-border rounded-lg shadow-lg px-4 py-3 cursor-text"
+        >
+          <textarea
+            ref={inputRef}
+            value={input}
+            onChange={(e) => {
+              setInput(e.target.value);
+              e.target.style.height = "auto";
+              e.target.style.height = `${e.target.scrollHeight}px`;
+            }}
+            placeholder="Ask about the docs..."
+            rows={1}
+            onFocus={() => {
+              if (messages.length > 0) setOpen(true);
+            }}
+            onKeyDown={(e) => {
+              if (e.key === "Escape") {
+                setOpen(false);
+                inputRef.current?.blur();
+              }
+              if (e.key === "Enter" && !e.shiftKey) {
+                e.preventDefault();
+                handleSubmit(e);
+              }
+            }}
+            className="flex-1 bg-transparent text-sm text-foreground placeholder:text-muted-foreground outline-none disabled:opacity-50 resize-none max-h-32 leading-relaxed"
+          />
           <button
-            onClick={() => setOpen(false)}
-            className="text-muted-foreground hover:text-foreground transition-colors"
-            aria-label="Close panel"
+            type="submit"
+            disabled={isLoading || !input.trim()}
+            className="bg-primary text-primary-foreground rounded-md p-1 hover:bg-primary/90 transition-colors disabled:opacity-30"
+            aria-label="Send message"
           >
             <svg
-              width="14"
-              height="14"
+              width="16"
+              height="16"
               viewBox="0 0 24 24"
               fill="none"
               stroke="currentColor"
@@ -402,196 +197,12 @@ export function DocsChat({
               strokeLinecap="round"
               strokeLinejoin="round"
             >
-              <line x1="18" y1="6" x2="6" y2="18" />
-              <line x1="6" y1="6" x2="18" y2="18" />
+              <line x1="12" y1="19" x2="12" y2="5" />
+              <polyline points="5 12 12 5 19 12" />
             </svg>
           </button>
-        </div>
+        </form>
       </div>
-
-      {/* Content: suggestions or messages */}
-      {showMessages ? (
-        <div
-          ref={messagesScrollRef}
-          className="flex-1 min-h-0 p-4 space-y-4 overflow-y-auto"
-        >
-          {messages.map((message) => {
-            if (!hasVisibleContent(message.parts)) return null;
-            return (
-              <div key={message.id}>
-                {message.role === "user" ? (
-                  <div className="text-sm text-muted-foreground whitespace-pre-wrap leading-relaxed">
-                    {message.parts
-                      .filter(
-                        (p): p is Extract<typeof p, { type: "text" }> =>
-                          p.type === "text",
-                      )
-                      .map((p) => p.text)
-                      .join("")}
-                  </div>
-                ) : (
-                  <div className="space-y-2">
-                    {message.parts.map((part, i) => {
-                      if (part.type === "text" && part.text) {
-                        return (
-                          <div
-                            key={i}
-                            className="docs-chat-content text-sm text-foreground/90 leading-relaxed prose prose-sm dark:prose-invert max-w-none"
-                          >
-                            <Streamdown>{part.text}</Streamdown>
-                          </div>
-                        );
-                      }
-                      if (isToolPart(part)) {
-                        return (
-                          <ToolCallDisplay key={part.toolCallId} part={part} />
-                        );
-                      }
-                      return null;
-                    })}
-                  </div>
-                )}
-              </div>
-            );
-          })}
-          {error && (
-            <div className="text-sm text-destructive/80 bg-destructive/10 rounded-md px-3 py-2">
-              {(() => {
-                try {
-                  const parsed = JSON.parse(error.message);
-                  return parsed.message || parsed.error || error.message;
-                } catch {
-                  return (
-                    error.message || "Something went wrong. Please try again."
-                  );
-                }
-              })()}
-            </div>
-          )}
-        </div>
-      ) : (
-        <div className="flex-1 min-h-0 flex flex-col">
-          <div className="flex flex-wrap gap-2 p-4">
-            {SUGGESTIONS.map((s) => (
-              <button
-                key={s}
-                type="button"
-                onClick={() => {
-                  sendMessage({ text: s });
-                }}
-                className="text-xs px-3 py-1.5 rounded-full border bg-secondary font-medium text-muted-foreground hover:text-foreground transition-colors"
-              >
-                {s}
-              </button>
-            ))}
-          </div>
-        </div>
-      )}
-
-      {/* Input bar */}
-      <form
-        onSubmit={handleSubmit}
-        className="flex items-end gap-2 px-4 py-3 border-t shrink-0"
-      >
-        <textarea
-          ref={inputRef}
-          value={input}
-          onChange={(e) => {
-            setInput(e.target.value);
-            e.target.style.height = "auto";
-            e.target.style.height = `${e.target.scrollHeight}px`;
-          }}
-          rows={1}
-          enterKeyHint="send"
-          placeholder="Ask a question..."
-          aria-label="Ask a question"
-          onKeyDown={(e) => {
-            if (e.key === "Enter" && !e.shiftKey) {
-              e.preventDefault();
-              handleSubmit(e);
-            }
-          }}
-          className="flex-1 bg-transparent text-base sm:text-sm text-foreground outline-none disabled:opacity-50 resize-none max-h-32 leading-relaxed placeholder:text-muted-foreground"
-        />
-        <button
-          type="submit"
-          disabled={isLoading || !input.trim()}
-          className="bg-primary text-primary-foreground rounded-full p-1.5 hover:bg-primary/90 transition-colors disabled:opacity-30 shrink-0"
-          aria-label="Send message"
-        >
-          <svg
-            width="16"
-            height="16"
-            viewBox="0 0 24 24"
-            fill="none"
-            stroke="currentColor"
-            strokeWidth="2"
-            strokeLinecap="round"
-            strokeLinejoin="round"
-          >
-            <line x1="12" y1="19" x2="12" y2="5" />
-            <polyline points="5 12 12 5 19 12" />
-          </svg>
-        </button>
-      </form>
-    </>
-  );
-
-  return (
-    <>
-      {/* Ask AI trigger button */}
-      {!open && (
-        <button
-          ref={launcherRef}
-          data-docs-chat-launcher
-          onClick={() => setOpen(true)}
-          className="fixed z-30 bottom-[calc(1rem+env(safe-area-inset-bottom))] left-1/2 -translate-x-1/2 min-[640px]:left-auto min-[640px]:translate-x-0 min-[640px]:right-6 min-[640px]:bottom-[var(--chat-launcher-bottom,24px)] flex h-10 items-center gap-2 px-4 py-2 rounded-lg border border-primary bg-primary text-primary-foreground shadow-lg hover:bg-primary/90 transition-colors text-sm font-medium"
-          aria-label="Ask AI"
-          aria-expanded={open}
-          aria-controls={
-            isDesktop ? "json-render-chat-desktop" : "json-render-chat-mobile"
-          }
-          aria-keyshortcuts="Meta+I Control+I"
-        >
-          Ask AI
-          <kbd className="hidden min-[640px]:inline-flex items-center gap-0.5 text-xs opacity-60 font-mono">
-            <span>&#8984;</span>I
-          </kbd>
-        </button>
-      )}
-
-      {/* Desktop: resizable side pane — always rendered, hidden on mobile via CSS */}
-      <aside
-        id="json-render-chat-desktop"
-        inert={!open || !isDesktop}
-        className={`hidden sm:flex fixed top-0 right-0 bottom-0 z-40 border-l bg-background transition-transform duration-150 ease-in-out ${open ? "translate-x-0" : "translate-x-full"}`}
-        style={{ width: `min(${desktopWidth}px, calc(100vw - 320px))` }}
-        aria-hidden={!open || !isDesktop}
-      >
-        {/* Resize handle */}
-        <div
-          onPointerDown={handleResizePointerDown}
-          className="absolute top-0 bottom-0 left-0 w-1.5 cursor-col-resize hover:bg-ring/30 active:bg-ring/50 transition-colors z-10"
-        />
-        <div className="flex flex-col flex-1 min-w-0">{chatPanel}</div>
-      </aside>
-
-      {/* Mobile: Sheet overlay/drawer — only after mount to avoid flash on desktop */}
-      {hasMounted && !isDesktop && (
-        <Sheet open={open} onOpenChange={setOpen}>
-          <SheetContent
-            id="json-render-chat-mobile"
-            aria-describedby={undefined}
-            side="right"
-            overlayClassName="!bg-background"
-            className="!inset-0 !w-full !h-full !max-w-none p-0 flex flex-col"
-            style={{ backgroundColor: "var(--background)", opacity: 1 }}
-          >
-            <SheetTitle className="sr-only">AI Chat</SheetTitle>
-            {chatPanel}
-          </SheetContent>
-        </Sheet>
-      )}
-    </>
+    </div>
   );
 }

apps/web/components/geistdocs-provider.tsx

@@ -1,13 +0,0 @@
-"use client";
-
-import { GeistdocsProvider } from "@vercel/geistdocs/layout";
-import type { ReactNode } from "react";
-import { config } from "@/lib/geistdocs/config";
-
-export function DocsProvider({ children }: { children: ReactNode }) {
-  return (
-    <GeistdocsProvider config={config} lang="en">
-      {children}
-    </GeistdocsProvider>
-  );
-}

apps/web/components/generation-modes-diagram.tsx

@@ -1,272 +0,0 @@
-"use client";
-
-function ScheduleItem({
-  time,
-  label,
-  color,
-}: {
-  time: string;
-  label: string;
-  color: string;
-}) {
-  return (
-    <div className="flex items-center gap-2 py-1.5 border-t border-border/50 first:border-t-0">
-      <span className="text-[10px] text-muted-foreground/60 w-12 shrink-0 tabular-nums">
-        {time}
-      </span>
-      <span
-        className="w-1.5 h-1.5 rounded-full shrink-0"
-        style={{ background: color }}
-      />
-      <span className="text-[11px] text-muted-foreground">{label}</span>
-    </div>
-  );
-}
-
-function InlineModeDiagram() {
-  return (
-    <div className="flex flex-col h-full">
-      <div className="text-sm font-medium text-foreground text-center mb-3">
-        Inline Mode
-      </div>
-      <div className="flex-1 border border-border rounded-2xl bg-background overflow-hidden flex flex-col">
-        <div className="flex-1 p-4 space-y-3 overflow-hidden">
-          {/* User message */}
-          <div className="flex justify-end">
-            <div className="bg-muted-foreground/20 rounded-2xl rounded-br px-3.5 py-2 max-w-[85%]">
-              <span className="text-[11px] text-foreground/80">
-                I have back-to-back meetings today
-              </span>
-            </div>
-          </div>
-
-          {/* AI response */}
-          <div className="space-y-2">
-            <p className="text-[11px] text-muted-foreground/70">
-              Packed day! Here&apos;s what you&apos;ve got:
-            </p>
-            <div className="bg-muted/40 border border-border rounded-xl p-3 w-[92%]">
-              <div className="text-[11px] font-semibold text-foreground/80 mb-2">
-                Today&apos;s Schedule
-              </div>
-              <ScheduleItem
-                time="10:00 AM"
-                label="Design Review"
-                color="#7aa2f7"
-              />
-              <ScheduleItem
-                time="1:00 PM"
-                label="Sprint Planning"
-                color="#bb9af7"
-              />
-              <ScheduleItem
-                time="3:30 PM"
-                label="Team Standup"
-                color="#9ece6a"
-              />
-              <ScheduleItem
-                time="4:30 PM"
-                label="Eng All-Hands"
-                color="#e0af68"
-              />
-            </div>
-          </div>
-        </div>
-
-        {/* Prompt input */}
-        <div className="p-2.5">
-          <div className="bg-muted/50 border border-border rounded-xl px-2.5 py-1.5 flex items-center gap-1.5">
-            <span className="text-[10px] text-muted-foreground/40 flex-1">
-              Message...
-            </span>
-            <div className="w-5 h-5 rounded-md bg-muted-foreground/20 flex items-center justify-center">
-              <svg
-                className="w-2.5 h-2.5 text-muted-foreground/50"
-                viewBox="0 0 24 24"
-                fill="currentColor"
-              >
-                <path
-                  d="M12 4l-1.41 1.41L16.17 11H4v2h12.17l-5.58 5.59L12 20l8-8z"
-                  transform="rotate(-90 12 12)"
-                />
-              </svg>
-            </div>
-          </div>
-        </div>
-      </div>
-      <div className="mt-3 flex flex-col items-center gap-2">
-        <div className="text-xs font-medium text-muted-foreground">
-          AI decides when UI beats text
-        </div>
-        <div className="flex items-center gap-1.5 text-[10px] text-muted-foreground/50">
-          <span>AI chatbots</span>
-          <span className="text-muted-foreground/30">/</span>
-          <span>Copilots</span>
-          <span className="text-muted-foreground/30">/</span>
-          <span>Assistants</span>
-        </div>
-      </div>
-    </div>
-  );
-}
-
-function LandingPage() {
-  return (
-    <div className="w-full h-full flex flex-col bg-muted/20">
-      {/* Nav */}
-      <div className="flex items-center justify-between px-3 py-2 border-b border-border/50">
-        <svg
-          width="12"
-          height="12"
-          viewBox="0 0 24 24"
-          fill="none"
-          className="shrink-0"
-        >
-          <rect
-            x="2"
-            y="14"
-            width="5"
-            height="8"
-            rx="1"
-            className="fill-muted-foreground/60"
-          />
-          <rect
-            x="9.5"
-            y="8"
-            width="5"
-            height="14"
-            rx="1"
-            className="fill-muted-foreground/60"
-          />
-          <rect
-            x="17"
-            y="2"
-            width="5"
-            height="20"
-            rx="1"
-            className="fill-muted-foreground/60"
-          />
-        </svg>
-        <div className="flex items-center gap-2">
-          <span className="text-[9px] text-muted-foreground/50">Pricing</span>
-          <span className="text-[9px] text-muted-foreground/50">Blog</span>
-          <span className="text-[8px] font-semibold bg-foreground text-background rounded-md px-1.5 py-0.5 whitespace-nowrap">
-            Get Started
-          </span>
-        </div>
-      </div>
-
-      {/* Hero */}
-      <div className="flex-1 flex flex-col items-center justify-center gap-2.5 text-center px-4">
-        <span className="text-[8px] font-medium text-green-400 bg-green-400/10 border border-green-400/15 rounded-full px-2 py-0.5">
-          Trusted by 2,000+ teams
-        </span>
-        <div className="text-sm font-bold text-foreground leading-tight">
-          Analytics that
-          <br />
-          move the needle
-        </div>
-        <div className="text-[10px] text-muted-foreground/50 leading-relaxed">
-          Ship what matters. No setup required.
-        </div>
-        <div className="flex gap-1.5 mt-1">
-          <button className="bg-foreground text-background text-[9px] font-semibold rounded-lg px-3 py-1.5 whitespace-nowrap">
-            Start Free
-          </button>
-          <button className="border border-border text-muted-foreground text-[9px] font-medium rounded-lg px-3 py-1.5 whitespace-nowrap">
-            Book Demo
-          </button>
-        </div>
-      </div>
-
-      {/* Footer */}
-      <div className="flex justify-center gap-3 py-2 border-t border-border/50">
-        <span className="text-[8px] text-muted-foreground/30">Privacy</span>
-        <span className="text-[8px] text-muted-foreground/30">Terms</span>
-        <span className="text-[8px] text-muted-foreground/30">Status</span>
-      </div>
-    </div>
-  );
-}
-
-function StandaloneModeDiagram() {
-  return (
-    <div className="flex flex-col h-full">
-      <div className="text-sm font-medium text-foreground text-center mb-3">
-        Standalone Mode
-      </div>
-      <div className="flex-1 border border-border rounded-2xl bg-background overflow-hidden flex flex-row">
-        {/* Left panel - conversation */}
-        <div className="w-[38%] border-r border-border/50 flex flex-col">
-          <div className="flex-1 p-3 space-y-2.5">
-            {/* User message */}
-            <div className="flex justify-end">
-              <div className="bg-muted-foreground/20 rounded-2xl rounded-br px-2.5 py-1.5">
-                <span className="text-[10px] text-foreground/80 block leading-relaxed">
-                  A landing page for my analytics startup
-                </span>
-              </div>
-            </div>
-            {/* AI text */}
-            <p className="text-[10px] text-muted-foreground/60 leading-relaxed">
-              Here&apos;s a clean landing page with a hero, nav, and CTAs.
-            </p>
-          </div>
-
-          {/* Prompt input */}
-          <div className="p-2.5">
-            <div className="bg-muted/50 border border-border rounded-xl px-2.5 py-1.5 flex items-center gap-1.5">
-              <span className="text-[10px] text-muted-foreground/40 flex-1">
-                Message...
-              </span>
-              <div className="w-5 h-5 rounded-md bg-muted-foreground/20 flex items-center justify-center">
-                <svg
-                  className="w-2.5 h-2.5 text-muted-foreground/50"
-                  viewBox="0 0 24 24"
-                  fill="currentColor"
-                >
-                  <path
-                    d="M12 4l-1.41 1.41L16.17 11H4v2h12.17l-5.58 5.59L12 20l8-8z"
-                    transform="rotate(-90 12 12)"
-                  />
-                </svg>
-              </div>
-            </div>
-          </div>
-        </div>
-
-        {/* Right panel - landing page */}
-        <div className="flex-1">
-          <LandingPage />
-        </div>
-      </div>
-      <div className="mt-3 flex flex-col items-center gap-2">
-        <div className="text-xs font-medium text-muted-foreground">
-          Prompt in, UI out
-        </div>
-        <div className="flex items-center gap-1.5 text-[10px] text-muted-foreground/50">
-          <span>Website builders</span>
-          <span className="text-muted-foreground/30">/</span>
-          <span>Text-to-widget</span>
-          <span className="text-muted-foreground/30">/</span>
-          <span>Dashboards</span>
-        </div>
-      </div>
-    </div>
-  );
-}
-
-export function GenerationModesDiagram() {
-  return (
-    <div className="not-prose my-8">
-      <div className="grid grid-cols-1 sm:grid-cols-2 gap-6">
-        <div className="h-[420px]">
-          <InlineModeDiagram />
-        </div>
-        <div className="h-[420px]">
-          <StandaloneModeDiagram />
-        </div>
-      </div>
-    </div>
-  );
-}

apps/web/components/header.tsx

@@ -1,65 +1,17 @@
 "use client";
 
-import { useState } from "react";
 import Link from "next/link";
 import { usePathname } from "next/navigation";
 import { ThemeToggle } from "./theme-toggle";
-import { Search } from "./search";
-import {
-  Sheet,
-  SheetTrigger,
-  SheetContent,
-  SheetTitle,
-} from "@/components/ui/sheet";
 import { cn } from "@/lib/utils";
 
-const navLinks = [
-  { href: "/playground", label: "Playground" },
-  { href: "/examples", label: "Examples" },
-  { href: "/docs", label: "Docs" },
-];
-
-function GitHubLink({
-  className,
-  stars,
-}: {
-  className?: string;
-  stars?: string;
-}) {
-  return (
-    <a
-      href="https://github.com/vercel-labs/json-render"
-      target="_blank"
-      rel="noopener noreferrer"
-      className={cn(
-        "flex items-center gap-1.5 text-sm text-muted-foreground hover:text-foreground transition-colors",
-        className,
-      )}
-    >
-      <svg
-        viewBox="0 0 16 16"
-        className="h-4 w-4"
-        fill="currentColor"
-        aria-hidden="true"
-      >
-        <path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z" />
-      </svg>
-      {stars && <span>{stars}</span>}
-    </a>
-  );
-}
-
-export function Header({ stars }: { stars?: string }) {
+export function Header() {
   const pathname = usePathname();
-  const [mobileOpen, setMobileOpen] = useState(false);
 
   const isActive = (href: string) => {
     if (href === "/playground") {
       return pathname === "/playground";
     }
-    if (href === "/examples") {
-      return pathname.startsWith("/examples");
-    }
     if (href === "/docs") {
       return pathname.startsWith("/docs");
     }
@@ -105,86 +57,53 @@ export function Header({ stars }: { stars?: string }) {
             </svg>
           </span>
           <Link href="/">
-            <span className="font-medium tracking-tight text-lg font-(family-name:--font-geist-pixel-square)">
+            <span className="font-medium tracking-tight text-lg">
               json-render
             </span>
           </Link>
         </div>
-
-        {/* Desktop nav */}
-        <nav className="hidden sm:flex items-center gap-4">
-          {navLinks.map((link) => (
-            <Link
-              key={link.href}
-              href={link.href}
-              className={cn(
-                "text-sm transition-colors",
-                isActive(link.href)
-                  ? "text-primary"
-                  : "text-muted-foreground hover:text-foreground",
-              )}
+        <nav className="flex items-center gap-4">
+          <Link
+            href="/playground"
+            className={cn(
+              "text-sm transition-colors",
+              isActive("/playground")
+                ? "text-primary font-medium"
+                : "text-muted-foreground hover:text-foreground",
+            )}
+          >
+            <span className="sm:hidden">Play</span>
+            <span className="hidden sm:inline">Playground</span>
+          </Link>
+          <Link
+            href="/docs"
+            className={cn(
+              "text-sm transition-colors",
+              isActive("/docs")
+                ? "text-primary font-medium"
+                : "text-muted-foreground hover:text-foreground",
+            )}
+          >
+            Docs
+          </Link>
+          <a
+            href="https://github.com/vercel-labs/json-render"
+            target="_blank"
+            rel="noopener noreferrer"
+            className="flex items-center gap-1.5 text-sm text-muted-foreground hover:text-foreground transition-colors"
+          >
+            <svg
+              viewBox="0 0 16 16"
+              className="h-4 w-4"
+              fill="currentColor"
+              aria-hidden="true"
             >
-              {link.label}
-            </Link>
-          ))}
-          <Search />
-          <GitHubLink stars={stars} />
+              <path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z" />
+            </svg>
+            <span>10.1k</span>
+          </a>
           <ThemeToggle />
         </nav>
-
-        {/* Mobile nav */}
-        <div className="flex sm:hidden items-center gap-3">
-          <Search />
-          <GitHubLink stars={stars} />
-          <Sheet open={mobileOpen} onOpenChange={setMobileOpen}>
-            <SheetTrigger
-              className="flex items-center justify-center"
-              aria-label="Open menu"
-            >
-              <svg
-                xmlns="http://www.w3.org/2000/svg"
-                width="20"
-                height="20"
-                viewBox="0 0 24 24"
-                fill="none"
-                stroke="currentColor"
-                strokeWidth="2"
-                strokeLinecap="round"
-                strokeLinejoin="round"
-                className="text-muted-foreground"
-              >
-                <line x1="4" x2="20" y1="12" y2="12" />
-                <line x1="4" x2="20" y1="6" y2="6" />
-                <line x1="4" x2="20" y1="18" y2="18" />
-              </svg>
-            </SheetTrigger>
-            <SheetContent side="right" className="overflow-y-auto p-6">
-              <SheetTitle className="mb-6">Menu</SheetTitle>
-              <nav className="flex flex-col gap-1">
-                {navLinks.map((link) => (
-                  <Link
-                    key={link.href}
-                    href={link.href}
-                    onClick={() => setMobileOpen(false)}
-                    className={cn(
-                      "block py-2.5 text-sm transition-colors",
-                      isActive(link.href)
-                        ? "text-primary"
-                        : "text-muted-foreground hover:text-foreground",
-                    )}
-                  >
-                    {link.label}
-                  </Link>
-                ))}
-                <div className="my-3 border-t border-border" />
-                <div className="flex items-center justify-between py-2.5">
-                  <span className="text-sm text-muted-foreground">Theme</span>
-                  <ThemeToggle />
-                </div>
-              </nav>
-            </SheetContent>
-          </Sheet>
-        </div>
       </div>
     </header>
   );

apps/web/components/search.tsx

@@ -1,266 +0,0 @@
-"use client";
-
-import { useCallback, useEffect, useRef, useState } from "react";
-import { useRouter } from "next/navigation";
-import { Dialog, DialogContent, DialogTitle } from "@/components/ui/dialog";
-import { cn } from "@/lib/utils";
-
-type SearchResult = {
-  title: string;
-  href: string;
-  section: string;
-  snippet: string;
-};
-
-export function Search() {
-  const router = useRouter();
-  const [open, setOpen] = useState(false);
-  const [query, setQuery] = useState("");
-  const [results, setResults] = useState<SearchResult[]>([]);
-  const [loading, setLoading] = useState(false);
-  const [activeIndex, setActiveIndex] = useState(0);
-  const inputRef = useRef<HTMLInputElement>(null);
-  const listRef = useRef<HTMLDivElement>(null);
-  const abortRef = useRef<AbortController | null>(null);
-
-  const navigate = useCallback(
-    (href: string) => {
-      setOpen(false);
-      setQuery("");
-      setResults([]);
-      router.push(href);
-    },
-    [router],
-  );
-
-  useEffect(() => {
-    function onKeyDown(e: KeyboardEvent) {
-      if ((e.metaKey || e.ctrlKey) && e.key === "k") {
-        e.preventDefault();
-        setOpen((prev) => !prev);
-      }
-    }
-    document.addEventListener("keydown", onKeyDown);
-    return () => document.removeEventListener("keydown", onKeyDown);
-  }, []);
-
-  useEffect(() => {
-    if (open) {
-      setTimeout(() => inputRef.current?.focus(), 0);
-    } else {
-      setQuery("");
-      setResults([]);
-    }
-  }, [open]);
-
-  useEffect(() => {
-    const q = query.trim();
-    if (!q) {
-      setResults([]);
-      setLoading(false);
-      return;
-    }
-
-    setLoading(true);
-    abortRef.current?.abort();
-    const controller = new AbortController();
-    abortRef.current = controller;
-
-    const timeout = setTimeout(async () => {
-      try {
-        const res = await fetch(`/api/search?q=${encodeURIComponent(q)}`, {
-          signal: controller.signal,
-        });
-        if (res.ok) {
-          const data = await res.json();
-          setResults(data.results);
-        }
-      } catch {
-        // aborted or network error
-      } finally {
-        if (!controller.signal.aborted) {
-          setLoading(false);
-        }
-      }
-    }, 150);
-
-    return () => {
-      clearTimeout(timeout);
-      controller.abort();
-    };
-  }, [query]);
-
-  useEffect(() => {
-    setActiveIndex(0);
-  }, [results]);
-
-  function handleKeyDown(e: React.KeyboardEvent) {
-    if (e.key === "ArrowDown") {
-      e.preventDefault();
-      setActiveIndex((i) => Math.min(i + 1, results.length - 1));
-    } else if (e.key === "ArrowUp") {
-      e.preventDefault();
-      setActiveIndex((i) => Math.max(i - 1, 0));
-    } else if (e.key === "Enter" && results[activeIndex]) {
-      e.preventDefault();
-      navigate(results[activeIndex].href);
-    }
-  }
-
-  useEffect(() => {
-    const active = listRef.current?.querySelector("[data-active='true']");
-    active?.scrollIntoView({ block: "nearest" });
-  }, [activeIndex]);
-
-  const hasQuery = query.trim().length > 0;
-
-  return (
-    <>
-      <button
-        onClick={() => setOpen(true)}
-        className="hidden sm:flex items-center gap-2 rounded-md border border-border bg-muted/50 px-3 py-1.5 text-sm text-muted-foreground hover:text-foreground hover:border-foreground/25 transition-colors"
-      >
-        <svg
-          xmlns="http://www.w3.org/2000/svg"
-          width="14"
-          height="14"
-          viewBox="0 0 24 24"
-          fill="none"
-          stroke="currentColor"
-          strokeWidth="2"
-          strokeLinecap="round"
-          strokeLinejoin="round"
-        >
-          <circle cx="11" cy="11" r="8" />
-          <path d="m21 21-4.3-4.3" />
-        </svg>
-        Search docs
-        <kbd className="pointer-events-none ml-1 inline-flex items-center gap-0.5 rounded border border-border bg-background px-1.5 py-0.5 font-mono text-[10px] text-muted-foreground">
-          <span>&#8984;</span>K
-        </kbd>
-      </button>
-
-      <button
-        onClick={() => setOpen(true)}
-        className="sm:hidden flex items-center text-muted-foreground hover:text-foreground transition-colors"
-        aria-label="Search docs"
-      >
-        <svg
-          xmlns="http://www.w3.org/2000/svg"
-          width="16"
-          height="16"
-          viewBox="0 0 24 24"
-          fill="none"
-          stroke="currentColor"
-          strokeWidth="2"
-          strokeLinecap="round"
-          strokeLinejoin="round"
-        >
-          <circle cx="11" cy="11" r="8" />
-          <path d="m21 21-4.3-4.3" />
-        </svg>
-      </button>
-
-      <Dialog open={open} onOpenChange={setOpen}>
-        <DialogContent
-          showCloseButton={false}
-          className="gap-0 p-0 sm:max-w-lg"
-        >
-          <DialogTitle className="sr-only">Search documentation</DialogTitle>
-          <div className="flex items-center gap-2 border-b px-3">
-            <svg
-              xmlns="http://www.w3.org/2000/svg"
-              width="16"
-              height="16"
-              viewBox="0 0 24 24"
-              fill="none"
-              stroke="currentColor"
-              strokeWidth="2"
-              strokeLinecap="round"
-              strokeLinejoin="round"
-              className="shrink-0 text-muted-foreground"
-            >
-              <circle cx="11" cy="11" r="8" />
-              <path d="m21 21-4.3-4.3" />
-            </svg>
-            <input
-              ref={inputRef}
-              value={query}
-              onChange={(e) => setQuery(e.target.value)}
-              onKeyDown={handleKeyDown}
-              placeholder="Search docs..."
-              className="flex-1 bg-transparent py-3 text-sm outline-none placeholder:text-muted-foreground"
-            />
-            {query && (
-              <button
-                onClick={() => setQuery("")}
-                className="text-muted-foreground hover:text-foreground"
-              >
-                <svg
-                  xmlns="http://www.w3.org/2000/svg"
-                  width="14"
-                  height="14"
-                  viewBox="0 0 24 24"
-                  fill="none"
-                  stroke="currentColor"
-                  strokeWidth="2"
-                  strokeLinecap="round"
-                  strokeLinejoin="round"
-                >
-                  <path d="M18 6 6 18" />
-                  <path d="m6 6 12 12" />
-                </svg>
-              </button>
-            )}
-          </div>
-
-          <div
-            ref={listRef}
-            className="max-h-[min(60vh,400px)] overflow-y-auto p-2"
-          >
-            {loading && hasQuery ? (
-              <div className="flex items-center justify-center py-6">
-                <div className="h-4 w-4 animate-spin rounded-full border-2 border-muted-foreground border-t-transparent" />
-              </div>
-            ) : hasQuery && results.length === 0 ? (
-              <p className="py-6 text-center text-sm text-muted-foreground">
-                No results found.
-              </p>
-            ) : !hasQuery ? (
-              <p className="py-6 text-center text-sm text-muted-foreground">
-                Type to search documentation...
-              </p>
-            ) : (
-              results.map((item, i) => (
-                <button
-                  key={item.href}
-                  data-active={i === activeIndex}
-                  onClick={() => navigate(item.href)}
-                  onMouseEnter={() => setActiveIndex(i)}
-                  className={cn(
-                    "flex w-full flex-col gap-1 rounded-md px-3 py-2 text-left transition-colors",
-                    i === activeIndex
-                      ? "bg-accent text-accent-foreground"
-                      : "text-foreground",
-                  )}
-                >
-                  <div className="flex items-center justify-between gap-2">
-                    <span className="text-sm font-medium">{item.title}</span>
-                    <span className="shrink-0 text-xs text-muted-foreground">
-                      {item.section}
-                    </span>
-                  </div>
-                  {item.snippet && (
-                    <span className="line-clamp-2 text-xs text-muted-foreground leading-relaxed">
-                      {item.snippet}
-                    </span>
-                  )}
-                </button>
-              ))
-            )}
-          </div>
-        </DialogContent>
-      </Dialog>
-    </>
-  );
-}

apps/web/components/table-of-contents.tsx

@@ -1,83 +0,0 @@
-"use client";
-
-import { useEffect, useState } from "react";
-import { usePathname } from "next/navigation";
-import { cn } from "@/lib/utils";
-
-type Heading = {
-  id: string;
-  text: string;
-  level: number;
-};
-
-function getHeadings(): Heading[] {
-  const article = document.querySelector("article");
-  if (!article) return [];
-  const elements = article.querySelectorAll("h2[id], h3[id]");
-  return Array.from(elements).map((el) => ({
-    id: el.id,
-    text: el.textContent?.replace(/#$/, "").trim() ?? "",
-    level: el.tagName === "H3" ? 3 : 2,
-  }));
-}
-
-export function TableOfContents() {
-  const pathname = usePathname();
-  const [headings, setHeadings] = useState<Heading[]>([]);
-  const [activeId, setActiveId] = useState<string>("");
-
-  useEffect(() => {
-    const timer = setTimeout(() => setHeadings(getHeadings()), 100);
-    return () => clearTimeout(timer);
-  }, [pathname]);
-
-  useEffect(() => {
-    if (headings.length === 0) return;
-
-    const observer = new IntersectionObserver(
-      (entries) => {
-        for (const entry of entries) {
-          if (entry.isIntersecting) {
-            setActiveId(entry.target.id);
-          }
-        }
-      },
-      { rootMargin: "0px 0px -75% 0px", threshold: 0.1 },
-    );
-
-    for (const h of headings) {
-      const el = document.getElementById(h.id);
-      if (el) observer.observe(el);
-    }
-
-    return () => observer.disconnect();
-  }, [headings]);
-
-  if (headings.length === 0) return null;
-
-  return (
-    <nav aria-label="On this page">
-      <h4 className="text-xs font-medium text-muted-foreground uppercase tracking-wider mb-3">
-        On this page
-      </h4>
-      <ul className="space-y-1">
-        {headings.map((h) => (
-          <li key={h.id}>
-            <a
-              href={`#${h.id}`}
-              className={cn(
-                "block text-xs leading-relaxed py-0.5 transition-colors",
-                h.level === 3 && "pl-3",
-                activeId === h.id
-                  ? "text-foreground"
-                  : "text-muted-foreground hover:text-foreground",
-              )}
-            >
-              {h.text}
-            </a>
-          </li>
-        ))}
-      </ul>
-    </nav>
-  );
-}

apps/web/components/theme-provider.tsx

@@ -6,7 +6,6 @@ export function ThemeProvider({ children }: { children: React.ReactNode }) {
   return (
     <NextThemesProvider
       attribute="class"
-      value={{ dark: "dark-theme", light: "light-theme" }}
       defaultTheme="dark"
       enableSystem
       disableTransitionOnChange

apps/web/components/ui/sheet.tsx

@@ -18,7 +18,7 @@ const SheetOverlay = React.forwardRef<
 >(({ className, ...props }, ref) => (
   <SheetPrimitive.Overlay
     className={cn(
-      "fixed inset-0 z-50 bg-black/75 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:duration-150 data-[state=open]:duration-150",
+      "fixed inset-0 z-50 bg-black/50 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:duration-150 data-[state=open]:duration-150",
       className,
     )}
     {...props}
@@ -27,26 +27,17 @@ const SheetOverlay = React.forwardRef<
 ));
 SheetOverlay.displayName = SheetPrimitive.Overlay.displayName;
 
-const sheetSideVariants = {
-  left: "inset-y-0 left-0 h-full w-3/4 max-w-xs border-r data-[state=closed]:slide-out-to-left data-[state=open]:slide-in-from-left",
-  right:
-    "inset-y-0 right-0 h-full w-3/4 max-w-xs data-[state=closed]:slide-out-to-right data-[state=open]:slide-in-from-right",
-};
-
 const SheetContent = React.forwardRef<
   React.ComponentRef<typeof SheetPrimitive.Content>,
-  React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content> & {
-    side?: "left" | "right";
-    overlayClassName?: string;
-  }
->(({ className, children, side = "left", overlayClassName, ...props }, ref) => (
+  React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>
+>(({ className, children, ...props }, ref) => (
   <SheetPortal>
-    <SheetOverlay className={overlayClassName} />
+    <SheetOverlay />
     <SheetPrimitive.Content
       ref={ref}
       className={cn(
         "fixed z-50 gap-4 bg-background p-6 shadow-lg transition ease-in-out data-[state=closed]:duration-150 data-[state=open]:duration-150 data-[state=open]:animate-in data-[state=closed]:animate-out focus:outline-none",
-        sheetSideVariants[side],
+        "inset-y-0 left-0 h-full w-3/4 max-w-xs border-r data-[state=closed]:slide-out-to-left data-[state=open]:slide-in-from-left",
         className,
       )}
       {...props}

apps/web/content/docs/ai-sdk.mdx

@@ -1,238 +0,0 @@
----
-title: "AI SDK Integration"
----
-
-Use json-render with the [Vercel AI SDK](https://sdk.vercel.ai) for seamless streaming. json-render supports two modes: **Standalone** (standalone UI) and **Inline** (UI embedded in conversation). See [Generation Modes](/docs/generation-modes) for a detailed comparison.
-
-## Installation
-
-```bash
-npm install ai @ai-sdk/react
-```
-
-## Standalone Mode
-
-In standalone mode, the AI outputs only JSONL patches. The entire response is a UI spec with no prose. This is the default mode and is ideal for playgrounds, builders, and dashboard generators.
-
-### API Route
-
-```typescript
-// app/api/generate/route.ts
-import { streamText } from "ai";
-import { catalog } from "@/lib/catalog";
-
-export async function POST(req: Request) {
-  const { prompt, currentTree } = await req.json();
-
-  const systemPrompt = catalog.prompt();
-
-  // Optionally include current UI state for context
-  const contextPrompt = currentTree
-    ? `\n\nCurrent UI state:\n${JSON.stringify(currentTree, null, 2)}`
-    : "";
-
-  const result = streamText({
-    model: yourModel,
-    system: systemPrompt + contextPrompt,
-    prompt,
-  });
-
-  return result.toTextStreamResponse();
-}
-```
-
-### Client
-
-Use `useUIStream` on the client to compile the JSONL stream into a spec:
-
-```tsx
-"use client";
-
-import { useUIStream, Renderer } from "@json-render/react";
-
-function GenerativeUI() {
-  const { spec, isStreaming, error, send } = useUIStream({
-    api: "/api/generate",
-  });
-
-  return (
-    <div>
-      <button
-        onClick={() => send("Create a dashboard with metrics")}
-        disabled={isStreaming}
-      >
-        {isStreaming ? "Generating..." : "Generate"}
-      </button>
-
-      {error && <p className="text-red-500">{error.message}</p>}
-
-      <Renderer spec={spec} registry={registry} loading={isStreaming} />
-    </div>
-  );
-}
-```
-
-## Inline Mode
-
-In inline mode, the AI responds conversationally and includes JSONL patches inline. Text-only replies are allowed when no UI is needed. This is ideal for chatbots, copilots, and educational assistants.
-
-### API Route
-
-Use `pipeJsonRender` to separate text from JSONL patches in the stream. Patches are emitted as data parts that the client can pick up.
-
-```typescript
-// app/api/chat/route.ts
-import { streamText } from "ai";
-import { pipeJsonRender } from "@json-render/core";
-import {
-  createUIMessageStream,
-  createUIMessageStreamResponse,
-} from "ai";
-import { catalog } from "@/lib/catalog";
-
-export async function POST(req: Request) {
-  const { messages } = await req.json();
-
-  const result = streamText({
-    model: yourModel,
-    system: catalog.prompt({ mode: "inline" }),
-    messages,
-  });
-
-  const stream = createUIMessageStream({
-    execute: async ({ writer }) => {
-      writer.merge(pipeJsonRender(result.toUIMessageStream()));
-    },
-  });
-
-  return createUIMessageStreamResponse({ stream });
-}
-```
-
-### Client
-
-Use `useChat` from the AI SDK and `useJsonRenderMessage` from json-render to extract the spec from each message:
-
-```tsx
-"use client";
-
-import { useChat } from "@ai-sdk/react";
-import { useJsonRenderMessage, Renderer } from "@json-render/react";
-
-function Chat() {
-  const { messages, input, handleInputChange, handleSubmit } = useChat({
-    api: "/api/chat",
-  });
-
-  return (
-    <div>
-      <div>
-        {messages.map((msg) => (
-          <ChatMessage key={msg.id} message={msg} />
-        ))}
-      </div>
-
-      <form onSubmit={handleSubmit}>
-        <input
-          value={input}
-          onChange={handleInputChange}
-          placeholder="Ask something..."
-        />
-        <button type="submit">Send</button>
-      </form>
-    </div>
-  );
-}
-
-function ChatMessage({ message }: { message: { parts: Array<{ type: string; text?: string; data?: unknown }> } }) {
-  const { spec, text, hasSpec } = useJsonRenderMessage(message.parts);
-
-  return (
-    <div>
-      {text && <p>{text}</p>}
-      {hasSpec && spec && (
-        <Renderer spec={spec} registry={registry} />
-      )}
-    </div>
-  );
-}
-```
-
-## Prompt Engineering
-
-The `catalog.prompt()` method creates an optimized system prompt that:
-
-- Lists all available components and their props
-- Describes available actions
-- Specifies the expected output format (JSONL-only or text + JSONL depending on mode)
-- Includes examples for better generation
-
-### Custom Rules
-
-Pass custom rules to tailor AI behavior:
-
-```typescript
-const systemPrompt = catalog.prompt({
-  customRules: [
-    "Always use Card components for grouping related content",
-    "Prefer horizontal layouts (Row) for metrics",
-    "Use consistent spacing with padding=\"md\"",
-  ],
-});
-```
-
-### Inline Mode Prompt
-
-```typescript
-const inlinePrompt = catalog.prompt({ mode: "inline" });
-```
-
-In inline mode, the prompt instructs the AI to respond conversationally first, then include JSONL patches on their own lines when UI is needed. Text-only replies are allowed.
-
-## Which Mode?
-
-<div className="my-6 overflow-x-auto">
-  <table className="mdx-table w-full text-sm border-collapse">
-    <thead>
-      <tr>
-        <th></th>
-        <th>Standalone</th>
-        <th>Inline</th>
-      </tr>
-    </thead>
-    <tbody>
-      <tr>
-        <td>Output</td>
-        <td>JSONL only</td>
-        <td>Text + JSONL</td>
-      </tr>
-      <tr>
-        <td>Text-only replies</td>
-        <td>No</td>
-        <td>Yes</td>
-      </tr>
-      <tr>
-        <td>System prompt</td>
-        <td><code>catalog.prompt()</code></td>
-        <td><code>{"catalog.prompt({ mode: \"inline\" })"}</code></td>
-      </tr>
-      <tr>
-        <td>Stream utility</td>
-        <td><code>useUIStream</code></td>
-        <td><code>pipeJsonRender</code> + <code>useJsonRenderMessage</code></td>
-      </tr>
-      <tr>
-        <td>Use case</td>
-        <td>Playgrounds, builders</td>
-        <td>Chatbots, copilots</td>
-      </tr>
-    </tbody>
-  </table>
-</div>
-
-Learn more in the [Generation Modes](/docs/generation-modes) guide.
-
-## Next
-
-- Learn about [progressive streaming](/docs/streaming)
-- See the [chat example](https://github.com/vercel-labs/json-render/tree/main/examples/chat) for a complete implementation

apps/web/content/docs/api/core.mdx

@@ -1,795 +0,0 @@
----
-title: "@json-render/core"
----
-
-Core types, schemas, and utilities.
-
-## experimental_composeSpec
-
-**Experimental, unreleased:** may change in any release. Pin exact versions when published; see [source-build setup and the full Jev guide](/docs/jev).
-
-```typescript
-import {
-  experimental_composeSpec,
-  type Experimental_CompositionCandidate,
-  type Experimental_CompositionEvaluator,
-  type Experimental_CompositionEvent,
-} from "@json-render/core";
-
-const events = experimental_composeSpec({
-  catalog,             // Standard flat Spec catalog
-  candidates,          // App-owned atomic elements
-  prompt,              // User request
-  evaluate,            // Experimental_CompositionEvaluator
-  initialState: {},    // Included in spec; not sent to evaluator
-  initialSpec,         // Optional selected version to edit; never mutated
-  elementDescriptions: {}, // Optional descriptions of existing element IDs
-  context: {},         // Explicitly shared evaluator context
-  strategy: "batch",  // Default for new trees; edits are sequential
-  maxElements: 32,     // Batched creation only, includes the root
-  maxSteps: 32,        // Evaluation calls, including terminal decisions
-  maxDepth: 8,         // Root depth is one
-  signal,              // AbortSignal, optional
-  instructions: { root: "", next: "", parent: "" }, // Appended guidance
-});
-```
-
-A candidate has `id`, `description`, `element`, optional `root` (default true), `maxUses` (default one), and `resource` (mutually exclusive variants). IDs start with a letter and contain only letters, digits, underscores, and hyphens. IDs must be unique; `finish` and `unavailable` are reserved. Elements accept `type`, `props`, optional `on`, and `visible`. The composer supplies children and named slots.
-
-Events are full detached snapshots. A `step` contains `spec` and `step`; `complete` contains nullable `spec`, `steps`, `elapsedMs`, nullable `inputTokens`, and `stopReason` (`finish`, `limit`, or `unavailable`). Each trace step contains `index`, `choice`, `description`, nullable `parent`/`slot`, nullable `confidence`/`parentConfidence`, `elapsedMs`, and nullable `inputTokens`. Batched steps also contain `answers`, keyed by question name, with each selected `choice` and optional confidence. Each trace represents one evaluation: batched timing and usage are counted once, not once per answer. Indexes start at zero. Completion is not a guarantee of semantic correctness.
-
-### Batched creation
-
-With no `initialSpec`, `strategy: "batch"` is the default. The first evaluation selects the root and required components together. Shared `resource` variants use one exclusive choice; reusable recipes use bounded counts that include the root when applicable. Root selection takes precedence over speculative membership for the same recipe/resource. The first snapshot includes all selected elements in catalog order under the root's default slot, or its first declared slot when there is no default.
-
-A second evaluation selects parents and sibling positions from the actual selected set. Equal positions retain catalog order. The combined tree must pass catalog, slot, depth, and tree validation before publication; a cycle or invalid layout throws and preserves the first snapshot as partial output. A single root or one child in a single slot needs no layout call. No separate finish call is made.
-
-`maxElements` limits batched creation, including the root. A truncated selection, insufficient depth for selected content, or a call budget that prevents required layout returns `limit`. Use `strategy: "sequential"` for one-operation-at-a-time creation. Edits always use the sequential protocol.
-
-Invalid configuration, out-of-set decisions, provider failures, and aborts throw. Previous snapshots remain usable as partial UI. Stopping iteration prevents further evaluation calls. A supplied signal also stops waiting for an evaluator that ignores cancellation; that evaluator must honor the signal to stop its underlying work.
-
-### Custom evaluators
-
-The composer is provider independent. An evaluator receives `state`, `questions`, and `signal`, then returns a selected criteria key for each question:
-
-```typescript
-const evaluate: Experimental_CompositionEvaluator = async ({ state, questions, signal }) => {
-  // Your adapter calls a decision model with this request.
-  const result = await yourEvaluator({ state, questions, signal });
-  return {
-    answers: result.answers, // { [questionName]: { choice: "offered_key", confidence: 0.9 } }
-    usage: { inputTokens: result.inputTokens }, // Optional
-  };
-};
-```
-
-Questions are records of `type: "choice"`, `instructions`, and `criteria` (choice key to description). Return an answer for every question and treat question/choice keys as opaque. Batched creation sends `root` and `select_*` questions, then `parent_*` and `order_*` questions. Sequential creation and edits use `next` to select an operation, `finish`, or `unavailable`, with `parent` when several attachment points exist. Existing adapters that only implement `next`/`parent` must opt into `strategy: "sequential"`. Confidence must be in [0, 1] when provided; input tokens must be a nonnegative integer.
-
-State contains `user_request` and explicit app `context`, plus capabilities/guidance during batched selection, `selected_elements` during layout, or `already_built` during sequential composition. Candidate descriptions and instructions are shared; raw state/props/binding values are not automatically included. See [validation and v1 limits](/docs/jev#validation-and-v1-limits).
-
-### Follow-up edits
-
-Pass `initialSpec` to edit an existing version. The composer validates and clones it, preserving unchanged elements, IDs, action bindings, and state. `initialState` explicitly overrides `initialSpec.state` when provided. Optional `elementDescriptions` maps existing IDs to descriptions shared with the evaluator; matching candidates supply the default description, otherwise only the component type is shared.
-
-Editing adds bounded operations: replace an element with an offered recipe, remove a non-root subtree, and move/reorder a subtree to an allowed slot/position. Replacements preserve children and are offered only when the new component can contain them. Moves cannot create cycles or exceed the depth limit. Seed specs with cycles, shared children, missing references, unreachable nodes, or unsupported expressions are rejected before evaluation.
-
-The `next` question offers opaque operation keys as well as candidate IDs. For replacement or movement, the following evaluation selects a recipe or destination, also through `next`. Both calls count toward `maxSteps`; the first emits an unchanged snapshot with its decision trace. `changes_made` supplies the edit trace alongside `already_built`. A budget limit, unavailable result, or cancellation may leave a selected edit unapplied. Existing elements exactly matching a recipe count toward `maxUses` and `resource`; removing/replacing them releases those limits.
-
-## experimental_createEvaluator
-
-**Experimental:** creates a server-side evaluator using Vercel AI Gateway's experimental v4 evaluation transport. No AI SDK dependency or provider constructor is required.
-
-```typescript
-import { experimental_createEvaluator } from "@json-render/core";
-
-const evaluate = experimental_createEvaluator({
-  apiKey: process.env.AI_GATEWAY_API_KEY!, // Required; keep server-side
-  model: "typesafe-ai/jev",               // Required, plain Gateway evaluation model ID
-  timeoutMs: 10_000,                      // Default, per evaluation
-  fetch: globalThis.fetch,               // Optional transport override
-});
-```
-
-The factory uses model-neutral naming and requires an explicit model. Jev is the current tested example; other models must support the Gateway choice-evaluation protocol. When using Jev, the Gateway team must permit TypeSafe AI. The adapter reports HTTP status on failure and rejects malformed/unoffered decisions. For Jev, it normalizes TypeSafe's native confidence rather than treating option probability as confidence. Confidence from other provider metadata is not yet normalized. Missing confidence and usage remain unknown. It does not retry automatically or estimate cost.
-
-## defineCatalog
-
-Creates a type-safe catalog definition with schema validation.
-
-```typescript
-import { defineCatalog } from '@json-render/core';
-import { schema } from '@json-render/react/schema';
-
-function defineCatalog<T extends ZodType>(
-  s: T,
-  config: CatalogConfig
-): Catalog
-
-// Use the React schema for standard UI specs
-const catalog = defineCatalog(schema, {
-  components: {...},
-  actions: {...},
-});
-```
-
-### CatalogConfig
-
-```typescript
-interface CatalogConfig {
-  components: Record<string, ComponentDefinition>;
-  actions?: Record<string, ActionDefinition>;
-  functions?: Record<string, FunctionDefinition>;
-}
-
-interface ComponentDefinition {
-  props: ZodObject;         // Use .nullable() for optional props
-  slots?: string[];         // Named slots (e.g., ["default"])
-  description?: string;     // Help AI understand usage
-}
-
-interface ActionDefinition {
-  params?: ZodObject;
-  description?: string;
-}
-
-interface FunctionDefinition {
-  description?: string;
-}
-```
-
-### Catalog Instance
-
-The returned catalog provides methods for AI prompt generation, validation, and schema export:
-
-```typescript
-interface Catalog {
-  // Data
-  readonly data: CatalogConfig;         // The catalog configuration
-  readonly componentNames: string[];    // List of component names
-  readonly actionNames: string[];       // List of action names
-
-  // AI Prompt Generation
-  prompt(options?: PromptOptions): string;
-
-  // Validation
-  validate(spec: unknown): SpecValidationResult;
-  zodSchema(): z.ZodType;               // Get the Zod schema for specs
-
-  // Export
-  jsonSchema(): object;                 // Export as JSON Schema
-}
-
-interface PromptOptions {
-  system?: string;           // Custom system message intro
-  customRules?: string[];    // Additional rules to append
-  mode?: "standalone" | "inline" | "generate" | "chat"; // Output mode (default: "standalone")
-  editModes?: EditMode[];    // Edit modes to document in prompt (default: ["patch"])
-}
-
-interface SpecValidationResult<T> {
-  success: boolean;
-  data?: T;               // Validated spec (if success)
-  error?: z.ZodError;     // Validation errors (if failed)
-}
-```
-
-### Catalog Methods
-
-```typescript
-// Generate AI system prompt
-const systemPrompt = catalog.prompt({
-  customRules: ["Always use Card as root element"],
-});
-
-// Validate a spec from AI
-const result = catalog.validate(aiOutput);
-if (result.success) {
-  render(result.data);
-} else {
-  console.error(result.error);
-}
-
-// Get Zod schema for custom validation
-const schema = catalog.zodSchema();
-const parsed = schema.safeParse(aiOutput);
-
-// Export as JSON Schema (for structured outputs)
-const jsonSchema = catalog.jsonSchema();
-```
-
-## Schema System
-
-json-render uses a flexible schema system that defines both the AI output format (spec) and what catalogs must provide. Each renderer package provides its own schema (e.g., @json-render/react exports `schema`).
-
-### schema
-
-The schema for flat UI element trees. This is exported from @json-render/react.
-
-```typescript
-import { defineCatalog } from '@json-render/core';
-import { schema } from '@json-render/react/schema';
-
-// schema defines:
-// - Spec shape: { root: string, elements: Record<string, UIElement> }
-// - Catalog shape: { components: {...}, actions: {...} }
-
-const catalog = defineCatalog(schema, {
-  components: {
-    Card: {
-      props: z.object({ title: z.string() }),
-      slots: ["default"],
-      description: "Container card",
-    },
-  },
-  actions: {
-    submit: {
-      params: z.object({ formId: z.string() }),
-      description: "Submit a form",
-    },
-  },
-});
-```
-
-### SchemaOptions
-
-When creating schemas with `defineSchema`, you can pass options:
-
-```typescript
-interface SchemaOptions {
-  promptTemplate?: PromptTemplate;  // Custom AI prompt generator
-  defaultRules?: string[];          // Default rules injected before custom rules in prompts
-  builtInActions?: BuiltInAction[]; // Actions always available at runtime, auto-injected into prompts
-}
-
-interface BuiltInAction {
-  name: string;        // Action name (e.g. "setState")
-  description: string; // Human-readable description for the LLM
-}
-```
-
-Built-in actions are injected into prompts as `[built-in]` and are handled by the runtime (e.g. `ActionProvider`) without requiring handlers in `defineRegistry`. The React schema declares `setState`, `pushState`, and `removeState` as built-in.
-
-### defineSchema
-
-Create custom schemas for different output formats (e.g., page-based, block-based).
-
-```typescript
-import { defineSchema } from '@json-render/core';
-
-const mySchema = defineSchema((s) => ({
-  // What the AI outputs (spec)
-  spec: s.object({
-    title: s.string(),
-    blocks: s.array(s.object({
-      type: s.ref("catalog.blocks"),
-      content: s.any(),
-    })),
-  }),
-
-  // What the catalog must provide
-  catalog: s.object({
-    blocks: s.map({
-      props: s.zod(),
-      description: s.string(),
-    }),
-  }),
-}));
-```
-
-### Schema Builder API
-
-The schema builder provides these methods:
-
-```typescript
-// Primitive types
-s.string()           // String value
-s.number()           // Number value
-s.boolean()          // Boolean value
-s.any()              // Any value
-
-// Compound types
-s.array(item)        // Array of items
-s.object({ ... })    // Object with shape
-s.record(value)      // Record/map with value type
-
-// Catalog references (for type safety)
-s.ref("catalog.components")      // Reference to catalog key (becomes enum)
-s.propsOf("catalog.components")  // Props schema from catalog entry
-
-// Catalog definitions
-s.map({ props: s.zod(), ... })   // Map of named entries with shared shape
-s.zod()                          // Placeholder for user-provided Zod schema
-
-// Modifiers
-s.optional()         // Mark field as optional
-```
-
-## Zod Schemas
-
-Pre-built Zod schemas for common json-render types:
-
-### Dynamic Value Schemas
-
-```typescript
-import {
-  DynamicValueSchema,    // string | number | boolean | null | { $state: string }
-  DynamicStringSchema,   // string | { $state: string }
-  DynamicNumberSchema,   // number | { $state: string }
-  DynamicBooleanSchema,  // boolean | { $state: string }
-} from '@json-render/core';
-
-// Dynamic values can be literals or state path references
-type DynamicValue<T> = T | { $state: string };
-
-// Example: a prop that can be a literal or bound to state
-const schema = z.object({
-  label: DynamicStringSchema,  // "Hello" or { $state: "/user/name" }
-});
-```
-
-### Visibility Schemas
-
-```typescript
-import { VisibilityConditionSchema } from '@json-render/core';
-
-// Use in component props that need conditional rendering
-const schema = z.object({
-  visible: VisibilityConditionSchema.optional(),
-});
-```
-
-### Action Schemas
-
-```typescript
-import {
-  ActionSchema,           // Full action definition
-  ActionConfirmSchema,    // Confirmation dialog config
-  ActionOnSuccessSchema,  // Success handler config
-  ActionOnErrorSchema,    // Error handler config
-} from '@json-render/core';
-```
-
-### Validation Schemas
-
-```typescript
-import {
-  ValidationCheckSchema,   // Single validation check
-  ValidationConfigSchema,  // Full validation config with checks array
-} from '@json-render/core';
-```
-
-## SpecStream
-
-SpecStream is json-render's streaming format for progressively building specs from JSONL patches.
-
-### createSpecStreamCompiler
-
-Create a streaming compiler that incrementally builds a spec:
-
-```typescript
-import { createSpecStreamCompiler } from '@json-render/core';
-
-const compiler = createSpecStreamCompiler<MySpec>();
-
-// Process streaming chunks
-const { result, newPatches } = compiler.push(chunk);
-
-// Get final result
-const spec = compiler.getResult();
-
-// Reset for reuse
-compiler.reset();
-```
-
-### compileSpecStream
-
-Compile an entire SpecStream string at once:
-
-```typescript
-import { compileSpecStream } from '@json-render/core';
-
-const jsonl = `{"op":"add","path":"/root","value":{}}
-{"op":"add","path":"/root/type","value":"Card"}`;
-
-const spec = compileSpecStream<MySpec>(jsonl);
-```
-
-### Low-Level Utilities
-
-```typescript
-import {
-  parseSpecStreamLine,
-  applySpecStreamPatch,
-} from '@json-render/core';
-
-// Parse a single line
-const patch = parseSpecStreamLine('{"op":"add","path":"/root","value":{}}');
-
-// Apply patch to object (mutates in place)
-const obj = {};
-applySpecStreamPatch(obj, patch);
-```
-
-### applySpecPatch
-
-Apply a single SpecStream patch to a Spec object (mutates in place, returns the spec):
-
-```typescript
-import { applySpecPatch } from '@json-render/core';
-
-let spec: Spec = { root: "", elements: {} };
-applySpecPatch(spec, { op: "add", path: "/root", value: "main" });
-
-// For React state updates, spread to create a new reference:
-setSpec({ ...applySpecPatch(spec, patch) });
-```
-
-### nestedToFlat
-
-Convert a nested element tree (with inline children and named slots) into the flat `Spec` format:
-
-```typescript
-import { nestedToFlat } from '@json-render/core';
-
-const flat = nestedToFlat({
-  type: "Layout",
-  props: {},
-  children: [{ type: "Text", props: { content: "Main" }, children: [] }],
-  slots: {
-    header: [{ type: "Heading", props: { text: "Header" }, children: [] }],
-  },
-});
-// { root: "el-0", elements: { "el-0": ..., "el-1": ... } }
-```
-
-### createJsonRenderTransform
-
-Low-level `TransformStream` that separates text from JSONL patches in a mixed AI stream. Lines that parse as JSONL patches are emitted as `data-spec` parts; everything else passes through as text.
-
-The transform properly splits text blocks around spec data by emitting `text-end`/`text-start` pairs, ensuring the AI SDK creates separate text parts and preserving correct interleaving of prose and UI in `message.parts`.
-
-```typescript
-import { createJsonRenderTransform } from '@json-render/core';
-
-const transform = createJsonRenderTransform();
-// Use with ReadableStream.pipeThrough(transform) for custom pipelines
-```
-
-Most users should use `pipeJsonRender()` instead, which wraps this transform for the common AI SDK use case.
-
-### createMixedStreamParser
-
-Parse a mixed stream of text and JSONL patches (used for Inline mode):
-
-```typescript
-import { createMixedStreamParser } from '@json-render/core';
-
-const parser = createMixedStreamParser({
-  onText: (text) => appendToMessage(text),
-  onPatch: (patch) => applySpecPatch(spec, patch),
-});
-
-// As chunks arrive from the stream:
-for await (const chunk of stream) {
-  parser.push(chunk);
-}
-parser.flush();
-```
-
-### pipeJsonRender
-
-Pipe an AI SDK `UIMessageStream` through the json-render transform. Lines that parse as JSONL patches are emitted as `data-spec` parts; everything else passes through as text. Used in Inline mode API routes.
-
-```typescript
-import { pipeJsonRender } from '@json-render/core';
-import { createUIMessageStream, createUIMessageStreamResponse } from 'ai';
-
-const stream = createUIMessageStream({
-  execute: async ({ writer }) => {
-    writer.merge(pipeJsonRender(result.toUIMessageStream()));
-  },
-});
-return createUIMessageStreamResponse({ stream });
-```
-
-See [Generation Modes](/docs/generation-modes) for full Inline mode setup.
-
-### SpecStream Types
-
-Fully compliant with [RFC 6902](https://datatracker.ietf.org/doc/html/rfc6902):
-
-```typescript
-interface SpecStreamLine {
-  op: 'add' | 'remove' | 'replace' | 'move' | 'copy' | 'test';
-  path: string;
-  value?: unknown;  // Required for add, replace, test
-  from?: string;    // Required for move, copy
-}
-
-interface SpecStreamCompiler<T> {
-  push(chunk: string): { result: T; newPatches: SpecStreamLine[] };
-  getResult(): T;
-  getPatches(): SpecStreamLine[];
-  reset(): void;
-}
-
-interface MixedStreamCallbacks {
-  onText: (text: string) => void;
-  onPatch: (patch: SpecStreamLine) => void;
-}
-
-interface MixedStreamParser {
-  push(chunk: string): void;
-  flush(): void;
-}
-```
-
-## Utility Functions
-
-### Path Utilities
-
-```typescript
-import { getByPath, setByPath } from '@json-render/core';
-
-// Get value by JSON Pointer path
-const value = getByPath(state, '/user/name');  // "Alice"
-
-// Set value by path (mutates object)
-setByPath(state, '/user/email', 'alice@example.com');
-```
-
-### resolveDynamicValue
-
-```typescript
-import { resolveDynamicValue } from '@json-render/core';
-
-// Resolve a dynamic value against state
-const name = resolveDynamicValue("Hello", state);        // "Hello"
-const name2 = resolveDynamicValue({ $state: "/user/name" }, state);  // "Alice"
-```
-
-### findFormValue
-
-Read a value from resolved action parameters or state. A parameter value is literal, including strings with dots such as emails, URLs, and versions. Lookup order: a defined direct parameter, a parameter key ending in `.<fieldName>`, a matching flat state key, then a slash-delimited path in nested state.
-
-```typescript
-import { findFormValue } from '@json-render/core';
-
-findFormValue("email", { email: "john.doe@example.com" }, {});
-findFormValue("email", { "form.email": "john.doe@example.com" }, {});
-findFormValue("email", {}, { "form.email": "john.doe@example.com" });
-findFormValue("/form/email", {}, { form: { email: "john.doe@example.com" } });
-```
-
-For action bindings, use `{ $state: "/form/email" }` to read nested state: the action resolver passes the resulting value to the handler. A raw string like `"form.email"` in parameters is not a state reference. A bare `"email"` field name does not search `state.form.email`.
-
-## buildUserPrompt
-
-Build structured user prompts for AI generation, with support for refinement and state context.
-
-```typescript
-import { buildUserPrompt } from '@json-render/core';
-
-function buildUserPrompt(options: UserPromptOptions): string
-
-interface UserPromptOptions {
-  prompt: string;                        // The user's text prompt
-  currentSpec?: Spec | null;             // Existing spec to refine (triggers edit mode)
-  state?: Record<string, unknown> | null; // Runtime state context to include
-  maxPromptLength?: number;              // Max length for user text (truncates before wrapping)
-  editModes?: EditMode[];                // Edit modes for refinement (default: ["patch"])
-}
-```
-
-### Fresh generation
-
-```typescript
-const userPrompt = buildUserPrompt({ prompt: "create a todo app" });
-```
-
-### Refinement (edit modes)
-
-When `currentSpec` is provided, the prompt instructs the AI to use the specified edit modes instead of recreating the entire spec. Available modes: `"patch"` (RFC 6902), `"merge"` (RFC 7396), and `"diff"` (unified diff).
-
-```typescript
-const userPrompt = buildUserPrompt({
-  prompt: "add a dark mode toggle",
-  currentSpec: existingSpec,
-  editModes: ["patch", "merge"],
-});
-```
-
-### With state context
-
-Include runtime state so the AI knows what data is available:
-
-```typescript
-const userPrompt = buildUserPrompt({
-  prompt: "show my data",
-  state: { todos: [{ text: "Buy milk" }] },
-});
-```
-
-## Edit Modes
-
-Universal edit mode utilities for modifying existing specs. Used by `buildUserPrompt` internally and available for direct use.
-
-```typescript
-import {
-  buildEditInstructions,
-  buildEditUserPrompt,
-  isNonEmptySpec,
-  type EditMode,
-  type EditConfig,
-} from '@json-render/core';
-
-type EditMode = "patch" | "merge" | "diff";
-```
-
-### buildEditInstructions
-
-Generate the prompt section describing available edit modes. Supports both JSON and YAML formats.
-
-```typescript
-function buildEditInstructions(config: EditConfig, format: "json" | "yaml"): string
-
-const instructions = buildEditInstructions({ modes: ["patch", "merge"] }, "json");
-```
-
-### buildEditUserPrompt
-
-Build a user prompt for editing an existing spec. Includes the current spec (with line numbers when diff mode is enabled) and mode-specific instructions.
-
-```typescript
-function buildEditUserPrompt(options: BuildEditUserPromptOptions): string
-
-interface BuildEditUserPromptOptions {
-  prompt: string;
-  currentSpec?: Spec | null;
-  config?: EditConfig;
-  format: "json" | "yaml";
-  maxPromptLength?: number;
-  serializer?: (spec: Spec) => string;
-}
-```
-
-### isNonEmptySpec
-
-Check whether a value is a non-empty spec (has a root string and at least one element).
-
-```typescript
-function isNonEmptySpec(spec: unknown): spec is Spec
-```
-
-## Deep Merge and Diff
-
-Format-agnostic utilities for merging and diffing spec objects.
-
-### deepMergeSpec
-
-Deep-merge with RFC 7396 semantics: `null` deletes, arrays replace, objects recurse. Neither input is mutated.
-
-```typescript
-import { deepMergeSpec } from '@json-render/core';
-
-function deepMergeSpec(
-  base: Record<string, unknown>,
-  patch: Record<string, unknown>
-): Record<string, unknown>
-
-const merged = deepMergeSpec(currentSpec, { elements: { main: { props: { title: "New" } } } });
-```
-
-### diffToPatches
-
-Generate RFC 6902 JSON Patch operations that transform one object into another. Arrays are compared shallowly and replaced atomically; plain objects recurse.
-
-```typescript
-import { diffToPatches } from '@json-render/core';
-
-function diffToPatches(
-  oldObj: Record<string, unknown>,
-  newObj: Record<string, unknown>,
-  basePath?: string
-): JsonPatch[]
-
-const patches = diffToPatches(oldSpec, newSpec);
-// [{ op: "replace", path: "/elements/main/props/title", value: "New Title" }]
-```
-
-## evaluateVisibility
-
-Evaluates a visibility condition against the state model.
-
-```typescript
-function evaluateVisibility(
-  condition: VisibilityCondition | undefined,
-  ctx: VisibilityContext
-): boolean
-
-interface VisibilityContext {
-  stateModel: StateModel;
-  repeatItem?: unknown;    // Current repeat item (inside repeat scope)
-  repeatIndex?: number;    // Current repeat array index (inside repeat scope)
-}
-
-type VisibilityCondition =
-  | { $state: string }                                    // truthiness
-  | { $state: string; not: true }                         // falsy
-  | { $state: string; eq: unknown }                       // equality
-  | { $state: string; neq: unknown }                      // inequality
-  | { $state: string; gt: number }                        // greater than
-  | { $state: string; gte: number }                       // gte
-  | { $state: string; lt: number }                        // lt
-  | { $state: string; lte: number }                       // lte
-  | { $item: string }                                     // item field (repeat scope)
-  | { $item: string; eq: unknown }                        // item field equality
-  | { $index: true }                                      // index truthiness (repeat scope)
-  | { $index: true; gt: number }                          // index comparison
-  | VisibilityCondition[]                                 // implicit AND
-  | { $and: VisibilityCondition[] }                       // explicit AND
-  | { $or: VisibilityCondition[] }                        // OR
-  | boolean;                                              // always / never
-```
-
-## Types
-
-### UIElement
-
-```typescript
-interface UIElement {
-  type: string;
-  props: Record<string, unknown>;
-  children?: string[];          // Keys of child elements
-  slots?: Record<string, string[]>; // Named slots mapped to child keys
-  visible?: VisibilityCondition;
-  on?: Record<string, ActionBinding | ActionBinding[]>;  // Event bindings
-  repeat?: { statePath: string | { $item: string }; key?: string }; // Repeat for arrays
-}
-```
-
-Elements are stored in the `elements` map keyed by string IDs. The key comes from the map, not from the element itself.
-
-### Spec (Element Tree)
-
-```typescript
-interface Spec {
-  root: string | null;                        // Key of root element
-  elements: Record<string, UIElement>;        // Flat element map
-  state?: Record<string, unknown>;            // Initial state model
-}
-```
-
-Elements are stored as a flat map with string keys. The tree structure is built by following `children` and named `slots` references.
-
-### ActionBinding
-
-```typescript
-interface ActionBinding {
-  action: string;
-  params?: Record<string, DynamicValue>;
-  confirm?: {
-    title: string;
-    message: string;
-    variant?: 'default' | 'danger';
-  };
-  onSuccess?: { set: Record<string, unknown> };
-  onError?: { set: Record<string, unknown> };
-  preventDefault?: boolean;  // Prevent default browser behavior (e.g. navigation on links)
-}
-```
-
-### ValidationSchema
-
-```typescript
-interface ValidationSchema {
-  checks: ValidationCheck[];
-  validateOn?: 'change' | 'blur' | 'submit';
-}
-
-interface ValidationCheck {
-  type: string;
-  args?: Record<string, unknown>;
-  message: string;
-}
-```

apps/web/content/docs/api/devtools-react.mdx

@@ -1,58 +0,0 @@
----
-title: "@json-render/devtools-react"
----
-
-React adapter for the json-render devtools. Drop-in `<JsonRenderDevtools />` component.
-
-See the [Devtools guide](/docs/devtools) for the drop-in walkthrough.
-
-## JsonRenderDevtools
-
-```tsx
-import { JsonRenderDevtools } from "@json-render/devtools-react";
-
-<JSONUIProvider registry={registry} handlers={handlers}>
-  <Renderer spec={spec} registry={registry} />
-  <JsonRenderDevtools spec={spec} catalog={catalog} messages={messages} />
-</JSONUIProvider>
-```
-
-### Props
-
-```tsx
-interface JsonRenderDevtoolsProps {
-  /** Current spec being rendered. */
-  spec?: Spec | null;
-  /** Catalog definition (required for the Catalog panel). */
-  catalog?: Catalog | null;
-  /** AI SDK useChat messages array. */
-  messages?: readonly UIMessage[];
-  /** Start the panel open. Default: false. */
-  initialOpen?: boolean;
-  /** Floating toggle position. */
-  position?: "bottom-right" | "bottom-left" | "right";
-  /** Toggle keybinding, or false to disable. Default: "mod+shift+j". */
-  hotkey?: string | false;
-  /** Ring buffer size. Default: 500. */
-  bufferSize?: number;
-  /** Fires for every devtools event. */
-  onEvent?: (evt: DevtoolsEvent) => void;
-}
-```
-
-In production builds the component renders `null`.
-
-## useJsonRenderDevtools
-
-```tsx
-import { useJsonRenderDevtools } from "@json-render/devtools-react";
-
-const devtools = useJsonRenderDevtools();
-devtools?.open();
-devtools?.toggle();
-devtools?.close();
-devtools?.clear();
-devtools?.recordEvent({ kind: "stream-text", at: Date.now(), text: "hi" });
-```
-
-Access the running devtools instance from anywhere in the React tree. Returns `null` in production or before the component has mounted.

apps/web/content/docs/api/devtools-solid.mdx

@@ -1,37 +0,0 @@
----
-title: "@json-render/devtools-solid"
----
-
-SolidJS adapter for the json-render devtools. Drop-in `<JsonRenderDevtools />` component.
-
-See the [Devtools guide](/docs/devtools) for the drop-in walkthrough.
-
-## JsonRenderDevtools
-
-```tsx
-import { JsonRenderDevtools } from "@json-render/devtools-solid";
-
-<JSONUIProvider registry={registry}>
-  <Renderer spec={spec()} registry={registry} />
-  <JsonRenderDevtools
-    spec={spec()}
-    catalog={catalog}
-    messages={messages()}
-  />
-</JSONUIProvider>
-```
-
-### Props
-
-Same shape as the React adapter:
-
-- `spec`
-- `catalog`
-- `messages`
-- `initialOpen`
-- `position`
-- `hotkey`
-- `bufferSize`
-- `onEvent`
-
-In production builds the component renders `null`.

apps/web/content/docs/api/devtools-svelte.mdx

@@ -1,35 +0,0 @@
----
-title: "@json-render/devtools-svelte"
----
-
-Svelte adapter for the json-render devtools. Drop-in `<JsonRenderDevtools />` component.
-
-See the [Devtools guide](/docs/devtools) for the drop-in walkthrough.
-
-## JsonRenderDevtools
-
-```svelte
-<script>
-  import { JsonRenderDevtools } from "@json-render/devtools-svelte";
-</script>
-
-<JSONUIProvider {registry}>
-  <Renderer {spec} {registry} />
-  <JsonRenderDevtools {spec} {catalog} {messages} />
-</JSONUIProvider>
-```
-
-### Props
-
-Same shape as the React adapter:
-
-- `spec`
-- `catalog`
-- `messages`
-- `initialOpen`
-- `position`
-- `hotkey`
-- `bufferSize`
-- `onEvent`
-
-In production builds the component renders nothing.

apps/web/content/docs/api/devtools-vue.mdx

@@ -1,37 +0,0 @@
----
-title: "@json-render/devtools-vue"
----
-
-Vue adapter for the json-render devtools. Drop-in `<JsonRenderDevtools />` component.
-
-See the [Devtools guide](/docs/devtools) for the drop-in walkthrough.
-
-## JsonRenderDevtools
-
-```vue
-<script setup>
-import { JsonRenderDevtools } from "@json-render/devtools-vue";
-</script>
-
-<template>
-  <JSONUIProvider :registry="registry">
-    <Renderer :spec="spec" :registry="registry" />
-    <JsonRenderDevtools :spec="spec" :catalog="catalog" :messages="messages" />
-  </JSONUIProvider>
-</template>
-```
-
-### Props
-
-Same shape as the React adapter:
-
-- `spec`
-- `catalog`
-- `messages`
-- `initialOpen`
-- `position`
-- `hotkey`
-- `bufferSize`
-- `onEvent`
-
-In production builds the component renders nothing.

apps/web/content/docs/api/devtools.mdx

@@ -1,145 +0,0 @@
----
-title: "@json-render/devtools"
----
-
-Framework-agnostic core for the json-render devtools — vanilla TS panel UI, event store, DOM picker, and stream tap utilities. Every framework-specific adapter package depends on this.
-
-Most users never import from this package directly. Pick the adapter that matches your renderer (`@json-render/devtools-react`, `@json-render/devtools-vue`, etc.) and drop the `<JsonRenderDevtools />` component into your app.
-
-See the [Devtools guide](/docs/devtools) for the drop-in walkthrough.
-
-## Event Store
-
-### createEventStore
-
-```ts
-function createEventStore(options?: { bufferSize?: number }): EventStore
-
-interface EventStore {
-  push: (event: DevtoolsEvent) => void;
-  snapshot: () => DevtoolsEvent[];
-  subscribe: (listener: () => void) => () => void;
-  clear: () => void;
-  size: () => number;
-}
-```
-
-Ring-buffered pub/sub of `DevtoolsEvent`. Shared by every panel and every stream tap.
-
-## Panel
-
-### createPanel
-
-```ts
-function createPanel(options: PanelOptions): PanelHandle
-
-interface PanelHandle {
-  open: () => void;
-  close: () => void;
-  toggle: () => void;
-  isOpen: () => boolean;
-  refresh: () => void;
-  destroy: () => void;
-}
-```
-
-Mount the panel into a host document. Adapters call this internally.
-
-### Panel tabs
-
-Each tab is a factory function that returns a `TabDef`:
-
-```ts
-import {
-  specTab,
-  stateTab,
-  actionsTab,
-  streamTab,
-  catalogTab,
-  pickerTab,
-} from "@json-render/devtools";
-```
-
-## Stream Taps
-
-### tapJsonRenderStream
-
-```ts
-function tapJsonRenderStream(
-  stream: ReadableStream<StreamChunk>,
-  events: EventStore,
-): ReadableStream<StreamChunk>
-```
-
-Mirror the spec patches flowing through a `pipeJsonRender` transform into a devtools event store. Returns the original stream unchanged — the tap just forks a copy.
-
-### tapYamlStream
-
-```ts
-function tapYamlStream(
-  stream: ReadableStream<StreamChunk>,
-  events: EventStore,
-): ReadableStream<StreamChunk>
-```
-
-YAML equivalent of `tapJsonRenderStream`.
-
-### scanMessageParts
-
-```ts
-function scanMessageParts(
-  parts: readonly DataPart[] | undefined,
-  events: EventStore,
-  seen: WeakSet<object>,
-): void
-```
-
-Client-side helper: scan an AI SDK message's `parts` array for spec data parts and push matching events into the store. Idempotent via `seen` — call it on every render of a chat UI.
-
-## Picker
-
-### startPicker
-
-```ts
-function startPicker(options: PickerOptions): PickerSession | null
-
-interface PickerOptions {
-  onPick: (key: string) => void;
-  onCancel?: () => void;
-}
-```
-
-Start a DOM picker session. Hovering paints an outline on any element carrying `data-jr-key`; clicking fires `onPick` with the spec key. Returns `null` in environments without a DOM.
-
-### findElementByKey / highlightElement
-
-```ts
-function findElementByKey(key: string): Element | null
-function highlightElement(key: string, durationMs?: number): void
-```
-
-Look up the live DOM node for a spec element key, or briefly paint an outline around it.
-
-## Types
-
-### DevtoolsEvent
-
-```ts
-type DevtoolsEvent =
-  | { kind: "spec-changed"; at: number; spec: Spec }
-  | { kind: "state-set"; at: number; path: string; prev: unknown; next: unknown }
-  | { kind: "action-dispatched"; at: number; id: string; name: string; params?: unknown }
-  | { kind: "action-settled"; at: number; id: string; ok: boolean; result?: unknown; error?: string; durationMs: number }
-  | { kind: "stream-patch"; at: number; patch: JsonPatch; source: "json" | "yaml" }
-  | { kind: "stream-text"; at: number; text: string }
-  | { kind: "stream-usage"; at: number; usage: TokenUsage }
-  | { kind: "stream-lifecycle"; at: number; phase: "start" | "end"; ok?: boolean };
-```
-
-### isProduction
-
-```ts
-function isProduction(): boolean
-```
-
-`true` when `process.env.NODE_ENV === "production"`. Adapters use this to short-circuit to a null render.

apps/web/content/docs/api/directives.mdx

@@ -1,406 +0,0 @@
----
-title: "@json-render/directives"
----
-
-Pre-built custom directives for `@json-render/core`. Drop them into your catalog and renderer to add formatting, math, string manipulation, and i18n.
-
-## Install
-
-```bash
-npm install @json-render/directives
-```
-
-## Quick Start
-
-```typescript
-import { standardDirectives } from '@json-render/directives';
-
-// Wire into prompt generation
-const prompt = catalog.prompt({ directives: standardDirectives });
-
-// Wire into the renderer
-<JSONUIProvider spec={spec} directives={standardDirectives}>
-  ...
-</JSONUIProvider>
-```
-
-To add factory directives like `createI18nDirective`, spread the array:
-
-```typescript
-import { standardDirectives, createI18nDirective } from '@json-render/directives';
-
-const directives = [...standardDirectives, createI18nDirective(config)];
-```
-
-## Directives
-
-### `$format` — Locale-aware value formatting
-
-Formats values using `Intl` formatters. Supports `date`, `currency`, `number`, and `percent`.
-
-```json
-{ "$format": "currency", "value": { "$state": "/cart/total" }, "currency": "USD" }
-```
-
-```json
-{ "$format": "date", "value": { "$state": "/user/createdAt" } }
-```
-
-```json
-{ "$format": "number", "value": 1234567, "notation": "compact" }
-```
-
-```json
-{ "$format": "percent", "value": 0.75 }
-```
-
-Relative dates are also supported:
-
-```json
-{ "$format": "date", "value": { "$state": "/post/createdAt" }, "style": "relative" }
-```
-
-This returns strings like `"3h ago"`, `"2d from now"`, or `"just now"`.
-
-<table>
-  <thead>
-    <tr>
-      <th>Field</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>$format</code></td>
-      <td><code>{'\"date\" | \"currency\" | \"number\" | \"percent\"'}</code></td>
-      <td>Format type.</td>
-    </tr>
-    <tr>
-      <td><code>value</code></td>
-      <td><code>unknown</code></td>
-      <td>Value to format. Accepts any dynamic expression.</td>
-    </tr>
-    <tr>
-      <td><code>locale</code></td>
-      <td><code>string</code></td>
-      <td>Optional. Locale for formatting (e.g. <code>"en-US"</code>).</td>
-    </tr>
-    <tr>
-      <td><code>currency</code></td>
-      <td><code>string</code></td>
-      <td>Optional. Currency code for <code>"currency"</code> format. Default: <code>"USD"</code>.</td>
-    </tr>
-    <tr>
-      <td><code>notation</code></td>
-      <td><code>string</code></td>
-      <td>Optional. Notation for <code>"number"</code> format (e.g. <code>"compact"</code>).</td>
-    </tr>
-    <tr>
-      <td><code>style</code></td>
-      <td><code>string</code></td>
-      <td>Optional. Set to <code>"relative"</code> for relative date formatting.</td>
-    </tr>
-    <tr>
-      <td><code>options</code></td>
-      <td><code>{'Record<string, unknown>'}</code></td>
-      <td>Optional. Extra <code>Intl</code> formatter options.</td>
-    </tr>
-  </tbody>
-</table>
-
-### `$math` — Arithmetic operations
-
-Performs arithmetic on one or two operands. Operands accept any dynamic expression.
-
-```json
-{ "$math": "add", "a": { "$state": "/subtotal" }, "b": { "$state": "/tax" } }
-```
-
-```json
-{ "$math": "round", "a": 3.7 }
-```
-
-<table>
-  <thead>
-    <tr>
-      <th>Field</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>$math</code></td>
-      <td><code>{'\"add\" | \"subtract\" | \"multiply\" | \"divide\" | \"mod\" | \"min\" | \"max\" | \"round\" | \"floor\" | \"ceil\" | \"abs\"'}</code></td>
-      <td>Operation to perform.</td>
-    </tr>
-    <tr>
-      <td><code>a</code></td>
-      <td><code>unknown</code></td>
-      <td>First operand. Defaults to <code>0</code> if missing.</td>
-    </tr>
-    <tr>
-      <td><code>b</code></td>
-      <td><code>unknown</code></td>
-      <td>Second operand (binary ops only). Defaults to <code>0</code> if missing.</td>
-    </tr>
-  </tbody>
-</table>
-
-Unary operations (`round`, `floor`, `ceil`, `abs`) only use `a`. Division by zero returns `0`.
-
-### `$concat` — String concatenation
-
-Concatenates multiple values into a single string. Each element is resolved then joined.
-
-```json
-{ "$concat": [{ "$state": "/user/firstName" }, " ", { "$state": "/user/lastName" }] }
-```
-
-<table>
-  <thead>
-    <tr>
-      <th>Field</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>$concat</code></td>
-      <td><code>{'unknown[]'}</code></td>
-      <td>Array of values to concatenate. Each is resolved, converted to string, and joined.</td>
-    </tr>
-  </tbody>
-</table>
-
-### `$count` — Array/string length
-
-Returns the length of an array or string. Returns `0` for other types.
-
-```json
-{ "$count": { "$state": "/cart/items" } }
-```
-
-<table>
-  <thead>
-    <tr>
-      <th>Field</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>$count</code></td>
-      <td><code>unknown</code></td>
-      <td>Value to count. Accepts arrays and strings.</td>
-    </tr>
-  </tbody>
-</table>
-
-### `$truncate` — Text truncation
-
-Truncates text to a maximum length with a configurable suffix.
-
-```json
-{ "$truncate": { "$state": "/post/body" }, "length": 140, "suffix": "..." }
-```
-
-<table>
-  <thead>
-    <tr>
-      <th>Field</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>$truncate</code></td>
-      <td><code>unknown</code></td>
-      <td>Value to truncate.</td>
-    </tr>
-    <tr>
-      <td><code>length</code></td>
-      <td><code>number</code></td>
-      <td>Optional. Max character length. Default: <code>100</code>.</td>
-    </tr>
-    <tr>
-      <td><code>suffix</code></td>
-      <td><code>string</code></td>
-      <td>Optional. Suffix to append when truncated. Default: <code>"..."</code>.</td>
-    </tr>
-  </tbody>
-</table>
-
-### `$pluralize` — Singular/plural forms
-
-Selects a singular, plural, or zero form based on a count.
-
-```json
-{ "$pluralize": { "$state": "/cart/itemCount" }, "one": "item", "other": "items", "zero": "no items" }
-```
-
-Output: `"3 items"`, `"1 item"`, or `"no items"`.
-
-<table>
-  <thead>
-    <tr>
-      <th>Field</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>$pluralize</code></td>
-      <td><code>unknown</code></td>
-      <td>Count value. Accepts dynamic expressions.</td>
-    </tr>
-    <tr>
-      <td><code>one</code></td>
-      <td><code>string</code></td>
-      <td>Singular form label.</td>
-    </tr>
-    <tr>
-      <td><code>other</code></td>
-      <td><code>string</code></td>
-      <td>Plural form label.</td>
-    </tr>
-    <tr>
-      <td><code>zero</code></td>
-      <td><code>string</code></td>
-      <td>Optional. Label for count of zero. If omitted, uses <code>"0 {'<other>'}"</code>.</td>
-    </tr>
-  </tbody>
-</table>
-
-### `$join` — Join array elements
-
-Joins array elements with a separator string.
-
-```json
-{ "$join": { "$state": "/tags" }, "separator": ", " }
-```
-
-<table>
-  <thead>
-    <tr>
-      <th>Field</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>$join</code></td>
-      <td><code>unknown</code></td>
-      <td>Array to join. Non-array values are converted to string.</td>
-    </tr>
-    <tr>
-      <td><code>separator</code></td>
-      <td><code>string</code></td>
-      <td>Optional. Separator between elements. Default: <code>", "</code>.</td>
-    </tr>
-  </tbody>
-</table>
-
-### `createI18nDirective` — Internationalization
-
-Factory function that creates a `$t` directive for translations with `{'{{param}}'}` interpolation.
-
-```typescript
-import { createI18nDirective } from '@json-render/directives';
-
-const tDirective = createI18nDirective({
-  locale: 'en',
-  messages: {
-    en: { "greeting": "Hello, {'{{name}}'}!", "checkout.submit": "Place Order" },
-    es: { "greeting": "Hola, {'{{name}}'}!", "checkout.submit": "Realizar Pedido" },
-  },
-  fallbackLocale: 'en',
-});
-```
-
-Usage in specs:
-
-```json
-{ "$t": "checkout.submit" }
-```
-
-```json
-{ "$t": "greeting", "params": { "name": { "$state": "/user/name" } } }
-```
-
-<table>
-  <thead>
-    <tr>
-      <th>Field</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>$t</code></td>
-      <td><code>string</code></td>
-      <td>Translation key.</td>
-    </tr>
-    <tr>
-      <td><code>params</code></td>
-      <td><code>{'Record<string, unknown>'}</code></td>
-      <td>Optional. Interpolation parameters. Values accept dynamic expressions.</td>
-    </tr>
-  </tbody>
-</table>
-
-#### `I18nConfig`
-
-<table>
-  <thead>
-    <tr>
-      <th>Field</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>locale</code></td>
-      <td><code>string</code></td>
-      <td>Current locale (e.g. <code>"en"</code>).</td>
-    </tr>
-    <tr>
-      <td><code>messages</code></td>
-      <td><code>{'Record<string, Record<string, string>>'}</code></td>
-      <td>Map of locale to key-value translation pairs.</td>
-    </tr>
-    <tr>
-      <td><code>fallbackLocale</code></td>
-      <td><code>string</code></td>
-      <td>Optional. Fallback locale when a key is missing in the current locale.</td>
-    </tr>
-  </tbody>
-</table>
-
-## Composition
-
-Directives compose naturally. Each resolver calls `resolvePropValue` on its inputs, so you can nest directives:
-
-```json
-{
-  "$format": "currency",
-  "value": { "$math": "multiply", "a": { "$state": "/price" }, "b": { "$state": "/qty" } },
-  "currency": "USD"
-}
-```
-
-```json
-{
-  "$pluralize": { "$count": { "$state": "/items" } },
-  "one": "item",
-  "other": "items"
-}
-```

apps/web/content/docs/api/image.mdx

@@ -1,363 +0,0 @@
----
-title: "@json-render/image"
----
-
-Image renderer. Turn JSON specs into SVG and PNG images using [Satori](https://github.com/vercel/satori).
-
-## Install
-
-```bash
-npm install @json-render/core @json-render/image
-```
-
-For PNG output, also install the optional peer dependency:
-
-```bash
-npm install @resvg/resvg-js
-```
-
-See the [Image example](https://github.com/vercel-labs/json-render/tree/main/examples/image) for a full working example.
-
-## schema
-
-The image element schema for image specs. Use with `defineCatalog` from core.
-
-```typescript
-import { defineCatalog } from '@json-render/core';
-import { schema, standardComponentDefinitions } from '@json-render/image';
-
-const catalog = defineCatalog(schema, {
-  components: standardComponentDefinitions,
-});
-```
-
-## Render Functions
-
-Server-side functions for producing image output. Both accept a spec and optional `RenderOptions`.
-
-```typescript
-import { renderToSvg, renderToPng } from '@json-render/image/render';
-
-const svg = await renderToSvg(spec, { fonts });
-
-const png = await renderToPng(spec, { fonts });
-await writeFile('output.png', png);
-```
-
-### RenderOptions
-
-```typescript
-interface RenderOptions {
-  registry?: ComponentRegistry;
-  includeStandard?: boolean;  // default: true
-  state?: Record<string, unknown>;
-  fonts?: SatoriOptions['fonts'];
-  width?: number;
-  height?: number;
-}
-```
-
-<table>
-  <thead>
-    <tr>
-      <th>Option</th>
-      <th>Type</th>
-      <th>Default</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>fonts</code></td>
-      <td><code>{"SatoriOptions['fonts']"}</code></td>
-      <td><code>[]</code></td>
-      <td>Font data for text rendering (required for meaningful output)</td>
-    </tr>
-    <tr>
-      <td><code>width</code></td>
-      <td><code>number</code></td>
-      <td>Frame prop</td>
-      <td>Override the output image width</td>
-    </tr>
-    <tr>
-      <td><code>height</code></td>
-      <td><code>number</code></td>
-      <td>Frame prop</td>
-      <td>Override the output image height</td>
-    </tr>
-    <tr>
-      <td><code>registry</code></td>
-      <td><code>{"Record<string, ComponentRenderer>"}</code></td>
-      <td><code>{"{}"}</code></td>
-      <td>Custom component map (merged with standard components)</td>
-    </tr>
-    <tr>
-      <td><code>includeStandard</code></td>
-      <td><code>boolean</code></td>
-      <td><code>true</code></td>
-      <td>Include built-in standard components</td>
-    </tr>
-    <tr>
-      <td><code>state</code></td>
-      <td><code>{"Record<string, unknown>"}</code></td>
-      <td><code>{"{}"}</code></td>
-      <td>Initial state for <code>$state</code> / <code>$cond</code> dynamic prop resolution</td>
-    </tr>
-  </tbody>
-</table>
-
-## Standard Components
-
-### Root
-
-#### Frame
-
-Root image container. Defines the output image dimensions and background. Must be the root element.
-
-```typescript
-{
-  width: number;
-  height: number;
-  backgroundColor: string | null;
-  padding: number | null;
-  display: "flex" | "none" | null;
-  flexDirection: "row" | "column" | null;
-  alignItems: "flex-start" | "center" | "flex-end" | "stretch" | null;
-  justifyContent: "flex-start" | "center" | "flex-end" | "space-between" | "space-around" | null;
-}
-```
-
-### Layout
-
-#### Box
-
-Generic container with padding, margin, background, border, and flex alignment. Supports absolute positioning.
-
-```typescript
-{
-  padding: number | null;
-  paddingTop: number | null;
-  paddingBottom: number | null;
-  paddingLeft: number | null;
-  paddingRight: number | null;
-  margin: number | null;
-  backgroundColor: string | null;
-  borderWidth: number | null;
-  borderColor: string | null;
-  borderRadius: number | null;
-  flex: number | null;
-  width: number | string | null;
-  height: number | string | null;
-  alignItems: "flex-start" | "center" | "flex-end" | "stretch" | null;
-  justifyContent: "flex-start" | "center" | "flex-end" | "space-between" | "space-around" | null;
-  flexDirection: "row" | "column" | null;
-  position: "relative" | "absolute" | null;
-  top: number | null;
-  left: number | null;
-  right: number | null;
-  bottom: number | null;
-  overflow: "visible" | "hidden" | null;
-}
-```
-
-#### Row
-
-Horizontal flex layout with optional wrapping.
-
-```typescript
-{
-  gap: number | null;
-  alignItems: "flex-start" | "center" | "flex-end" | "stretch" | null;
-  justifyContent: "flex-start" | "center" | "flex-end" | "space-between" | "space-around" | null;
-  padding: number | null;
-  flex: number | null;
-  wrap: boolean | null;
-}
-```
-
-#### Column
-
-Vertical flex layout.
-
-```typescript
-{
-  gap: number | null;
-  alignItems: "flex-start" | "center" | "flex-end" | "stretch" | null;
-  justifyContent: "flex-start" | "center" | "flex-end" | "space-between" | "space-around" | null;
-  padding: number | null;
-  flex: number | null;
-}
-```
-
-### Content
-
-#### Heading
-
-Heading text at various levels. h1 is largest, h4 is smallest.
-
-```typescript
-{
-  text: string;
-  level: "h1" | "h2" | "h3" | "h4" | null;
-  color: string | null;
-  align: "left" | "center" | "right" | null;
-  letterSpacing: number | string | null;
-  lineHeight: number | null;
-}
-```
-
-#### Text
-
-Body text with configurable size, color, weight, and alignment.
-
-```typescript
-{
-  text: string;
-  fontSize: number | null;
-  color: string | null;
-  align: "left" | "center" | "right" | null;
-  fontWeight: "normal" | "bold" | null;
-  fontStyle: "normal" | "italic" | null;
-  lineHeight: number | null;
-  letterSpacing: number | string | null;
-  textDecoration: "none" | "underline" | "line-through" | null;
-}
-```
-
-#### Image
-
-Image from a URL with optional dimensions and fit.
-
-```typescript
-{
-  src: string;
-  width: number | null;
-  height: number | null;
-  borderRadius: number | null;
-  objectFit: "contain" | "cover" | "fill" | "none" | null;
-}
-```
-
-### Decorative
-
-#### Divider
-
-Horizontal line separator.
-
-```typescript
-{
-  color: string | null;
-  thickness: number | null;
-  marginTop: number | null;
-  marginBottom: number | null;
-}
-```
-
-#### Spacer
-
-Empty vertical space.
-
-```typescript
-{
-  height: number | null;
-}
-```
-
-## Catalog Definitions
-
-Pre-built definitions for creating image catalogs:
-
-```typescript
-import { standardComponentDefinitions } from '@json-render/image/catalog';
-import { defineCatalog } from '@json-render/core';
-import { schema } from '@json-render/image';
-
-const catalog = defineCatalog(schema, {
-  components: {
-    ...standardComponentDefinitions,
-    // Add custom components
-  },
-});
-```
-
-## Server-Safe Import
-
-Import schema and catalog definitions without pulling in React or Satori:
-
-```typescript
-import { schema, standardComponentDefinitions } from '@json-render/image/server';
-```
-
-## Sub-path Exports
-
-<table>
-  <thead>
-    <tr>
-      <th>Export</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>@json-render/image</code></td>
-      <td>Full package: schema, renderer, components, render functions</td>
-    </tr>
-    <tr>
-      <td><code>@json-render/image/server</code></td>
-      <td>Schema and catalog definitions only (no React or Satori)</td>
-    </tr>
-    <tr>
-      <td><code>@json-render/image/catalog</code></td>
-      <td>Standard component definitions and types</td>
-    </tr>
-    <tr>
-      <td><code>@json-render/image/render</code></td>
-      <td>Server-side render functions only</td>
-    </tr>
-  </tbody>
-</table>
-
-## Types
-
-<table>
-  <thead>
-    <tr>
-      <th>Export</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>ImageSchema</code></td>
-      <td>Schema type for image specs</td>
-    </tr>
-    <tr>
-      <td><code>ImageSpec</code></td>
-      <td>Spec type for image output</td>
-    </tr>
-    <tr>
-      <td><code>RenderOptions</code></td>
-      <td>Options for render functions</td>
-    </tr>
-    <tr>
-      <td><code>ComponentRenderProps</code></td>
-      <td>Props passed to component render functions</td>
-    </tr>
-    <tr>
-      <td><code>ComponentRenderer</code></td>
-      <td>Component render function type</td>
-    </tr>
-    <tr>
-      <td><code>ComponentRegistry</code></td>
-      <td>Map of component names to render functions</td>
-    </tr>
-    <tr>
-      <td><code>StandardComponentDefinitions</code></td>
-      <td>Type of the standard component definitions object</td>
-    </tr>
-    <tr>
-      <td><code>StandardComponentProps{'<K>'}</code></td>
-      <td>Inferred props type for a standard component by name</td>
-    </tr>
-  </tbody>
-</table>

apps/web/content/docs/api/ink.mdx

@@ -1,292 +0,0 @@
----
-title: "@json-render/ink"
----
-
-Terminal renderer for [Ink](https://github.com/vadimdemedes/ink) with multiple standard components, providers, hooks, and streaming support.
-
-## Installation
-
-<PackageInstall packages="@json-render/core @json-render/ink" />
-
-Peer dependencies: `react ^18.0.0 || ^19.0.0`, `ink ^6.0.0`, and `zod ^4.0.0`.
-
-<PackageInstall packages="react ink zod" />
-
-## Standard Components
-
-### Layout
-
-<table>
-<thead>
-<tr><th>Component</th><th>Props</th><th>Description</th></tr>
-</thead>
-<tbody>
-<tr><td><code>Box</code></td><td><code>flexDirection</code>, <code>alignItems</code>, <code>justifyContent</code>, <code>gap</code>, <code>padding</code>, <code>margin</code>, <code>borderStyle</code>, <code>borderColor</code>, <code>width</code>, <code>height</code>, <code>display</code>, <code>overflow</code></td><td>Flexbox layout container (like a terminal div)</td></tr>
-<tr><td><code>Spacer</code></td><td>(none)</td><td>Flexible empty space that expands to fill available room</td></tr>
-<tr><td><code>Newline</code></td><td><code>count</code></td><td>Insert blank lines</td></tr>
-</tbody>
-</table>
-
-### Content
-
-<table>
-<thead>
-<tr><th>Component</th><th>Props</th><th>Description</th></tr>
-</thead>
-<tbody>
-<tr><td><code>Text</code></td><td><code>text</code>, <code>color</code>, <code>bold</code>, <code>italic</code>, <code>underline</code>, <code>strikethrough</code>, <code>dimColor</code>, <code>inverse</code>, <code>wrap</code></td><td>Text output with styling</td></tr>
-<tr><td><code>Heading</code></td><td><code>text</code>, <code>level</code> (h1-h4), <code>color</code></td><td>Section heading</td></tr>
-<tr><td><code>Divider</code></td><td><code>character</code>, <code>color</code>, <code>dimColor</code>, <code>title</code>, <code>width</code></td><td>Horizontal separator line with optional title</td></tr>
-<tr><td><code>Badge</code></td><td><code>label</code>, <code>variant</code></td><td>Colored inline label (default, info, success, warning, error)</td></tr>
-<tr><td><code>Spinner</code></td><td><code>label</code>, <code>color</code></td><td>Animated loading spinner</td></tr>
-<tr><td><code>ProgressBar</code></td><td><code>progress</code> (0-1), <code>width</code>, <code>color</code>, <code>label</code></td><td>Horizontal progress bar</td></tr>
-<tr><td><code>StatusLine</code></td><td><code>text</code>, <code>status</code>, <code>icon</code></td><td>Status message with colored icon</td></tr>
-<tr><td><code>KeyValue</code></td><td><code>label</code>, <code>value</code>, <code>labelColor</code>, <code>separator</code></td><td>Key-value pair display</td></tr>
-<tr><td><code>Link</code></td><td><code>url</code>, <code>label</code>, <code>color</code></td><td>Renders a URL as underlined text. Shows "label (url)" when label is provided.</td></tr>
-<tr><td><code>Markdown</code></td><td><code>text</code></td><td>Renders markdown with terminal styling (headings, bold, italic, code, lists, blockquotes, horizontal rules)</td></tr>
-</tbody>
-</table>
-
-### Data
-
-<table>
-<thead>
-<tr><th>Component</th><th>Props</th><th>Description</th></tr>
-</thead>
-<tbody>
-<tr><td><code>Table</code></td><td><code>columns</code>, <code>rows</code>, <code>borderStyle</code>, <code>headerColor</code></td><td>Tabular data with headers</td></tr>
-<tr><td><code>List</code></td><td><code>items</code>, <code>ordered</code>, <code>bulletChar</code>, <code>spacing</code></td><td>Bulleted or numbered list</td></tr>
-<tr><td><code>ListItem</code></td><td><code>title</code>, <code>subtitle</code>, <code>leading</code>, <code>trailing</code></td><td>Structured list row</td></tr>
-<tr><td><code>Card</code></td><td><code>title</code>, <code>borderStyle</code>, <code>borderColor</code>, <code>padding</code></td><td>Bordered container with optional title</td></tr>
-<tr><td><code>Sparkline</code></td><td><code>data</code>, <code>width</code>, <code>color</code>, <code>label</code>, <code>min</code>, <code>max</code></td><td>Inline sparkline chart using Unicode blocks (▁▂▃▄▅▆▇█)</td></tr>
-<tr><td><code>BarChart</code></td><td><code>data</code> (label/value/color), <code>width</code>, <code>showValues</code>, <code>showPercentage</code></td><td>Horizontal bar chart for comparing values</td></tr>
-</tbody>
-</table>
-
-### Interactive
-
-<table>
-<thead>
-<tr><th>Component</th><th>Props</th><th>Description</th></tr>
-</thead>
-<tbody>
-<tr><td><code>TextInput</code></td><td><code>placeholder</code>, <code>value</code> (use <code>$bindState</code>), <code>label</code>, <code>mask</code></td><td>Text input field. Press Enter to submit.</td></tr>
-<tr><td><code>Select</code></td><td><code>options</code>, <code>value</code> (use <code>$bindState</code>), <code>label</code></td><td>Arrow-key selection menu</td></tr>
-<tr><td><code>MultiSelect</code></td><td><code>options</code>, <code>value</code> (use <code>$bindState</code>), <code>label</code>, <code>min</code>, <code>max</code></td><td>Multi-selection menu. Space to toggle, Enter to confirm.</td></tr>
-<tr><td><code>ConfirmInput</code></td><td><code>message</code>, <code>defaultValue</code>, <code>yesLabel</code>, <code>noLabel</code></td><td>Yes/No confirmation prompt. Press Y or N.</td></tr>
-<tr><td><code>Tabs</code></td><td><code>tabs</code>, <code>value</code> (use <code>$bindState</code>), <code>color</code></td><td>Tab bar navigation with left/right arrow keys. Place child content inside with visible conditions.</td></tr>
-</tbody>
-</table>
-
-## Providers
-
-### JSONUIProvider
-
-Convenience wrapper around all providers: `StateProvider` → `VisibilityProvider` → `ValidationProvider` → `ActionProvider` → `FocusProvider`.
-
-```tsx
-import { JSONUIProvider, Renderer } from "@json-render/ink";
-
-<JSONUIProvider initialState={{}} handlers={handlers}>
-  <Renderer spec={spec} registry={registry} />
-</JSONUIProvider>
-```
-
-### StateProvider
-
-```tsx
-<StateProvider initialState={object} onStateChange={fn}>
-  {children}
-</StateProvider>
-```
-
-<table>
-<thead>
-<tr><th>Prop</th><th>Type</th><th>Description</th></tr>
-</thead>
-<tbody>
-<tr><td><code>store</code></td><td><code>StateStore</code></td><td>External store (controlled mode). When provided, <code>initialState</code> and <code>onStateChange</code> are ignored.</td></tr>
-<tr><td><code>initialState</code></td><td><code>Record&lt;string, unknown&gt;</code></td><td>Initial state model (uncontrolled mode).</td></tr>
-<tr><td><code>onStateChange</code></td><td><code>{'(changes: Array<{ path: string; value: unknown }>) => void'}</code></td><td>Callback when state changes (uncontrolled mode).</td></tr>
-</tbody>
-</table>
-
-#### External Store (Controlled Mode)
-
-Pass a `StateStore` to bypass internal state and wire json-render to any state management:
-
-```tsx
-import { createStateStore } from "@json-render/ink";
-
-const store = createStateStore({ count: 0 });
-
-<StateProvider store={store}>
-  {children}
-</StateProvider>
-
-// Mutate from anywhere — components re-render automatically:
-store.set("/count", 1);
-```
-
-The `store` prop is also available on `JSONUIProvider` and `createRenderer`.
-
-### ActionProvider
-
-```tsx
-<ActionProvider handlers={Record<string, ActionHandler>} navigate={fn}>
-  {children}
-</ActionProvider>
-```
-
-Built-in actions: `setState`, `pushState`, `removeState`, `log`, `exit`. Custom handlers override built-ins. Includes a terminal confirmation dialog (press Y/N) for actions with `confirm`.
-
-### VisibilityProvider
-
-```tsx
-<VisibilityProvider>
-  {children}
-</VisibilityProvider>
-```
-
-### ValidationProvider
-
-```tsx
-<ValidationProvider>
-  {children}
-</ValidationProvider>
-```
-
-### FocusProvider
-
-```tsx
-<FocusProvider>
-  {children}
-</FocusProvider>
-```
-
-Manages Tab-cycling focus between interactive components (TextInput, Select). Supports `useFocusDisable` to suppress cycling during modal dialogs.
-
-## defineRegistry
-
-Create a type-safe component registry. Standard components are built-in; only register custom components.
-
-```tsx
-import { defineRegistry, type Components } from "@json-render/ink";
-
-const { registry, handlers, executeAction } = defineRegistry(catalog, {
-  components: {
-    MyWidget: ({ props }) => <Text>{props.label}</Text>,
-  } as Components<typeof catalog>,
-  actions: {
-    submit: async (params, setState, state) => {
-      // custom action logic
-    },
-  },
-});
-```
-
-`handlers` is designed for `JSONUIProvider`/`ActionProvider`. `executeAction` is an imperative helper.
-
-## createRenderer
-
-Higher-level helper that wraps `Renderer` + all providers into a single component.
-
-```tsx
-import { createRenderer } from "@json-render/ink";
-
-const UIRenderer = createRenderer(catalog, components);
-
-<UIRenderer spec={spec} state={initialState} />;
-```
-
-## Hooks
-
-### useUIStream
-
-```typescript
-const {
-  spec,         // Spec | null - current UI state
-  isStreaming,  // boolean - true while streaming
-  error,        // Error | null
-  send,         // (prompt: string, context?: Record<string, unknown>) => Promise<void>
-  stop,         // () => void - abort the current stream
-  clear,        // () => void - reset spec and error
-} = useUIStream({
-  api: string,
-  onComplete?: (spec: Spec) => void,
-  onError?: (error: Error) => void,
-  fetch?: (url: string, init?: RequestInit) => Promise<Response>,
-  validate?: boolean,
-  maxRetries?: number,
-});
-```
-
-### useStateStore
-
-```typescript
-const { state, get, set, update } = useStateStore();
-```
-
-### useStateValue
-
-```typescript
-const value = useStateValue(path: string);
-```
-
-### useBoundProp
-
-```typescript
-const [value, setValue] = useBoundProp(resolvedValue, bindingPath);
-```
-
-### useActions
-
-```typescript
-const { execute } = useActions();
-```
-
-### useIsVisible
-
-```typescript
-const isVisible = useIsVisible(condition?: VisibilityCondition);
-```
-
-### useFocus
-
-```typescript
-const { isActive, id } = useFocus();
-```
-
-### useFocusDisable
-
-```typescript
-useFocusDisable(disabled: boolean);
-```
-
-Suppresses Tab-cycling while `disabled` is true (e.g., during a modal dialog).
-
-## Catalog Exports
-
-```typescript
-import { standardComponentDefinitions, standardActionDefinitions } from "@json-render/ink/catalog";
-import { schema } from "@json-render/ink/schema";
-```
-
-<table>
-<thead>
-<tr><th>Export</th><th>Purpose</th></tr>
-</thead>
-<tbody>
-<tr><td><code>standardComponentDefinitions</code></td><td>Catalog definitions for all 19 standard components</td></tr>
-<tr><td><code>standardActionDefinitions</code></td><td>Catalog definitions for standard actions (setState, pushState, removeState, log, exit)</td></tr>
-<tr><td><code>schema</code></td><td>Ink element tree schema</td></tr>
-</tbody>
-</table>
-
-## Server Export
-
-```typescript
-import { schema, standardComponentDefinitions, standardActionDefinitions } from "@json-render/ink/server";
-```
-
-Re-exports the schema and catalog definitions for server-side usage (e.g., building system prompts).

apps/web/content/docs/api/jotai.mdx

@@ -1,103 +0,0 @@
----
-title: "@json-render/jotai"
----
-
-Jotai adapter for json-render's `StateStore` interface.
-
-## Installation
-
-```bash
-npm install @json-render/jotai @json-render/core @json-render/react jotai
-```
-
-## jotaiStateStore
-
-Create a `StateStore` backed by a Jotai atom.
-
-```typescript
-import { jotaiStateStore } from "@json-render/jotai";
-```
-
-### Options
-
-<table>
-  <thead>
-    <tr>
-      <th>Option</th>
-      <th>Type</th>
-      <th>Required</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>atom</code></td>
-      <td><code>{'WritableAtom<StateModel, [StateModel], void>'}</code></td>
-      <td>Yes</td>
-      <td>A writable atom holding the state model.</td>
-    </tr>
-    <tr>
-      <td><code>store</code></td>
-      <td>Jotai <code>Store</code></td>
-      <td>No</td>
-      <td>The Jotai store instance. Defaults to a new store created internally. Pass your own to share state with <code>{'<Provider>'}</code>.</td>
-    </tr>
-  </tbody>
-</table>
-
-### Example
-
-```typescript
-import { atom } from "jotai";
-import { jotaiStateStore } from "@json-render/jotai";
-import { StateProvider } from "@json-render/react";
-
-const uiAtom = atom<Record<string, unknown>>({ count: 0 });
-const store = jotaiStateStore({ atom: uiAtom });
-```
-
-```tsx
-<StateProvider store={store}>
-  {/* json-render reads/writes go through Jotai */}
-</StateProvider>
-```
-
-### Shared Jotai Store
-
-If your app already uses a Jotai `<Provider>` with a custom store, pass it so both json-render and your components share the same state:
-
-```typescript
-import { atom, createStore } from "jotai";
-import { Provider as JotaiProvider } from "jotai/react";
-import { jotaiStateStore } from "@json-render/jotai";
-import { StateProvider } from "@json-render/react";
-
-const jStore = createStore();
-const uiAtom = atom<Record<string, unknown>>({ count: 0 });
-const store = jotaiStateStore({ atom: uiAtom, store: jStore });
-```
-
-```tsx
-<JotaiProvider store={jStore}>
-  <StateProvider store={store}>
-    {/* Both json-render and useAtom() see the same state */}
-  </StateProvider>
-</JotaiProvider>
-```
-
-## Re-exports
-
-<table>
-  <thead>
-    <tr>
-      <th>Export</th>
-      <th>Source</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>StateStore</code></td>
-      <td><code>@json-render/core</code></td>
-    </tr>
-  </tbody>
-</table>

apps/web/content/docs/api/mcp.mdx

@@ -1,246 +0,0 @@
----
-title: "@json-render/mcp"
----
-
-MCP Apps integration for json-render. Serve json-render UIs as interactive [MCP Apps](https://modelcontextprotocol.io/docs/extensions/apps) inside Claude, ChatGPT, Cursor, VS Code, and other MCP-capable clients.
-
-## Install
-
-```bash
-npm install @json-render/mcp @json-render/core @modelcontextprotocol/sdk
-```
-
-For the iframe-side React UI, also install:
-
-```bash
-npm install @json-render/react react react-dom
-```
-
-See the [MCP example](https://github.com/vercel-labs/json-render/tree/main/examples/mcp) for a full working example.
-
-## Overview
-
-MCP Apps let MCP servers return interactive HTML UIs that render directly inside chat conversations. `@json-render/mcp` bridges json-render catalogs with the MCP Apps protocol:
-
-1. Your **catalog** defines which components and actions the AI can use
-2. The **MCP server** exposes the catalog as a tool with the spec schema
-3. The **bundled HTML** renders json-render specs inside the host's sandboxed iframe
-4. The AI generates a spec, the host renders it, and users interact with the live UI
-
-## Server API
-
-### createMcpApp
-
-Create a fully-configured MCP server. This is the main entry point.
-
-```typescript
-import { createMcpApp } from "@json-render/mcp";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import fs from "node:fs";
-
-const server = createMcpApp({
-  name: "My Dashboard",
-  version: "1.0.0",
-  catalog: myCatalog,
-  html: fs.readFileSync("dist/index.html", "utf-8"),
-});
-
-await server.connect(new StdioServerTransport());
-```
-
-#### CreateMcpAppOptions
-
-<table>
-  <thead>
-    <tr>
-      <th>Option</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>name</code></td>
-      <td><code>string</code></td>
-      <td>Server name shown in client UIs</td>
-    </tr>
-    <tr>
-      <td><code>version</code></td>
-      <td><code>string</code></td>
-      <td>Server version</td>
-    </tr>
-    <tr>
-      <td><code>catalog</code></td>
-      <td><code>Catalog</code></td>
-      <td>json-render catalog defining available components</td>
-    </tr>
-    <tr>
-      <td><code>html</code></td>
-      <td><code>string</code></td>
-      <td>Self-contained HTML for the iframe UI</td>
-    </tr>
-    <tr>
-      <td><code>tool</code></td>
-      <td><code>McpToolOptions</code></td>
-      <td>Optional tool name/title/description overrides</td>
-    </tr>
-  </tbody>
-</table>
-
-### registerJsonRenderTool
-
-Register a json-render tool on an existing `McpServer`. Use this when you need to add json-render to a server that has other tools.
-
-```typescript
-import { registerJsonRenderTool } from "@json-render/mcp";
-
-registerJsonRenderTool(server, {
-  catalog,
-  name: "render-ui",
-  title: "Render UI",
-  description: "Render an interactive UI",
-  resourceUri: "ui://render-ui/view.html",
-});
-```
-
-### registerJsonRenderResource
-
-Register the UI resource that serves the bundled HTML.
-
-```typescript
-import { registerJsonRenderResource } from "@json-render/mcp";
-
-registerJsonRenderResource(server, {
-  resourceUri: "ui://render-ui/view.html",
-  html: bundledHtml,
-});
-```
-
-## Client API (`@json-render/mcp/app`)
-
-These exports run inside the sandboxed iframe rendered by the MCP host.
-
-### useJsonRenderApp
-
-React hook that connects to the MCP host, listens for tool results, and maintains the current json-render spec.
-
-```tsx
-import { useJsonRenderApp } from "@json-render/mcp/app";
-import { JSONUIProvider, Renderer } from "@json-render/react";
-
-function McpAppView({ registry }) {
-  const { spec, loading, connected, error } = useJsonRenderApp({
-    name: "my-app",
-    version: "1.0.0",
-  });
-
-  if (error) return <div>Error: {error.message}</div>;
-  if (!spec) return <div>Waiting...</div>;
-
-  return (
-    <JSONUIProvider registry={registry} initialState={spec.state ?? {}}>
-      <Renderer spec={spec} registry={registry} loading={loading} />
-    </JSONUIProvider>
-  );
-}
-```
-
-#### UseJsonRenderAppReturn
-
-<table>
-  <thead>
-    <tr>
-      <th>Field</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>spec</code></td>
-      <td><code>{'Spec | null'}</code></td>
-      <td>Current json-render spec</td>
-    </tr>
-    <tr>
-      <td><code>loading</code></td>
-      <td><code>boolean</code></td>
-      <td>Whether the spec is still being received</td>
-    </tr>
-    <tr>
-      <td><code>connected</code></td>
-      <td><code>boolean</code></td>
-      <td>Whether connected to the host</td>
-    </tr>
-    <tr>
-      <td><code>connecting</code></td>
-      <td><code>boolean</code></td>
-      <td>Whether currently connecting</td>
-    </tr>
-    <tr>
-      <td><code>error</code></td>
-      <td><code>{'Error | null'}</code></td>
-      <td>Connection error, if any</td>
-    </tr>
-    <tr>
-      <td><code>app</code></td>
-      <td><code>{'App | null'}</code></td>
-      <td>The underlying MCP App instance</td>
-    </tr>
-    <tr>
-      <td><code>callServerTool</code></td>
-      <td><code>{'(name, args?) => Promise<void>'}</code></td>
-      <td>Call an MCP server tool and update spec from result</td>
-    </tr>
-  </tbody>
-</table>
-
-### buildAppHtml
-
-Generate a self-contained HTML page from bundled JavaScript and CSS.
-
-```typescript
-import { buildAppHtml } from "@json-render/mcp/app";
-import fs from "node:fs";
-
-const html = buildAppHtml({
-  title: "Dashboard",
-  js: fs.readFileSync("dist/app.js", "utf-8"),
-  css: fs.readFileSync("dist/app.css", "utf-8"),
-});
-```
-
-## Client Configuration
-
-### Cursor
-
-Add to `.cursor/mcp.json`:
-
-```json
-{
-  "mcpServers": {
-    "json-render": {
-      "command": "npx",
-      "args": ["tsx", "path/to/server.ts", "--stdio"]
-    }
-  }
-}
-```
-
-### Claude Desktop
-
-Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
-
-```json
-{
-  "mcpServers": {
-    "json-render": {
-      "command": "npx",
-      "args": ["tsx", "/absolute/path/to/server.ts", "--stdio"]
-    }
-  }
-}
-```
-
-## Supported Clients
-
-MCP Apps are supported by Claude (web and desktop), ChatGPT, VS Code (GitHub Copilot), Cursor, Goose, and Postman.

apps/web/content/docs/api/meta.json

@@ -1,34 +0,0 @@
-{
-  "title": "API Reference",
-  "pages": [
-    "core",
-    "react",
-    "next",
-    "tanstack-start",
-    "react-pdf",
-    "react-email",
-    "shadcn",
-    "shadcn-svelte",
-    "react-native",
-    "image",
-    "remotion",
-    "ink",
-    "vue",
-    "svelte",
-    "solid",
-    "react-three-fiber",
-    "directives",
-    "codegen",
-    "devtools",
-    "devtools-react",
-    "devtools-vue",
-    "devtools-svelte",
-    "devtools-solid",
-    "mcp",
-    "redux",
-    "zustand",
-    "jotai",
-    "xstate",
-    "yaml"
-  ]
-}

apps/web/content/docs/api/next.mdx

@@ -1,279 +0,0 @@
----
-title: "@json-render/next"
----
-
-Next.js renderer. JSON becomes full Next.js applications with routes, layouts, metadata, and SSR.
-
-## Installation
-
-```bash
-npm install @json-render/core @json-render/react @json-render/next
-```
-
-## schema
-
-The Next.js app schema for multi-page specs. Use with `defineCatalog` from core.
-
-```typescript
-import { defineCatalog } from '@json-render/core';
-import { schema } from '@json-render/next/server';
-import { z } from 'zod';
-
-const catalog = defineCatalog(schema, {
-  components: {
-    Card: {
-      props: z.object({ title: z.string() }),
-      description: 'Card container',
-    },
-    NavBar: {
-      props: z.object({ links: z.array(z.object({ href: z.string(), label: z.string() })) }),
-      description: 'Navigation bar',
-    },
-  },
-  actions: {},
-});
-```
-
-## createNextApp
-
-Create all exports needed for a Next.js `[[...slug]]` catch-all route.
-
-```typescript
-import { createNextApp } from '@json-render/next/server';
-
-const { Page, generateMetadata, generateStaticParams } = createNextApp({
-  spec: myAppSpec,
-  loaders: {
-    loadPost: async ({ slug }) => {
-      const post = await db.post.findUnique({ where: { slug } });
-      return { post };
-    },
-  },
-});
-```
-
-### Options
-
-<table>
-  <thead>
-    <tr>
-      <th>Option</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>spec</code></td>
-      <td><code>{'NextAppSpec | (() => NextAppSpec | Promise<NextAppSpec>)'}</code></td>
-      <td>The application spec (static or dynamic)</td>
-    </tr>
-    <tr>
-      <td><code>loaders</code></td>
-      <td><code>{'Record<string, LoaderFn>'}</code></td>
-      <td>Server-side data loaders keyed by name</td>
-    </tr>
-  </tbody>
-</table>
-
-### Returns
-
-<table>
-  <thead>
-    <tr>
-      <th>Export</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>Page</code></td>
-      <td>Async Server Component for <code>page.tsx</code></td>
-    </tr>
-    <tr>
-      <td><code>generateMetadata</code></td>
-      <td>Metadata generator for Next.js SEO</td>
-    </tr>
-    <tr>
-      <td><code>generateStaticParams</code></td>
-      <td>Static params for pre-rendering at build time</td>
-    </tr>
-  </tbody>
-</table>
-
-## NextAppSpec
-
-The top-level spec defining an entire Next.js application.
-
-```typescript
-interface NextAppSpec {
-  metadata?: NextMetadata;
-  routes: Record<string, NextRouteSpec>;
-  layouts?: Record<string, Spec>;
-  state?: Record<string, unknown>;
-}
-```
-
-### Route Patterns
-
-Routes use Next.js URL conventions:
-
-<table>
-  <thead>
-    <tr>
-      <th>Pattern</th>
-      <th>Example Match</th>
-      <th>Params</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>/</code></td>
-      <td><code>/</code></td>
-      <td><code>{'{}'}</code></td>
-    </tr>
-    <tr>
-      <td><code>/about</code></td>
-      <td><code>/about</code></td>
-      <td><code>{'{}'}</code></td>
-    </tr>
-    <tr>
-      <td><code>/blog/[slug]</code></td>
-      <td><code>/blog/hello</code></td>
-      <td><code>{'{ slug: "hello" }'}</code></td>
-    </tr>
-    <tr>
-      <td><code>/docs/[...path]</code></td>
-      <td><code>/docs/a/b/c</code></td>
-      <td><code>{'{ path: ["a","b","c"] }'}</code></td>
-    </tr>
-    <tr>
-      <td><code>/app/[[...path]]</code></td>
-      <td><code>/app</code> or <code>/app/x/y</code></td>
-      <td><code>{'{ path: [] }'}</code> or <code>{'{ path: ["x","y"] }'}</code></td>
-    </tr>
-  </tbody>
-</table>
-
-## NextAppProvider
-
-Client component that provides the component registry and action handlers to all pages.
-
-```tsx
-import { NextAppProvider } from '@json-render/next';
-
-export default function Layout({ children }) {
-  return (
-    <NextAppProvider registry={registry} handlers={handlers}>
-      {children}
-    </NextAppProvider>
-  );
-}
-```
-
-## Built-in Components
-
-### Slot
-
-Placeholder in layouts where page content is rendered. Every layout MUST include a Slot.
-
-```json
-{ "type": "Slot", "props": {}, "children": [] }
-```
-
-### Link
-
-Client-side navigation wrapping `next/link`.
-
-```json
-{ "type": "Link", "props": { "href": "/about" }, "children": ["link-text"] }
-```
-
-## Built-in Actions
-
-<table>
-  <thead>
-    <tr>
-      <th>Action</th>
-      <th>Params</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>setState</code></td>
-      <td><code>{'{ statePath, value }'}</code></td>
-      <td>Update a value in state</td>
-    </tr>
-    <tr>
-      <td><code>pushState</code></td>
-      <td><code>{'{ statePath, value, clearStatePath? }'}</code></td>
-      <td>Append to array in state</td>
-    </tr>
-    <tr>
-      <td><code>removeState</code></td>
-      <td><code>{'{ statePath, index }'}</code></td>
-      <td>Remove from array by index</td>
-    </tr>
-    <tr>
-      <td><code>navigate</code></td>
-      <td><code>{'{ href }'}</code></td>
-      <td>Client-side navigation</td>
-    </tr>
-  </tbody>
-</table>
-
-## Server Utilities
-
-### matchRoute
-
-Match a pathname against a spec's routes.
-
-```typescript
-import { matchRoute } from '@json-render/next/server';
-
-const matched = matchRoute(spec, '/blog/hello-world');
-// { route: NextRouteSpec, pattern: '/blog/[slug]', params: { slug: 'hello-world' } }
-```
-
-### resolveMetadata
-
-Resolve merged metadata for a route.
-
-```typescript
-import { resolveMetadata } from '@json-render/next/server';
-
-const metadata = resolveMetadata(spec, matchedRoute?.route);
-```
-
-### slugToPath
-
-Convert catch-all slug array to pathname.
-
-```typescript
-import { slugToPath } from '@json-render/next/server';
-
-slugToPath(undefined);          // "/"
-slugToPath(['blog', 'hello']);  // "/blog/hello"
-```
-
-## Entry Points
-
-<table>
-  <thead>
-    <tr>
-      <th>Import</th>
-      <th>Contents</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>@json-render/next</code></td>
-      <td>Client components (NextAppProvider, PageRenderer, Link)</td>
-    </tr>
-    <tr>
-      <td><code>@json-render/next/server</code></td>
-      <td>Server utilities (createNextApp, matchRoute, schema)</td>
-    </tr>
-  </tbody>
-</table>

apps/web/content/docs/api/react-email.mdx

@@ -1,309 +0,0 @@
----
-title: "@json-render/react-email"
----
-
-React Email renderer. Turn JSON specs into HTML or plain-text emails using `@react-email/components` and `@react-email/render`.
-
-## Install
-
-```bash
-npm install @json-render/core @json-render/react-email @react-email/components @react-email/render
-```
-
-See the [React Email example](https://github.com/vercel-labs/json-render/tree/main/examples/react-email) for a full working example.
-
-## schema
-
-The email element schema for specs. Use with `defineCatalog` from core.
-
-```typescript
-import { defineCatalog } from '@json-render/core';
-import { schema, standardComponentDefinitions } from '@json-render/react-email';
-
-const catalog = defineCatalog(schema, {
-  components: standardComponentDefinitions,
-});
-```
-
-## Render Functions
-
-Server-side functions for producing email output. All accept a spec and optional `RenderOptions`.
-
-```typescript
-import { renderToHtml, renderToPlainText } from '@json-render/react-email';
-
-const html = await renderToHtml(spec);
-
-const plainText = await renderToPlainText(spec);
-```
-
-### RenderOptions
-
-```typescript
-interface RenderOptions {
-  registry?: ComponentRegistry;
-  includeStandard?: boolean;  // default: true
-  state?: Record<string, unknown>;
-}
-```
-
-<table>
-  <thead>
-    <tr>
-      <th>Option</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>registry</code></td>
-      <td>Custom component map (merged with standard components)</td>
-    </tr>
-    <tr>
-      <td><code>includeStandard</code></td>
-      <td>Include built-in standard components (default: <code>true</code>)</td>
-    </tr>
-    <tr>
-      <td><code>state</code></td>
-      <td>Initial state for <code>$state</code> / <code>$cond</code> dynamic prop resolution</td>
-    </tr>
-  </tbody>
-</table>
-
-## defineRegistry
-
-Create a type-safe component registry from a catalog. Components receive `{ props, children, emit, bindings, loading }`.
-
-```tsx
-import { defineRegistry } from '@json-render/react-email';
-import { Container, Heading, Text } from '@react-email/components';
-
-const { registry } = defineRegistry(catalog, {
-  components: {
-    Card: ({ props, children }) => (
-      <Container style={{ padding: 16, backgroundColor: '#fff' }}>
-        <Heading>{props.title}</Heading>
-        {children}
-      </Container>
-    ),
-  },
-});
-
-const html = await renderToHtml(spec, { registry });
-```
-
-## createRenderer
-
-Create a standalone renderer component wired to state, actions, and validation (for interactive previews in the browser).
-
-```typescript
-import { createRenderer } from '@json-render/react-email';
-
-const EmailRenderer = createRenderer(catalog, components);
-```
-
-## Renderer
-
-The main component that renders a spec to React Email elements. Use inside `JSONUIProvider` when you need state, actions, or visibility.
-
-```typescript
-interface RendererProps {
-  spec: Spec | null;
-  registry?: ComponentRegistry;
-  includeStandard?: boolean;  // default: true
-  loading?: boolean;
-  fallback?: ComponentRenderer;
-}
-```
-
-## Standard Components
-
-### Document structure
-
-<table>
-  <thead>
-    <tr>
-      <th>Component</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>Html</code></td>
-      <td>Top-level email wrapper. Must be the root element.</td>
-    </tr>
-    <tr>
-      <td><code>Head</code></td>
-      <td>Email head section. Place inside Html.</td>
-    </tr>
-    <tr>
-      <td><code>Body</code></td>
-      <td>Email body wrapper. Place inside Html.</td>
-    </tr>
-  </tbody>
-</table>
-
-### Layout
-
-<table>
-  <thead>
-    <tr>
-      <th>Component</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>Container</code></td>
-      <td>Constrains content width (e.g. max-width 600px).</td>
-    </tr>
-    <tr>
-      <td><code>Section</code></td>
-      <td>Groups related content.</td>
-    </tr>
-    <tr>
-      <td><code>Row</code></td>
-      <td>Horizontal layout row.</td>
-    </tr>
-    <tr>
-      <td><code>Column</code></td>
-      <td>Column within a Row.</td>
-    </tr>
-  </tbody>
-</table>
-
-### Content
-
-<table>
-  <thead>
-    <tr>
-      <th>Component</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>Heading</code></td>
-      <td>Heading text (h1-h6).</td>
-    </tr>
-    <tr>
-      <td><code>Text</code></td>
-      <td>Body text paragraph.</td>
-    </tr>
-    <tr>
-      <td><code>Link</code></td>
-      <td>Hyperlink with text and href.</td>
-    </tr>
-    <tr>
-      <td><code>Button</code></td>
-      <td>Call-to-action button (link styled as button).</td>
-    </tr>
-    <tr>
-      <td><code>Image</code></td>
-      <td>Image from URL.</td>
-    </tr>
-    <tr>
-      <td><code>Hr</code></td>
-      <td>Horizontal rule separator.</td>
-    </tr>
-  </tbody>
-</table>
-
-### Utility
-
-<table>
-  <thead>
-    <tr>
-      <th>Component</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>Preview</code></td>
-      <td>Preview text for inbox (inside Html).</td>
-    </tr>
-    <tr>
-      <td><code>Markdown</code></td>
-      <td>Renders markdown content as email-safe HTML.</td>
-    </tr>
-  </tbody>
-</table>
-
-## Server-Safe Import
-
-Import schema and catalog definitions without pulling in React or `@react-email/components`:
-
-```typescript
-import { schema, standardComponentDefinitions } from '@json-render/react-email/server';
-```
-
-## Sub-path Exports
-
-<table>
-  <thead>
-    <tr>
-      <th>Export</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>@json-render/react-email</code></td>
-      <td>Full package: schema, renderer, components, render functions</td>
-    </tr>
-    <tr>
-      <td><code>@json-render/react-email/server</code></td>
-      <td>Schema and catalog definitions only (no React)</td>
-    </tr>
-    <tr>
-      <td><code>@json-render/react-email/catalog</code></td>
-      <td>Standard component definitions and types</td>
-    </tr>
-    <tr>
-      <td><code>@json-render/react-email/render</code></td>
-      <td>Server-side render functions only</td>
-    </tr>
-  </tbody>
-</table>
-
-## Types
-
-<table>
-  <thead>
-    <tr>
-      <th>Export</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>ReactEmailSchema</code></td>
-      <td>Schema type for email specs</td>
-    </tr>
-    <tr>
-      <td><code>ReactEmailSpec</code></td>
-      <td>Spec type for email documents</td>
-    </tr>
-    <tr>
-      <td><code>RenderOptions</code></td>
-      <td>Options for render functions</td>
-    </tr>
-    <tr>
-      <td><code>ComponentContext</code></td>
-      <td>Typed component render function context</td>
-    </tr>
-    <tr>
-      <td><code>ComponentFn</code></td>
-      <td>Component render function type</td>
-    </tr>
-    <tr>
-      <td><code>StandardComponentDefinitions</code></td>
-      <td>Type of the standard component definitions object</td>
-    </tr>
-    <tr>
-      <td><code>StandardComponentProps&lt;K&gt;</code></td>
-      <td>Inferred props type for a standard component by name</td>
-    </tr>
-  </tbody>
-</table>

apps/web/content/docs/api/react-native.mdx

@@ -1,231 +0,0 @@
----
-title: "@json-render/react-native"
----
-
-React Native renderer with standard components, providers, and hooks.
-
-## Standard Components
-
-### Layout
-
-<table>
-<thead>
-<tr><th>Component</th><th>Props</th><th>Description</th></tr>
-</thead>
-<tbody>
-<tr><td><code>Container</code></td><td><code>padding</code>, <code>background</code>, <code>borderRadius</code>, <code>borderColor</code>, <code>flex</code></td><td>Basic wrapper with styling</td></tr>
-<tr><td><code>Row</code></td><td><code>gap</code>, <code>align</code>, <code>justify</code>, <code>flex</code>, <code>wrap</code></td><td>Horizontal flex layout</td></tr>
-<tr><td><code>Column</code></td><td><code>gap</code>, <code>align</code>, <code>justify</code>, <code>flex</code></td><td>Vertical flex layout</td></tr>
-<tr><td><code>ScrollContainer</code></td><td><code>direction</code></td><td>Scrollable area (vertical or horizontal)</td></tr>
-<tr><td><code>SafeArea</code></td><td><code>edges</code></td><td>Safe area insets for notch/home indicator</td></tr>
-<tr><td><code>Pressable</code></td><td><code>action</code>, <code>actionParams</code></td><td>Touchable wrapper that triggers actions</td></tr>
-<tr><td><code>Spacer</code></td><td><code>size</code>, <code>flex</code></td><td>Fixed or flexible spacing</td></tr>
-<tr><td><code>Divider</code></td><td><code>color</code>, <code>thickness</code></td><td>Thin line separator</td></tr>
-</tbody>
-</table>
-
-### Content
-
-<table>
-<thead>
-<tr><th>Component</th><th>Props</th><th>Description</th></tr>
-</thead>
-<tbody>
-<tr><td><code>Heading</code></td><td><code>text</code>, <code>level</code>, <code>align</code>, <code>color</code></td><td>Heading text (levels 1-6)</td></tr>
-<tr><td><code>Paragraph</code></td><td><code>text</code>, <code>align</code>, <code>color</code></td><td>Body text</td></tr>
-<tr><td><code>Label</code></td><td><code>text</code>, <code>color</code>, <code>bold</code></td><td>Small label text</td></tr>
-<tr><td><code>Image</code></td><td><code>uri</code>, <code>width</code>, <code>height</code>, <code>resizeMode</code>, <code>borderRadius</code></td><td>Image display</td></tr>
-<tr><td><code>Avatar</code></td><td><code>uri</code>, <code>size</code>, <code>fallback</code></td><td>Circular avatar</td></tr>
-<tr><td><code>Badge</code></td><td><code>label</code>, <code>color</code>, <code>textColor</code></td><td>Status badge</td></tr>
-<tr><td><code>Chip</code></td><td><code>label</code>, <code>selected</code>, <code>color</code></td><td>Tag/chip</td></tr>
-</tbody>
-</table>
-
-### Input
-
-<table>
-<thead>
-<tr><th>Component</th><th>Props</th><th>Description</th></tr>
-</thead>
-<tbody>
-<tr><td><code>Button</code></td><td><code>label</code>, <code>variant</code>, <code>size</code>, <code>disabled</code>, <code>action</code>, <code>actionParams</code></td><td>Pressable button</td></tr>
-<tr><td><code>TextInput</code></td><td><code>placeholder</code>, <code>value</code> (use <code>$bindState</code>), <code>secure</code>, <code>keyboardType</code>, <code>multiline</code></td><td>Text input field</td></tr>
-<tr><td><code>Switch</code></td><td><code>checked</code> (use <code>$bindState</code>), <code>label</code></td><td>Toggle switch</td></tr>
-<tr><td><code>Checkbox</code></td><td><code>checked</code> (use <code>$bindState</code>), <code>label</code></td><td>Checkbox with label</td></tr>
-<tr><td><code>Slider</code></td><td><code>value</code> (use <code>$bindState</code>), <code>min</code>, <code>max</code>, <code>step</code></td><td>Range slider</td></tr>
-<tr><td><code>SearchBar</code></td><td><code>placeholder</code>, <code>value</code> (use <code>$bindState</code>)</td><td>Search input</td></tr>
-</tbody>
-</table>
-
-### Feedback
-
-<table>
-<thead>
-<tr><th>Component</th><th>Props</th><th>Description</th></tr>
-</thead>
-<tbody>
-<tr><td><code>Spinner</code></td><td><code>size</code>, <code>color</code></td><td>Loading indicator</td></tr>
-<tr><td><code>ProgressBar</code></td><td><code>progress</code>, <code>color</code>, <code>trackColor</code></td><td>Progress indicator</td></tr>
-</tbody>
-</table>
-
-### Composite
-
-<table>
-<thead>
-<tr><th>Component</th><th>Props</th><th>Description</th></tr>
-</thead>
-<tbody>
-<tr><td><code>Card</code></td><td><code>title</code>, <code>subtitle</code>, <code>padding</code></td><td>Card container</td></tr>
-<tr><td><code>ListItem</code></td><td><code>title</code>, <code>subtitle</code>, <code>leading</code>, <code>trailing</code>, <code>action</code>, <code>actionParams</code></td><td>List row</td></tr>
-<tr><td><code>Modal</code></td><td><code>visible</code>, <code>title</code></td><td>Bottom sheet modal</td></tr>
-</tbody>
-</table>
-
-## Providers
-
-### StateProvider
-
-```tsx
-<StateProvider initialState={object} onStateChange={fn}>
-  {children}
-</StateProvider>
-```
-
-<table>
-<thead>
-<tr><th>Prop</th><th>Type</th><th>Description</th></tr>
-</thead>
-<tbody>
-<tr><td><code>store</code></td><td><code>StateStore</code></td><td>External store (controlled mode). When provided, <code>initialState</code> and <code>onStateChange</code> are ignored.</td></tr>
-<tr><td><code>initialState</code></td><td><code>Record&lt;string, unknown&gt;</code></td><td>Initial state model (uncontrolled mode).</td></tr>
-<tr><td><code>onStateChange</code></td><td><code>{'(changes: Array<{ path: string; value: unknown }>) => void'}</code></td><td>Callback when state changes (uncontrolled mode). Called once per <code>set</code> or <code>update</code> with all changed entries.</td></tr>
-</tbody>
-</table>
-
-#### External Store (Controlled Mode)
-
-Pass a `StateStore` to bypass the internal state and wire json-render to any state management library:
-
-```tsx
-import { createStateStore, type StateStore } from "@json-render/react-native";
-
-const store = createStateStore({ count: 0 });
-
-<StateProvider store={store}>
-  {children}
-</StateProvider>
-
-// Mutate from anywhere — components re-render automatically:
-store.set("/count", 1);
-```
-
-The `store` prop is also available on `JSONUIProvider` and `createRenderer`.
-
-### ActionProvider
-
-```tsx
-<ActionProvider handlers={Record<string, ActionHandler>}>
-  {children}
-</ActionProvider>
-```
-
-### VisibilityProvider
-
-```tsx
-<VisibilityProvider>
-  {children}
-</VisibilityProvider>
-```
-
-Conditions in specs use the `VisibilityCondition` format with `$state` paths (e.g. `{ "$state": "/path" }`, `{ "$state": "/path", "eq": value }`). See [visibility](/docs/visibility) for the full syntax.
-
-### ValidationProvider
-
-```tsx
-<ValidationProvider>
-  {children}
-</ValidationProvider>
-```
-
-## defineRegistry
-
-Create a type-safe component registry. Standard components are built-in; only register custom components.
-
-```tsx
-import { defineRegistry, type Components } from '@json-render/react-native';
-
-const { registry } = defineRegistry(catalog, {
-  components: {
-    Icon: ({ props }) => <Ionicons name={props.name} size={props.size ?? 24} />,
-  } as Components<typeof catalog>,
-});
-```
-
-## Hooks
-
-### useUIStream
-
-```typescript
-const {
-  spec,         // Spec | null - current UI state
-  isStreaming,  // boolean - true while streaming
-  error,        // Error | null
-  send,         // (prompt: string) => Promise<void>
-  clear,        // () => void - reset spec and error
-} = useUIStream({
-  api: string,
-  onComplete?: (spec: Spec) => void,
-  onError?: (error: Error) => void,
-});
-```
-
-### useStateStore
-
-```typescript
-const { state, get, set, update } = useStateStore();
-```
-
-### useStateValue
-
-```typescript
-const value = useStateValue(path: string);
-```
-
-### useStateBinding (deprecated)
-
-> **Deprecated.** Use `useBoundProp` with `$bindState` expressions instead.
-
-```typescript
-const [value, setValue] = useStateBinding(path: string);
-```
-
-### useActions
-
-```typescript
-const { execute } = useActions();
-```
-
-### useIsVisible
-
-```typescript
-const isVisible = useIsVisible(condition?: VisibilityCondition);
-```
-
-## Catalog Exports
-
-```typescript
-import { standardComponentDefinitions, standardActionDefinitions } from "@json-render/react-native/catalog";
-import { schema } from "@json-render/react-native/schema";
-```
-
-<table>
-<thead>
-<tr><th>Export</th><th>Purpose</th></tr>
-</thead>
-<tbody>
-<tr><td><code>standardComponentDefinitions</code></td><td>Catalog definitions for all 25+ standard components</td></tr>
-<tr><td><code>standardActionDefinitions</code></td><td>Catalog definitions for standard actions (setState, navigate)</td></tr>
-<tr><td><code>schema</code></td><td>React Native element tree schema</td></tr>
-</tbody>
-</table>

apps/web/content/docs/api/react-pdf.mdx

@@ -1,438 +0,0 @@
----
-title: "@json-render/react-pdf"
----
-
-PDF document renderer. Turn JSON specs into PDFs using `@react-pdf/renderer`.
-
-## Install
-
-```bash
-npm install @json-render/core @json-render/react-pdf
-```
-
-See the [React PDF example](https://github.com/vercel-labs/json-render/tree/main/examples/react-pdf) for a full working example.
-
-## schema
-
-The PDF element schema for document specs. Use with `defineCatalog` from core.
-
-```typescript
-import { defineCatalog } from '@json-render/core';
-import { schema, standardComponentDefinitions } from '@json-render/react-pdf';
-
-const catalog = defineCatalog(schema, {
-  components: standardComponentDefinitions,
-});
-```
-
-## Render Functions
-
-Server-side functions for producing PDF output. All accept a spec and optional `RenderOptions`.
-
-```typescript
-import { renderToBuffer, renderToStream, renderToFile } from '@json-render/react-pdf';
-
-const buffer = await renderToBuffer(spec);
-
-const stream = await renderToStream(spec);
-stream.pipe(res);
-
-await renderToFile(spec, './output.pdf');
-```
-
-### RenderOptions
-
-```typescript
-interface RenderOptions {
-  registry?: ComponentRegistry;
-  includeStandard?: boolean;  // default: true
-  state?: Record<string, unknown>;
-}
-```
-
-<table>
-  <thead>
-    <tr>
-      <th>Option</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>registry</code></td>
-      <td>Custom component map (merged with standard components)</td>
-    </tr>
-    <tr>
-      <td><code>includeStandard</code></td>
-      <td>Include built-in standard components (default: <code>true</code>)</td>
-    </tr>
-    <tr>
-      <td><code>state</code></td>
-      <td>Initial state for <code>$state</code> / <code>$cond</code> dynamic prop resolution</td>
-    </tr>
-  </tbody>
-</table>
-
-## defineRegistry
-
-Create a type-safe component registry from a catalog. Components receive `{ props, children, emit, bindings, loading }`.
-
-```tsx
-import { defineRegistry } from '@json-render/react-pdf';
-import { View, Text } from '@react-pdf/renderer';
-
-const { registry } = defineRegistry(catalog, {
-  components: {
-    Badge: ({ props }) => (
-      <View style={{ backgroundColor: props.color ?? '#e5e7eb', padding: 4, borderRadius: 4 }}>
-        <Text style={{ fontSize: 10 }}>{props.label}</Text>
-      </View>
-    ),
-  },
-});
-
-const buffer = await renderToBuffer(spec, { registry });
-```
-
-## createRenderer
-
-Create a standalone renderer component wired to state, actions, and validation.
-
-```typescript
-import { createRenderer } from '@json-render/react-pdf';
-
-const PDFRenderer = createRenderer(catalog, components);
-```
-
-```typescript
-interface CreateRendererProps {
-  spec: Spec | null;
-  store?: StateStore;
-  state?: Record<string, unknown>;
-  onAction?: (actionName: string, params?: Record<string, unknown>) => void;
-  onStateChange?: (changes: Array<{ path: string; value: unknown }>) => void;
-  loading?: boolean;
-  fallback?: ComponentRenderer;
-}
-```
-
-When `store` is provided, `state` and `onStateChange` are ignored (controlled mode).
-
-## Renderer
-
-The main component that renders a spec to `@react-pdf/renderer` elements.
-
-```typescript
-interface RendererProps {
-  spec: Spec | null;
-  registry?: ComponentRegistry;
-  includeStandard?: boolean;  // default: true
-  loading?: boolean;
-  fallback?: ComponentRenderer;
-}
-```
-
-## Standard Components
-
-### Document Structure
-
-#### Document
-
-Top-level PDF wrapper. Must be the root element. Children must be `Page` components.
-
-```typescript
-{
-  title: string | null;
-  author: string | null;
-  subject: string | null;
-}
-```
-
-#### Page
-
-A page in the document with configurable size, orientation, and margins.
-
-```typescript
-{
-  size: "A4" | "A3" | "A5" | "LETTER" | "LEGAL" | "TABLOID" | null;
-  orientation: "portrait" | "landscape" | null;
-  marginTop: number | null;
-  marginBottom: number | null;
-  marginLeft: number | null;
-  marginRight: number | null;
-  backgroundColor: string | null;
-}
-```
-
-### Layout
-
-#### View
-
-Generic container with padding, margin, background, border, and flex alignment.
-
-```typescript
-{
-  padding: number | null;
-  paddingTop: number | null;
-  paddingBottom: number | null;
-  paddingLeft: number | null;
-  paddingRight: number | null;
-  margin: number | null;
-  backgroundColor: string | null;
-  borderWidth: number | null;
-  borderColor: string | null;
-  borderRadius: number | null;
-  flex: number | null;
-  alignItems: "flex-start" | "center" | "flex-end" | "stretch" | null;
-  justifyContent: "flex-start" | "center" | "flex-end" | "space-between" | "space-around" | null;
-}
-```
-
-#### Row
-
-Horizontal flex layout with optional wrapping.
-
-```typescript
-{
-  gap: number | null;
-  alignItems: "flex-start" | "center" | "flex-end" | "stretch" | null;
-  justifyContent: "flex-start" | "center" | "flex-end" | "space-between" | "space-around" | null;
-  padding: number | null;
-  flex: number | null;
-  wrap: boolean | null;
-}
-```
-
-#### Column
-
-Vertical flex layout.
-
-```typescript
-{
-  gap: number | null;
-  alignItems: "flex-start" | "center" | "flex-end" | "stretch" | null;
-  justifyContent: "flex-start" | "center" | "flex-end" | "space-between" | "space-around" | null;
-  padding: number | null;
-  flex: number | null;
-}
-```
-
-### Content
-
-#### Heading
-
-h1-h4 heading text with configurable color and alignment.
-
-```typescript
-{
-  text: string;
-  level: "h1" | "h2" | "h3" | "h4" | null;
-  color: string | null;
-  align: "left" | "center" | "right" | null;
-}
-```
-
-#### Text
-
-Body text with full styling control.
-
-```typescript
-{
-  text: string;
-  fontSize: number | null;
-  color: string | null;
-  align: "left" | "center" | "right" | null;
-  fontWeight: "normal" | "bold" | null;
-  fontStyle: "normal" | "italic" | null;
-  lineHeight: number | null;
-}
-```
-
-#### Image
-
-Image from a URL with optional dimensions and fit.
-
-```typescript
-{
-  src: string;
-  width: number | null;
-  height: number | null;
-  objectFit: "contain" | "cover" | "fill" | "none" | null;
-}
-```
-
-#### Link
-
-Hyperlink with visible text.
-
-```typescript
-{
-  text: string;
-  href: string;
-  fontSize: number | null;
-  color: string | null;
-}
-```
-
-### Data
-
-#### Table
-
-Data table with typed columns and string rows. Supports header styling and striped rows.
-
-```typescript
-{
-  columns: { header: string; width?: string; align?: "left" | "center" | "right" }[];
-  rows: string[][];
-  headerBackgroundColor: string | null;
-  headerTextColor: string | null;
-  borderColor: string | null;
-  fontSize: number | null;
-  striped: boolean | null;
-}
-```
-
-#### List
-
-Ordered or unordered list.
-
-```typescript
-{
-  items: string[];
-  ordered: boolean | null;
-  fontSize: number | null;
-  color: string | null;
-  spacing: number | null;
-}
-```
-
-### Decorative
-
-#### Divider
-
-Horizontal line separator.
-
-```typescript
-{
-  color: string | null;
-  thickness: number | null;
-  marginTop: number | null;
-  marginBottom: number | null;
-}
-```
-
-#### Spacer
-
-Empty vertical space.
-
-```typescript
-{
-  height: number | null;
-}
-```
-
-### Page-Level
-
-#### PageNumber
-
-Renders current page number and total pages. Format uses `{pageNumber}` and `{totalPages}` placeholders.
-
-```typescript
-{
-  format: string | null;    // default: "{pageNumber} / {totalPages}"
-  fontSize: number | null;
-  color: string | null;
-  align: "left" | "center" | "right" | null;
-}
-```
-
-## External Store (Controlled Mode)
-
-Pass a `StateStore` to `StateProvider`, `JSONUIProvider`, or `createRenderer` for full control over state:
-
-```tsx
-import { createStateStore, type StateStore } from "@json-render/react-pdf";
-
-const store = createStateStore({ invoice: { total: 100 } });
-store.set("/invoice/total", 200);
-```
-
-When `store` is provided, `initialState` / `state` and `onStateChange` are ignored.
-
-## Server-Safe Import
-
-Import schema and catalog definitions without pulling in React or `@react-pdf/renderer`:
-
-```typescript
-import { schema, standardComponentDefinitions } from '@json-render/react-pdf/server';
-```
-
-## Sub-path Exports
-
-<table>
-  <thead>
-    <tr>
-      <th>Export</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>@json-render/react-pdf</code></td>
-      <td>Full package: schema, renderer, components, render functions</td>
-    </tr>
-    <tr>
-      <td><code>@json-render/react-pdf/server</code></td>
-      <td>Schema and catalog definitions only (no React)</td>
-    </tr>
-    <tr>
-      <td><code>@json-render/react-pdf/catalog</code></td>
-      <td>Standard component definitions and types</td>
-    </tr>
-    <tr>
-      <td><code>@json-render/react-pdf/render</code></td>
-      <td>Server-side render functions only</td>
-    </tr>
-  </tbody>
-</table>
-
-## Types
-
-<table>
-  <thead>
-    <tr>
-      <th>Export</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>ReactPdfSchema</code></td>
-      <td>Schema type for PDF specs</td>
-    </tr>
-    <tr>
-      <td><code>ReactPdfSpec</code></td>
-      <td>Spec type for PDF documents</td>
-    </tr>
-    <tr>
-      <td><code>RenderOptions</code></td>
-      <td>Options for render functions</td>
-    </tr>
-    <tr>
-      <td><code>ComponentContext</code></td>
-      <td>Typed component render function context</td>
-    </tr>
-    <tr>
-      <td><code>ComponentFn</code></td>
-      <td>Component render function type</td>
-    </tr>
-    <tr>
-      <td><code>StandardComponentDefinitions</code></td>
-      <td>Type of the standard component definitions object</td>
-    </tr>
-    <tr>
-      <td><code>StandardComponentProps&lt;K&gt;</code></td>
-      <td>Inferred props type for a standard component by name</td>
-    </tr>
-  </tbody>
-</table>

apps/web/content/docs/api/react-three-fiber.mdx

@@ -1,420 +0,0 @@
----
-title: "@json-render/react-three-fiber"
----
-
-React Three Fiber renderer for json-render. 20 built-in 3D components for meshes, lights, models, gaussian splats, environments, text, cameras, and controls.
-
-## Installation
-
-```bash
-npm install @json-render/react-three-fiber @json-render/core @json-render/react @react-three/fiber @react-three/drei three zod
-```
-
-## Entry Points
-
-<table>
-<thead>
-<tr>
-<th>Entry Point</th>
-<th>Exports</th>
-<th>Use For</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>@json-render/react-three-fiber</code></td>
-<td><code>threeComponents</code>, <code>ThreeRenderer</code>, <code>ThreeCanvas</code>, schemas</td>
-<td>React Three Fiber implementations and renderer</td>
-</tr>
-<tr>
-<td><code>@json-render/react-three-fiber/catalog</code></td>
-<td><code>threeComponentDefinitions</code></td>
-<td>Catalog schemas (no R3F dependency, safe for server)</td>
-</tr>
-</tbody>
-</table>
-
-## Usage
-
-```tsx
-import {'{ defineCatalog }'} from "@json-render/core";
-import {'{ schema, defineRegistry }'} from "@json-render/react";
-import {'{'}
-  threeComponentDefinitions,
-  threeComponents,
-  ThreeCanvas,
-{'}'} from "@json-render/react-three-fiber";
-
-const catalog = defineCatalog(schema, {'{'}
-  components: {'{'}
-    Box: threeComponentDefinitions.Box,
-    Sphere: threeComponentDefinitions.Sphere,
-    AmbientLight: threeComponentDefinitions.AmbientLight,
-    DirectionalLight: threeComponentDefinitions.DirectionalLight,
-    OrbitControls: threeComponentDefinitions.OrbitControls,
-  {'}'},
-  actions: {'{}'},
-{'}'});
-
-const {'{ registry }'} = defineRegistry(catalog, {'{'}
-  components: {'{'}
-    Box: threeComponents.Box,
-    Sphere: threeComponents.Sphere,
-    AmbientLight: threeComponents.AmbientLight,
-    DirectionalLight: threeComponents.DirectionalLight,
-    OrbitControls: threeComponents.OrbitControls,
-  {'}'},
-{'}'});
-```
-
-### ThreeCanvas (convenience)
-
-```tsx
-<ThreeCanvas
-  spec={'{spec}'}
-  registry={'{registry}'}
-  shadows
-  camera={'{'}{'{ position: [5, 5, 5], fov: 50 }'}{'}'} 
-  style={'{'}{'{ width: "100%", height: "100vh" }'}{'}'} 
-/>
-```
-
-### Manual Canvas Setup
-
-```tsx
-import {'{ Canvas }'} from "@react-three/fiber";
-import {'{ ThreeRenderer }'} from "@json-render/react-three-fiber";
-
-<Canvas shadows>
-  <ThreeRenderer spec={'{spec}'} registry={'{registry}'} />
-</Canvas>
-```
-
-## Components
-
-### Primitives
-
-<table>
-<thead>
-<tr>
-<th>Component</th>
-<th>Description</th>
-<th>Key Props</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>Box</code></td>
-<td>Box mesh (default 1x1x1)</td>
-<td><code>width</code>, <code>height</code>, <code>depth</code>, <code>material</code></td>
-</tr>
-<tr>
-<td><code>Sphere</code></td>
-<td>Sphere mesh</td>
-<td><code>radius</code>, <code>widthSegments</code>, <code>heightSegments</code>, <code>material</code></td>
-</tr>
-<tr>
-<td><code>Cylinder</code></td>
-<td>Cylinder mesh</td>
-<td><code>radiusTop</code>, <code>radiusBottom</code>, <code>height</code>, <code>material</code></td>
-</tr>
-<tr>
-<td><code>Cone</code></td>
-<td>Cone mesh</td>
-<td><code>radius</code>, <code>height</code>, <code>material</code></td>
-</tr>
-<tr>
-<td><code>Torus</code></td>
-<td>Torus (donut) mesh</td>
-<td><code>radius</code>, <code>tube</code>, <code>material</code></td>
-</tr>
-<tr>
-<td><code>Plane</code></td>
-<td>Flat plane mesh</td>
-<td><code>width</code>, <code>height</code>, <code>material</code></td>
-</tr>
-<tr>
-<td><code>Capsule</code></td>
-<td>Capsule mesh</td>
-<td><code>radius</code>, <code>length</code>, <code>material</code></td>
-</tr>
-</tbody>
-</table>
-
-All primitives share: <code>position</code>, <code>rotation</code>, <code>scale</code>, <code>castShadow</code>, <code>receiveShadow</code>, <code>material</code>.
-
-### Material Schema
-
-<table>
-<thead>
-<tr>
-<th>Property</th>
-<th>Type</th>
-<th>Default</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>color</code></td>
-<td><code>string</code></td>
-<td><code>"#ffffff"</code></td>
-</tr>
-<tr>
-<td><code>metalness</code></td>
-<td><code>number</code></td>
-<td><code>0</code></td>
-</tr>
-<tr>
-<td><code>roughness</code></td>
-<td><code>number</code></td>
-<td><code>1</code></td>
-</tr>
-<tr>
-<td><code>emissive</code></td>
-<td><code>string</code></td>
-<td><code>"#000000"</code></td>
-</tr>
-<tr>
-<td><code>emissiveIntensity</code></td>
-<td><code>number</code></td>
-<td><code>1</code></td>
-</tr>
-<tr>
-<td><code>opacity</code></td>
-<td><code>number</code></td>
-<td><code>1</code></td>
-</tr>
-<tr>
-<td><code>transparent</code></td>
-<td><code>boolean</code></td>
-<td><code>false</code></td>
-</tr>
-<tr>
-<td><code>wireframe</code></td>
-<td><code>boolean</code></td>
-<td><code>false</code></td>
-</tr>
-</tbody>
-</table>
-
-### Lights
-
-<table>
-<thead>
-<tr>
-<th>Component</th>
-<th>Description</th>
-<th>Key Props</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>AmbientLight</code></td>
-<td>Uniform illumination</td>
-<td><code>color</code>, <code>intensity</code></td>
-</tr>
-<tr>
-<td><code>DirectionalLight</code></td>
-<td>Sunlight-style</td>
-<td><code>position</code>, <code>color</code>, <code>intensity</code>, <code>castShadow</code></td>
-</tr>
-<tr>
-<td><code>PointLight</code></td>
-<td>Radiates from a point</td>
-<td><code>position</code>, <code>color</code>, <code>intensity</code>, <code>distance</code>, <code>decay</code></td>
-</tr>
-<tr>
-<td><code>SpotLight</code></td>
-<td>Cone of light</td>
-<td><code>position</code>, <code>color</code>, <code>intensity</code>, <code>angle</code>, <code>penumbra</code></td>
-</tr>
-</tbody>
-</table>
-
-### Other Components
-
-<table>
-<thead>
-<tr>
-<th>Component</th>
-<th>Description</th>
-<th>Key Props</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>Group</code></td>
-<td>Container for children</td>
-<td><code>position</code>, <code>rotation</code>, <code>scale</code></td>
-</tr>
-<tr>
-<td><code>Model</code></td>
-<td>GLTF/GLB model loader</td>
-<td><code>url</code>, <code>position</code>, <code>rotation</code>, <code>scale</code></td>
-</tr>
-<tr>
-<td><code>Environment</code></td>
-<td>HDRI environment map</td>
-<td><code>preset</code>, <code>background</code>, <code>blur</code>, <code>intensity</code></td>
-</tr>
-<tr>
-<td><code>Fog</code></td>
-<td>Linear fog effect</td>
-<td><code>color</code>, <code>near</code>, <code>far</code></td>
-</tr>
-<tr>
-<td><code>GridHelper</code></td>
-<td>Reference grid</td>
-<td><code>size</code>, <code>divisions</code>, <code>color</code></td>
-</tr>
-<tr>
-<td><code>Text3D</code></td>
-<td>3D text (SDF)</td>
-<td><code>text</code>, <code>fontSize</code>, <code>color</code>, <code>anchorX</code>, <code>anchorY</code></td>
-</tr>
-<tr>
-<td><code>PerspectiveCamera</code></td>
-<td>Camera</td>
-<td><code>position</code>, <code>fov</code>, <code>near</code>, <code>far</code>, <code>makeDefault</code></td>
-</tr>
-<tr>
-<td><code>OrbitControls</code></td>
-<td>Camera controls</td>
-<td><code>enableDamping</code>, <code>enableZoom</code>, <code>autoRotate</code></td>
-</tr>
-<tr>
-<td><code>GaussianSplat</code></td>
-<td>Gaussian splat (.splat/.ply) loader</td>
-<td><code>src</code>, <code>position</code>, <code>rotation</code>, <code>scale</code>, <code>alphaHash</code>, <code>toneMapped</code></td>
-</tr>
-</tbody>
-</table>
-
-## Shared Schemas
-
-Reusable Zod schemas for custom 3D components:
-
-```tsx
-import {'{ vector3Schema, materialSchema, transformProps, shadowProps }'} from "@json-render/react-three-fiber";
-```
-
-<table>
-<thead>
-<tr>
-<th>Export</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>vector3Schema</code></td>
-<td><code>z.tuple([z.number(), z.number(), z.number()])</code></td>
-</tr>
-<tr>
-<td><code>materialSchema</code></td>
-<td>Standard material props (color, metalness, roughness, etc.)</td>
-</tr>
-<tr>
-<td><code>transformProps</code></td>
-<td><code>{'{ position, rotation, scale }'}</code> schema fields</td>
-</tr>
-<tr>
-<td><code>shadowProps</code></td>
-<td><code>{'{ castShadow, receiveShadow }'}</code> schema fields</td>
-</tr>
-</tbody>
-</table>
-
-## ThreeRenderer
-
-<table>
-<thead>
-<tr>
-<th>Prop</th>
-<th>Type</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>spec</code></td>
-<td><code>Spec | null</code></td>
-<td>The spec to render as a 3D scene</td>
-</tr>
-<tr>
-<td><code>registry</code></td>
-<td><code>ComponentRegistry</code></td>
-<td>Component registry from <code>defineRegistry</code></td>
-</tr>
-<tr>
-<td><code>store</code></td>
-<td><code>StateStore</code></td>
-<td>External state store (controlled mode)</td>
-</tr>
-<tr>
-<td><code>initialState</code></td>
-<td><code>Record&lt;string, unknown&gt;</code></td>
-<td>Initial state (uncontrolled mode)</td>
-</tr>
-<tr>
-<td><code>handlers</code></td>
-<td><code>Record&lt;string, Function&gt;</code></td>
-<td>Action handlers</td>
-</tr>
-<tr>
-<td><code>loading</code></td>
-<td><code>boolean</code></td>
-<td>Whether the spec is streaming</td>
-</tr>
-<tr>
-<td><code>children</code></td>
-<td><code>ReactNode</code></td>
-<td>Additional R3F elements alongside the spec</td>
-</tr>
-</tbody>
-</table>
-
-## ThreeCanvas
-
-Extends <code>ThreeRendererProps</code> with Canvas options:
-
-<table>
-<thead>
-<tr>
-<th>Prop</th>
-<th>Type</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>shadows</code></td>
-<td><code>boolean</code></td>
-<td>Enable shadow maps</td>
-</tr>
-<tr>
-<td><code>camera</code></td>
-<td><code>object</code></td>
-<td>Default camera config (position, fov, etc.)</td>
-</tr>
-<tr>
-<td><code>className</code></td>
-<td><code>string</code></td>
-<td>CSS class for the canvas container</td>
-</tr>
-<tr>
-<td><code>style</code></td>
-<td><code>CSSProperties</code></td>
-<td>Inline styles for the canvas container</td>
-</tr>
-</tbody>
-</table>
-
-## Type Helpers
-
-```tsx
-import type {'{ ThreeProps }'} from "@json-render/react-three-fiber";
-
-type BoxProps = ThreeProps<"Box">;
-type SphereProps = ThreeProps<"Sphere">;
-```

apps/web/content/docs/api/react.mdx

@@ -1,376 +0,0 @@
----
-title: "@json-render/react"
----
-
-React components, providers, and hooks.
-
-## Providers
-
-### StateProvider
-
-```tsx
-<StateProvider initialState={object} onStateChange={fn}>
-  {children}
-</StateProvider>
-```
-
-<table>
-  <thead>
-    <tr>
-      <th>Prop</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>store</code></td>
-      <td><code>StateStore</code></td>
-      <td>External store (controlled mode). When provided, <code>initialState</code> and <code>onStateChange</code> are ignored.</td>
-    </tr>
-    <tr>
-      <td><code>initialState</code></td>
-      <td><code>Record&lt;string, unknown&gt;</code></td>
-      <td>Initial state model (uncontrolled mode).</td>
-    </tr>
-    <tr>
-      <td><code>onStateChange</code></td>
-      <td><code>{'(changes: Array<{ path: string; value: unknown }>) => void'}</code></td>
-      <td>Callback when state changes (uncontrolled mode). Called once per <code>set</code> or <code>update</code> with all changed entries.</td>
-    </tr>
-  </tbody>
-</table>
-
-#### External Store (Controlled Mode)
-
-Pass a `StateStore` to bypass the internal state and wire json-render to any state management library:
-
-```tsx
-import { createStateStore, type StateStore } from "@json-render/react";
-
-const store = createStateStore({ count: 0 });
-
-<StateProvider store={store}>
-  {children}
-</StateProvider>
-
-// Mutate from anywhere — React re-renders automatically:
-store.set("/count", 1);
-```
-
-The `store` prop is also available on `JSONUIProvider` and `createRenderer`.
-
-### ActionProvider
-
-```tsx
-<ActionProvider handlers={Record<string, ActionHandler>}>
-  {children}
-</ActionProvider>
-
-type ActionHandler = (params: Record<string, unknown>) => void | Promise<void>;
-```
-
-### VisibilityProvider
-
-```tsx
-<VisibilityProvider>
-  {children}
-</VisibilityProvider>
-```
-
-`VisibilityProvider` reads state from the parent `StateProvider` automatically. Conditions in specs use the `VisibilityCondition` format with `$state` paths (e.g. `{ "$state": "/path" }`, `{ "$state": "/path", "eq": value }`). See [visibility](/docs/visibility) for the full syntax.
-
-### ValidationProvider
-
-```tsx
-<ValidationProvider customFunctions={Record<string, ValidationFunction>}>
-  {children}
-</ValidationProvider>
-
-type ValidationFunction = (value: unknown, args?: object) => boolean | Promise<boolean>;
-```
-
-## defineRegistry
-
-Create a type-safe component registry from a catalog. Components receive `props`, `children`, `emit`, `on`, and `loading` with catalog-inferred types.
-
-When the catalog declares actions, the `actions` field is required. When the catalog has no actions (e.g. `actions: {}`), the field is optional.
-
-```tsx
-import { defineRegistry } from '@json-render/react';
-
-const { registry } = defineRegistry(catalog, {
-  components: {
-    Card: ({ props, children }) => <div>{props.title}{children}</div>,
-    Button: ({ props, emit }) => (
-      <button onClick={() => emit("press")}>
-        {props.label}
-      </button>
-    ),
-  },
-});
-
-// Pass to <Renderer>
-<Renderer spec={spec} registry={registry} />
-```
-
-## Components
-
-### Renderer
-
-```tsx
-<Renderer
-  spec={Spec}           // The UI spec to render
-  registry={Registry}   // Component registry (from defineRegistry)
-  loading={boolean}     // Optional loading state
-  fallback={Component}  // Optional fallback for unknown types
-/>
-
-type Registry = Record<string, React.ComponentType<ComponentRenderProps>>;
-```
-
-### JSONUIProvider
-
-Convenience wrapper that combines `StateProvider`, `VisibilityProvider`, `ValidationProvider`, and `ActionProvider`. Accepts all their props plus:
-
-<table>
-  <thead>
-    <tr>
-      <th>Prop</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>functions</code></td>
-      <td><code>Record&lt;string, ComputedFunction&gt;</code></td>
-      <td>Named functions for <code>$computed</code> expressions in props</td>
-    </tr>
-  </tbody>
-</table>
-
-```tsx
-<JSONUIProvider
-  spec={spec}
-  catalog={catalog}
-  handlers={{ submit: async () => { /* ... */ } }}
-  functions={{ fullName: (args) => `${args.first} ${args.last}` }}
->
-  <Renderer spec={spec} registry={registry} />
-</JSONUIProvider>
-```
-
-The `functions` prop is also available on `createRenderer`.
-
-### Component Props (via defineRegistry)
-
-```tsx
-interface ComponentContext<P> {
-  props: P;                                // Typed props from catalog
-  children?: React.ReactNode;              // Rendered children (for slot components)
-  emit: (event: string) => void;           // Emit a named event (always defined)
-  on: (event: string) => EventHandle;      // Get event handle with metadata
-  loading?: boolean;
-  bindings?: Record<string, string>;       // State paths from $bindState/$bindItem expressions
-}
-
-interface EventHandle {
-  emit: () => void;              // Fire the event
-  shouldPreventDefault: boolean; // Whether any binding requested preventDefault
-  bound: boolean;                // Whether any handler is bound
-}
-```
-
-Use `emit("press")` for simple event firing. Use `on("click")` when you need to check metadata like `shouldPreventDefault`:
-
-```tsx
-Link: ({ props, on }) => {
-  const click = on("click");
-  return (
-    <a
-      href={props.href}
-      onClick={(e) => {
-        if (click.shouldPreventDefault) e.preventDefault();
-        click.emit();
-      }}
-    >
-      {props.label}
-    </a>
-  );
-},
-```
-
-### BaseComponentProps
-
-Catalog-agnostic base type for building reusable component libraries (e.g. `@json-render/shadcn`) that are not tied to a specific catalog:
-
-```typescript
-import type { BaseComponentProps } from "@json-render/react";
-
-const Card = ({ props, children }: BaseComponentProps<{ title?: string }>) => (
-  <div>{props.title}{children}</div>
-);
-```
-
-## Hooks
-
-### useUIStream
-
-```typescript
-const {
-  spec,         // Spec | null - current UI state
-  isStreaming,  // boolean - true while streaming
-  error,        // Error | null
-  send,         // (prompt: string, context?: Record<string, unknown>) => Promise<void>
-  clear,        // () => void - reset spec and error
-} = useUIStream({
-  api: string,                         // API endpoint URL
-  onComplete?: (spec: Spec) => void,   // Called when streaming completes
-  onError?: (error: Error) => void,    // Called when an error occurs
-});
-```
-
-### useStateStore
-
-```typescript
-const {
-  state,   // StateModel (Record<string, unknown>)
-  get,     // (path: string) => unknown
-  set,     // (path: string, value: unknown) => void
-  update,  // (updates: Record<string, unknown>) => void
-} = useStateStore();
-```
-
-### useStateValue
-
-```typescript
-const value = useStateValue(path: string);
-```
-
-### useStateBinding (deprecated)
-
-> **Deprecated.** Use `useBoundProp` with `$bindState` expressions instead.
-
-```typescript
-const [value, setValue] = useStateBinding(path: string);
-```
-
-### useActions
-
-```typescript
-const { execute } = useActions();
-// execute(binding: ActionBinding) => Promise<void>
-```
-
-### useAction
-
-```typescript
-const { execute, isLoading } = useAction(binding: ActionBinding);
-// execute() => Promise<void>
-```
-
-### useIsVisible
-
-```typescript
-const isVisible = useIsVisible(condition?: VisibilityCondition);
-```
-
-### useFieldValidation
-
-```typescript
-const {
-  state,     // FieldValidationState
-  validate,  // () => ValidationResult
-  touch,     // () => void
-  clear,     // () => void
-  errors,    // string[]
-  isValid,   // boolean
-} = useFieldValidation(path: string, config?: ValidationConfig);
-```
-
-`ValidationConfig` is `{ checks?: ValidationCheck[], validateOn?: 'change' | 'blur' | 'submit' }`.
-
-### useOptionalValidation
-
-Non-throwing variant of `useValidation()`. Returns `null` when no `ValidationProvider` is present, instead of throwing. Useful in components that may or may not be rendered inside a validation context.
-
-```typescript
-const validation = useOptionalValidation();
-// ValidationContextValue | null
-```
-
-### useBoundProp
-
-Two-way binding helper for `$bindState` / `$bindItem` expressions. Returns `[value, setValue]` where `setValue` writes back to the bound state path.
-
-```typescript
-const [value, setValue] = useBoundProp<T>(
-  propValue: T | undefined,       // The already-resolved prop value
-  bindingPath: string | undefined  // From bindings?.value
-);
-```
-
-Use inside registry components:
-
-```tsx
-const Input: ComponentRenderer = ({ props, bindings }) => {
-  const [value, setValue] = useBoundProp<string>(props.value, bindings?.value);
-  return <input value={value ?? ""} onChange={(e) => setValue(e.target.value)} />;
-};
-```
-
-### Chat Hooks
-
-Two hooks are available for chat + GenUI, depending on your setup:
-
-- **`useChatUI`** -- Self-contained chat hook with its own message state, fetch logic, and mixed stream parsing. Use when you want a standalone chat experience without the Vercel AI SDK.
-- **`useJsonRenderMessage`** -- Extracts spec + text from an AI SDK `UIMessage.parts` array. Use with the Vercel AI SDK's `useChat` for full AI SDK integration.
-
-### useChatUI
-
-Hook for chat + GenUI experiences. Manages a multi-turn conversation where each assistant message can contain both text and a json-render UI spec.
-
-```typescript
-const {
-  messages,     // ChatMessage[] - all messages in the conversation
-  isStreaming,  // boolean - true while streaming
-  error,        // Error | null
-  send,         // (text: string) => Promise<void>
-  clear,        // () => void - reset conversation
-} = useChatUI({
-  api: string,                                   // API endpoint
-  onComplete?: (message: ChatMessage) => void,   // Called when streaming completes
-  onError?: (error: Error) => void,              // Called on error
-});
-
-interface ChatMessage {
-  id: string;
-  role: "user" | "assistant";
-  text: string;
-  spec: Spec | null;
-}
-```
-
-### useJsonRenderMessage
-
-Extract a spec and text content from an AI SDK message's `parts` array. Designed for integration with Vercel AI SDK's `useChat`.
-
-```typescript
-const { spec, text, hasSpec } = useJsonRenderMessage(parts: DataPart[]);
-
-// spec: Spec | null     - compiled from JSONL patches in data parts
-// text: string          - concatenated text parts
-// hasSpec: boolean      - true when spec is non-null
-```
-
-### buildSpecFromParts / getTextFromParts
-
-Standalone utilities for extracting spec and text from AI SDK message parts (non-hook versions):
-
-```typescript
-import { buildSpecFromParts, getTextFromParts } from '@json-render/react';
-
-const spec = buildSpecFromParts(message.parts);   // Spec | null
-const text = getTextFromParts(message.parts);      // string
-```

apps/web/content/docs/api/redux.mdx

@@ -1,103 +0,0 @@
----
-title: "@json-render/redux"
----
-
-Redux / Redux Toolkit adapter for json-render's `StateStore` interface.
-
-## Installation
-
-```bash
-npm install @json-render/redux @json-render/core @json-render/react redux
-# or with Redux Toolkit (recommended):
-npm install @json-render/redux @json-render/core @json-render/react @reduxjs/toolkit
-```
-
-## reduxStateStore
-
-Create a `StateStore` backed by a Redux store.
-
-```typescript
-import { reduxStateStore } from "@json-render/redux";
-```
-
-### Options
-
-<table>
-  <thead>
-    <tr>
-      <th>Option</th>
-      <th>Type</th>
-      <th>Required</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>store</code></td>
-      <td><code>Store</code></td>
-      <td>Yes</td>
-      <td>The Redux store instance.</td>
-    </tr>
-    <tr>
-      <td><code>selector</code></td>
-      <td><code>{'(state: S) => StateModel'}</code></td>
-      <td>No</td>
-      <td>Select the json-render slice from the Redux state tree. Defaults to <code>{'(state) => state'}</code>.</td>
-    </tr>
-    <tr>
-      <td><code>dispatch</code></td>
-      <td><code>{'(nextState: StateModel, store: Store) => void'}</code></td>
-      <td>Yes</td>
-      <td>Dispatch an action that replaces the selected slice with the next state.</td>
-    </tr>
-  </tbody>
-</table>
-
-### Example
-
-```typescript
-import { configureStore, createSlice } from "@reduxjs/toolkit";
-import { reduxStateStore } from "@json-render/redux";
-import { StateProvider } from "@json-render/react";
-
-const uiSlice = createSlice({
-  name: "ui",
-  initialState: { count: 0 } as Record<string, unknown>,
-  reducers: {
-    replaceUiState: (_state, action) => action.payload,
-  },
-});
-
-const reduxStore = configureStore({
-  reducer: { ui: uiSlice.reducer },
-});
-
-const store = reduxStateStore({
-  store: reduxStore,
-  selector: (state) => state.ui,
-  dispatch: (next, s) => s.dispatch(uiSlice.actions.replaceUiState(next)),
-});
-```
-
-```tsx
-<StateProvider store={store}>
-  {/* json-render reads/writes go through Redux */}
-</StateProvider>
-```
-
-## Re-exports
-
-<table>
-  <thead>
-    <tr>
-      <th>Export</th>
-      <th>Source</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>StateStore</code></td>
-      <td><code>@json-render/core</code></td>
-    </tr>
-  </tbody>
-</table>

apps/web/content/docs/api/shadcn-svelte.mdx

@@ -1,319 +0,0 @@
----
-title: "@json-render/shadcn-svelte"
----
-
-Pre-built [shadcn-svelte](https://www.shadcn-svelte.com/) components for json-render. 36 components built on Svelte 5 + Tailwind CSS, ready to use with `defineCatalog` and `defineRegistry`.
-
-## Installation
-
-```bash
-npm install @json-render/shadcn-svelte @json-render/core @json-render/svelte zod
-```
-
-Your app must have Tailwind CSS configured.
-
-## Entry Points
-
-<table>
-<thead>
-<tr>
-<th>Entry Point</th>
-<th>Exports</th>
-<th>Use For</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>@json-render/shadcn-svelte</code></td>
-<td><code>shadcnComponents</code>, <code>shadcnComponentDefinitions</code></td>
-<td>Svelte implementations + catalog schemas</td>
-</tr>
-<tr>
-<td><code>@json-render/shadcn-svelte/catalog</code></td>
-<td><code>shadcnComponentDefinitions</code></td>
-<td>Catalog schemas only (no Svelte dependency, safe for server)</td>
-</tr>
-</tbody>
-</table>
-
-## Usage
-
-Pick the components you need from the standard definitions:
-
-```typescript
-import { defineCatalog } from "@json-render/core";
-import { schema } from "@json-render/svelte/schema";
-import { shadcnComponentDefinitions } from "@json-render/shadcn-svelte/catalog";
-import { defineRegistry } from "@json-render/svelte";
-import { shadcnComponents } from "@json-render/shadcn-svelte";
-
-// Catalog: pick definitions
-const catalog = defineCatalog(schema, {
-  components: {
-    Card: shadcnComponentDefinitions.Card,
-    Stack: shadcnComponentDefinitions.Stack,
-    Heading: shadcnComponentDefinitions.Heading,
-    Button: shadcnComponentDefinitions.Button,
-    Input: shadcnComponentDefinitions.Input,
-  },
-  actions: {},
-});
-
-// Registry: pick matching implementations
-const { registry } = defineRegistry(catalog, {
-  components: {
-    Card: shadcnComponents.Card,
-    Stack: shadcnComponents.Stack,
-    Heading: shadcnComponents.Heading,
-    Button: shadcnComponents.Button,
-    Input: shadcnComponents.Input,
-  },
-});
-```
-
-Then render in your Svelte component:
-
-```svelte
-<script lang="ts">
-  import { Renderer, JsonUIProvider } from "@json-render/svelte";
-
-  export let spec;
-  export let registry;
-</script>
-
-<JsonUIProvider initialState={spec?.state ?? {}}>
-  <Renderer {spec} {registry} />
-</JsonUIProvider>
-```
-
-## Available Components
-
-### Layout
-
-<table>
-<thead>
-<tr>
-<th>Component</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>Card</code></td>
-<td>Container card with optional title, description, maxWidth, centered</td>
-</tr>
-<tr>
-<td><code>Stack</code></td>
-<td>Flex container with direction, gap, align, justify</td>
-</tr>
-<tr>
-<td><code>Grid</code></td>
-<td>Grid layout with columns (1-6) and gap</td>
-</tr>
-<tr>
-<td><code>Separator</code></td>
-<td>Visual separator line with orientation</td>
-</tr>
-</tbody>
-</table>
-
-### Navigation
-
-<table>
-<thead>
-<tr>
-<th>Component</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>Tabs</code></td>
-<td>Tabbed navigation with tabs array, defaultValue, value</td>
-</tr>
-<tr>
-<td><code>Accordion</code></td>
-<td>Collapsible sections with items array and type (single/multiple)</td>
-</tr>
-<tr>
-<td><code>Collapsible</code></td>
-<td>Single collapsible section with title and defaultOpen</td>
-</tr>
-<tr>
-<td><code>Pagination</code></td>
-<td>Page navigation with totalPages and page</td>
-</tr>
-</tbody>
-</table>
-
-### Overlay
-
-<table>
-<thead>
-<tr>
-<th>Component</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>Dialog</code></td>
-<td>Modal dialog with title, description, openPath</td>
-</tr>
-<tr>
-<td><code>Drawer</code></td>
-<td>Bottom drawer with title, description, openPath</td>
-</tr>
-<tr>
-<td><code>Tooltip</code></td>
-<td>Hover tooltip with content and text</td>
-</tr>
-<tr>
-<td><code>Popover</code></td>
-<td>Click-triggered popover with trigger and content</td>
-</tr>
-<tr>
-<td><code>DropdownMenu</code></td>
-<td>Dropdown menu with label and items array</td>
-</tr>
-</tbody>
-</table>
-
-### Content
-
-<table>
-<thead>
-<tr>
-<th>Component</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>Heading</code></td>
-<td>Heading text with level (h1-h4)</td>
-</tr>
-<tr>
-<td><code>Text</code></td>
-<td>Paragraph with variant (body, caption, muted, lead, code)</td>
-</tr>
-<tr>
-<td><code>Image</code></td>
-<td>Image with alt, width, height</td>
-</tr>
-<tr>
-<td><code>Avatar</code></td>
-<td>User avatar with src, name, size</td>
-</tr>
-<tr>
-<td><code>Badge</code></td>
-<td>Status badge with text and variant</td>
-</tr>
-<tr>
-<td><code>Alert</code></td>
-<td>Alert banner with title, message, type</td>
-</tr>
-<tr>
-<td><code>Carousel</code></td>
-<td>Horizontally scrollable carousel with items</td>
-</tr>
-<tr>
-<td><code>Table</code></td>
-<td>Data table with columns and rows</td>
-</tr>
-</tbody>
-</table>
-
-### Feedback
-
-<table>
-<thead>
-<tr>
-<th>Component</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>Progress</code></td>
-<td>Progress bar with value, max, label</td>
-</tr>
-<tr>
-<td><code>Skeleton</code></td>
-<td>Loading placeholder with width, height, rounded</td>
-</tr>
-<tr>
-<td><code>Spinner</code></td>
-<td>Loading spinner with size and label</td>
-</tr>
-</tbody>
-</table>
-
-### Input
-
-<table>
-<thead>
-<tr>
-<th>Component</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>Button</code></td>
-<td>Clickable button with label, variant, disabled</td>
-</tr>
-<tr>
-<td><code>Link</code></td>
-<td>Anchor link with label and href</td>
-</tr>
-<tr>
-<td><code>Input</code></td>
-<td>Text input with label, name, type, placeholder, value, checks</td>
-</tr>
-<tr>
-<td><code>Textarea</code></td>
-<td>Multi-line text input with label, name, placeholder, rows, value, checks</td>
-</tr>
-<tr>
-<td><code>Select</code></td>
-<td>Dropdown select with label, name, options, value, checks</td>
-</tr>
-<tr>
-<td><code>Checkbox</code></td>
-<td>Checkbox with label, name, checked</td>
-</tr>
-<tr>
-<td><code>Radio</code></td>
-<td>Radio button group with label, name, options, value</td>
-</tr>
-<tr>
-<td><code>Switch</code></td>
-<td>Toggle switch with label, name, checked</td>
-</tr>
-<tr>
-<td><code>Slider</code></td>
-<td>Range slider with label, min, max, step, value</td>
-</tr>
-<tr>
-<td><code>Toggle</code></td>
-<td>Toggle button with label, pressed, variant</td>
-</tr>
-<tr>
-<td><code>ToggleGroup</code></td>
-<td>Group of toggle buttons with items, type, value</td>
-</tr>
-<tr>
-<td><code>ButtonGroup</code></td>
-<td>Group of buttons with buttons array and selected</td>
-</tr>
-</tbody>
-</table>
-
-## Notes
-
-- The `/catalog` entry point has no Svelte dependency -- use it for server-side prompt generation
-- Components use Tailwind CSS classes -- your app must have Tailwind configured
-- Component implementations use bundled shadcn-svelte primitives (not your app's `$lib/components/ui/`)
-- Form inputs support `checks` for validation (type + message pairs) and `validateOn` for timing
-- Events: inputs emit `change`/`submit`/`focus`/`blur`; buttons emit `press`; selects emit `change`/`select`

apps/web/content/docs/api/shadcn.mdx

@@ -1,348 +0,0 @@
----
-title: "@json-render/shadcn"
----
-
-Pre-built [shadcn/ui](https://ui.shadcn.com/) components for json-render. 36 components built on Radix UI + Tailwind CSS, ready to use with `defineCatalog` and `defineRegistry`.
-
-## Installation
-
-```bash
-npm install @json-render/shadcn @json-render/core @json-render/react zod
-```
-
-Your app must have Tailwind CSS configured.
-
-## Entry Points
-
-<table>
-<thead>
-<tr>
-<th>Entry Point</th>
-<th>Exports</th>
-<th>Use For</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>@json-render/shadcn</code></td>
-<td><code>shadcnComponents</code></td>
-<td>React implementations</td>
-</tr>
-<tr>
-<td><code>@json-render/shadcn/catalog</code></td>
-<td><code>shadcnComponentDefinitions</code></td>
-<td>Catalog schemas (no React dependency, safe for server)</td>
-</tr>
-</tbody>
-</table>
-
-## Usage
-
-Pick the components you need from the standard definitions:
-
-```typescript
-import { defineCatalog } from "@json-render/core";
-import { schema } from "@json-render/react/schema";
-import { shadcnComponentDefinitions } from "@json-render/shadcn/catalog";
-import { defineRegistry } from "@json-render/react";
-import { shadcnComponents } from "@json-render/shadcn";
-
-// Catalog: pick definitions
-const catalog = defineCatalog(schema, {
-  components: {
-    Card: shadcnComponentDefinitions.Card,
-    Stack: shadcnComponentDefinitions.Stack,
-    Heading: shadcnComponentDefinitions.Heading,
-    Button: shadcnComponentDefinitions.Button,
-    Input: shadcnComponentDefinitions.Input,
-  },
-  actions: {},
-});
-
-// Registry: pick matching implementations
-const { registry } = defineRegistry(catalog, {
-  components: {
-    Card: shadcnComponents.Card,
-    Stack: shadcnComponents.Stack,
-    Heading: shadcnComponents.Heading,
-    Button: shadcnComponents.Button,
-    Input: shadcnComponents.Input,
-  },
-});
-```
-
-State actions (`setState`, `pushState`, `removeState`) are built into the React schema and handled by `ActionProvider` automatically. You don't need to declare them in your catalog.
-
-## Extending with Custom Components
-
-Add custom components alongside standard ones:
-
-```typescript
-import { z } from "zod";
-
-const catalog = defineCatalog(schema, {
-  components: {
-    // Standard
-    Card: shadcnComponentDefinitions.Card,
-    Stack: shadcnComponentDefinitions.Stack,
-    Button: shadcnComponentDefinitions.Button,
-
-    // Custom
-    Metric: {
-      props: z.object({
-        label: z.string(),
-        value: z.string(),
-        trend: z.enum(["up", "down", "neutral"]).nullable(),
-      }),
-      description: "KPI metric display",
-    },
-  },
-  actions: {},
-});
-
-const { registry } = defineRegistry(catalog, {
-  components: {
-    Card: shadcnComponents.Card,
-    Stack: shadcnComponents.Stack,
-    Button: shadcnComponents.Button,
-    Metric: ({ props }) => (
-      <div>
-        <span>{props.label}</span>
-        <span>{props.value}</span>
-      </div>
-    ),
-  },
-});
-```
-
-## Available Components
-
-### Layout
-
-<table>
-<thead>
-<tr>
-<th>Component</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>Card</code></td>
-<td>Container card with optional title, description, maxWidth, centered</td>
-</tr>
-<tr>
-<td><code>Stack</code></td>
-<td>Flex container with direction, gap, align, justify</td>
-</tr>
-<tr>
-<td><code>Grid</code></td>
-<td>Grid layout with columns (1-6) and gap</td>
-</tr>
-<tr>
-<td><code>Separator</code></td>
-<td>Visual separator line with orientation</td>
-</tr>
-</tbody>
-</table>
-
-### Navigation
-
-<table>
-<thead>
-<tr>
-<th>Component</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>Tabs</code></td>
-<td>Tabbed navigation with tabs array, defaultValue, value</td>
-</tr>
-<tr>
-<td><code>Accordion</code></td>
-<td>Collapsible sections with items array and type (single/multiple)</td>
-</tr>
-<tr>
-<td><code>Collapsible</code></td>
-<td>Single collapsible section with title and defaultOpen</td>
-</tr>
-<tr>
-<td><code>Pagination</code></td>
-<td>Page navigation with totalPages and page</td>
-</tr>
-</tbody>
-</table>
-
-### Overlay
-
-<table>
-<thead>
-<tr>
-<th>Component</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>Dialog</code></td>
-<td>Modal dialog with title, description, openPath</td>
-</tr>
-<tr>
-<td><code>Drawer</code></td>
-<td>Bottom drawer with title, description, openPath</td>
-</tr>
-<tr>
-<td><code>Tooltip</code></td>
-<td>Hover tooltip with content and text</td>
-</tr>
-<tr>
-<td><code>Popover</code></td>
-<td>Click-triggered popover with trigger and content</td>
-</tr>
-<tr>
-<td><code>DropdownMenu</code></td>
-<td>Dropdown menu with label and items array</td>
-</tr>
-</tbody>
-</table>
-
-### Content
-
-<table>
-<thead>
-<tr>
-<th>Component</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>Heading</code></td>
-<td>Heading text with level (h1-h4)</td>
-</tr>
-<tr>
-<td><code>Text</code></td>
-<td>Paragraph with variant (body, caption, muted, lead, code)</td>
-</tr>
-<tr>
-<td><code>Image</code></td>
-<td>Image with alt, width, height</td>
-</tr>
-<tr>
-<td><code>Avatar</code></td>
-<td>User avatar with src, name, size</td>
-</tr>
-<tr>
-<td><code>Badge</code></td>
-<td>Status badge with text and variant</td>
-</tr>
-<tr>
-<td><code>Alert</code></td>
-<td>Alert banner with title, message, type</td>
-</tr>
-<tr>
-<td><code>Carousel</code></td>
-<td>Horizontally scrollable carousel with items</td>
-</tr>
-<tr>
-<td><code>Table</code></td>
-<td>Data table with columns and rows</td>
-</tr>
-</tbody>
-</table>
-
-### Feedback
-
-<table>
-<thead>
-<tr>
-<th>Component</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>Progress</code></td>
-<td>Progress bar with value, max, label</td>
-</tr>
-<tr>
-<td><code>Skeleton</code></td>
-<td>Loading placeholder with width, height, rounded</td>
-</tr>
-<tr>
-<td><code>Spinner</code></td>
-<td>Loading spinner with size and label</td>
-</tr>
-</tbody>
-</table>
-
-### Input
-
-<table>
-<thead>
-<tr>
-<th>Component</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><code>Button</code></td>
-<td>Clickable button with label, variant, disabled</td>
-</tr>
-<tr>
-<td><code>Link</code></td>
-<td>Anchor link with label and href</td>
-</tr>
-<tr>
-<td><code>Input</code></td>
-<td>Text input with label, name, type, placeholder, value, checks</td>
-</tr>
-<tr>
-<td><code>Textarea</code></td>
-<td>Multi-line text input with label, name, placeholder, rows, value, checks</td>
-</tr>
-<tr>
-<td><code>Select</code></td>
-<td>Dropdown select with label, name, options, value, checks</td>
-</tr>
-<tr>
-<td><code>Checkbox</code></td>
-<td>Checkbox with label, name, checked</td>
-</tr>
-<tr>
-<td><code>Radio</code></td>
-<td>Radio button group with label, name, options, value</td>
-</tr>
-<tr>
-<td><code>Switch</code></td>
-<td>Toggle switch with label, name, checked</td>
-</tr>
-<tr>
-<td><code>Slider</code></td>
-<td>Range slider with label, min, max, step, value</td>
-</tr>
-<tr>
-<td><code>Toggle</code></td>
-<td>Toggle button with label, pressed, variant</td>
-</tr>
-<tr>
-<td><code>ToggleGroup</code></td>
-<td>Group of toggle buttons with items, type, value</td>
-</tr>
-<tr>
-<td><code>ButtonGroup</code></td>
-<td>Group of buttons with buttons array and selected</td>
-</tr>
-</tbody>
-</table>
-
-## Notes
-
-- The `/catalog` entry point has no React dependency -- use it for server-side prompt generation
-- Components use Tailwind CSS classes -- your app must have Tailwind configured
-- Component implementations use bundled shadcn/ui primitives (not your app's `components/ui/`)
-- Form inputs support `checks` for validation (type + message pairs)
-- Events: inputs emit `change`/`submit`/`focus`/`blur`; buttons emit `press`; selects emit `change`/`select`

apps/web/content/docs/api/solid.mdx

@@ -1,200 +0,0 @@
----
-title: "@json-render/solid"
----
-
-SolidJS components, providers, and hooks for rendering json-render specs.
-
-## Installation
-
-<PackageInstall packages="@json-render/core @json-render/solid" />
-
-Peer dependencies: `solid-js ^1.9.0` and `zod ^4.0.0`.
-
-<PackageInstall packages="solid-js zod" />
-
-## Providers
-
-### StateProvider
-
-```tsx
-<StateProvider
-  initialState={{}}
-  onStateChange={(changes) => console.log(changes)}
->
-  {/* children */}
-</StateProvider>
-```
-
-<table>
-  <thead>
-    <tr>
-      <th>Prop</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>
-        <code>store</code>
-      </td>
-      <td>
-        <code>StateStore</code>
-      </td>
-      <td>
-        External store (controlled mode). When provided,{" "}
-        <code>initialState</code> and <code>onStateChange</code> are ignored.
-      </td>
-    </tr>
-    <tr>
-      <td>
-        <code>initialState</code>
-      </td>
-      <td>
-        <code>Record&lt;string, unknown&gt;</code>
-      </td>
-      <td>Initial state model for uncontrolled mode.</td>
-    </tr>
-    <tr>
-      <td>
-        <code>onStateChange</code>
-      </td>
-      <td>
-        <code>
-          {"(changes: Array<{ path: string; value: unknown }>) => void"}
-        </code>
-      </td>
-      <td>Called for uncontrolled state updates.</td>
-    </tr>
-  </tbody>
-</table>
-
-### ActionProvider
-
-```tsx
-<ActionProvider
-  handlers={{ submit: async (params) => {} }}
-  navigate={(path) => {}}
->
-  {/* children */}
-</ActionProvider>
-```
-
-### VisibilityProvider
-
-```tsx
-<VisibilityProvider>{/* children */}</VisibilityProvider>
-```
-
-### ValidationProvider
-
-```tsx
-<ValidationProvider customFunctions={{ custom: (value) => Boolean(value) }}>
-  {/* children */}
-</ValidationProvider>
-```
-
-### JSONUIProvider
-
-Combined provider wrapper for state, visibility, validation, and actions.
-
-```tsx
-<JSONUIProvider
-  registry={registry}
-  initialState={{}}
-  handlers={handlers}
-  validationFunctions={validationFunctions}
->
-  <Renderer spec={spec} registry={registry} />
-</JSONUIProvider>
-```
-
-## defineRegistry
-
-Create a typed component registry and action helpers from a catalog.
-
-```tsx
-const { registry, handlers, executeAction } = defineRegistry(catalog, {
-  components: {
-    Card: (renderProps) => <div>{renderProps.children}</div>,
-    Button: (renderProps) => (
-      <button onClick={() => renderProps.emit("press")}>
-        {renderProps.element.props.label as string}
-      </button>
-    ),
-  },
-  actions: {
-    submit: async (params, setState, state) => {
-      // custom action logic
-    },
-  },
-});
-```
-
-## Components
-
-### Renderer
-
-```tsx
-<Renderer spec={spec} registry={registry} loading={false} />
-```
-
-Renders a `Spec` tree using your registry.
-
-### createRenderer
-
-Build an app-level renderer from catalog + components:
-
-```tsx
-const AppRenderer = createRenderer(catalog, {
-  Card: (renderProps) => <div>{renderProps.children}</div>,
-});
-
-<AppRenderer spec={spec} state={{}} onAction={(name, params) => {}} />;
-```
-
-## Hooks
-
-- `useStateStore()`
-- `useStateValue(path)` - returns an accessor
-- `useStateBinding(path)` - returns `[Accessor<T | undefined>, setValue]`
-- `useVisibility()` / `useIsVisible(condition)`
-- `useActions()` / `useAction(binding)`
-- `useValidation()` / `useOptionalValidation()`
-- `useFieldValidation(path, config)` - returns accessor-backed `state`, `errors`, and `isValid`
-- `useBoundProp(value, bindingPath)`
-- `useUIStream(options)`
-- `useChatUI(options)`
-
-## Built-in Actions
-
-`ActionProvider` handles these built-in actions:
-
-- `setState`
-- `pushState`
-- `removeState`
-- `validateForm`
-
-## Component Props
-
-Registry components receive:
-
-```ts
-interface ComponentRenderProps<P = Record<string, unknown>> {
-  element: UIElement<string, P>;
-  children?: JSX.Element;
-  emit: (event: string) => void;
-  on: (event: string) => EventHandle;
-  bindings?: Record<string, string>;
-  loading?: boolean;
-}
-```
-
-Use `emit("event")` to dispatch event bindings. Use `on("event")` to access `EventHandle` metadata (`bound`, `shouldPreventDefault`, `emit`).
-
-## Reactivity Notes
-
-- Keep changing reads in JSX expressions, `createMemo`, or `createEffect`.
-- Avoid props destructuring in component signatures when you need live updates.
-- `StateProvider` and other contexts expose getter-backed values so consumers read live signals.
-- `useStateValue`, `useStateBinding`, and `useFieldValidation` expose reactive accessors; call them as functions.

apps/web/content/docs/api/svelte.mdx

@@ -1,125 +0,0 @@
----
-title: "@json-render/svelte"
----
-
-Svelte 5 components, providers, and helpers for rendering json-render specs.
-
-## Installation
-
-<PackageInstall packages="@json-render/core @json-render/svelte" />
-
-Peer dependencies: `svelte ^5.0.0` and `zod ^4.0.0`.
-
-<PackageInstall packages="svelte zod" />
-
-## Components
-
-### Renderer
-
-```svelte
-<Renderer
-  spec={spec}       // Spec | null
-  registry={registry}
-  loading={false}
-/>
-```
-
-Renders a spec with your component registry. If `spec` is `null`, it renders nothing.
-
-### JsonUIProvider
-
-Convenience wrapper around `StateProvider`, `VisibilityProvider`, `ValidationProvider`, and `ActionProvider`.
-
-```svelte
-<JsonUIProvider
-  initialState={{}}
-  handlers={handlers}
-  validationFunctions={validationFunctions}
->
-  <Renderer {spec} {registry} />
-</JsonUIProvider>
-```
-
-## defineRegistry
-
-Create a typed component registry and action handlers from a catalog.
-
-```typescript
-import { defineRegistry } from "@json-render/svelte";
-
-const { registry, handlers, executeAction } = defineRegistry(catalog, {
-  components: {
-    Card,
-    Button,
-  },
-  actions: {
-    submit: async (params, setState, state) => {
-      // custom action logic
-    },
-  },
-});
-```
-
-`handlers` is designed for `JsonUIProvider`/`ActionProvider`. `executeAction` is an imperative helper.
-
-## Component Props
-
-Registry components receive `BaseComponentProps<TProps>`:
-
-```typescript
-interface BaseComponentProps<TProps> {
-  props: TProps;
-  children?: Snippet;
-  emit: (event: string) => void;
-  bindings?: Record<string, string>;
-  loading?: boolean;
-}
-```
-
-Use `emit("eventName")` to trigger handlers declared in the spec `on` bindings.
-
-## Context Helpers
-
-Use these helpers inside Svelte components:
-
-- `getStateValue(path)` - read/write state via `.current`
-- `getBoundProp(() => value, () => bindingPath)` - write back resolved `$bindState` / `$bindItem` values
-- `isVisible(condition)` - evaluate visibility via `.current`
-- `getAction(name)` - read a registered action handler via `.current`
-- `getFieldValidation(ctx, path, config)` - get field validation state + actions
-
-For advanced usage, access full contexts:
-
-- `getStateContext()`
-- `getActionContext()`
-- `getVisibilityContext()`
-- `getValidationContext()`
-- `getOptionalValidationContext()`
-
-## Streaming
-
-### createUIStream
-
-```typescript
-const stream = createUIStream({
-  api: "/api/generate-ui",
-  onComplete: (spec) => console.log(spec),
-});
-
-await stream.send("Create a login form");
-
-console.log(stream.spec);
-console.log(stream.isStreaming);
-```
-
-### createChatUI
-
-```typescript
-const chat = createChatUI({ api: "/api/chat-ui" });
-await chat.send("Build a settings panel");
-console.log(chat.messages, chat.isStreaming);
-```
-
-## Schema Export
-
-Use `schema` from `@json-render/svelte` when defining catalogs for Svelte specs.

apps/web/content/docs/api/tanstack-start.mdx

@@ -1,391 +0,0 @@
----
-title: "@json-render/tanstack-start"
----
-
-TanStack Start renderer for JSON-defined applications with routes, layouts,
-head metadata, SSR loaders, prerender paths, and client navigation.
-
-## Installation
-
-```bash
-npm install @json-render/core @json-render/react @json-render/tanstack-start
-```
-
-## schema
-
-Use the Start application schema to generate full multi-page specs.
-
-```typescript
-import { defineCatalog } from "@json-render/core";
-import {
-  schema,
-  startComponentDefinitions,
-} from "@json-render/tanstack-start/server";
-import { z } from "zod";
-
-const catalog = defineCatalog(schema, {
-  components: {
-    ...startComponentDefinitions,
-    Card: {
-      props: z.object({ title: z.string() }),
-      description: "Card container",
-    },
-    NavBar: {
-      props: z.object({}),
-      slots: ["default"],
-      description: "Application navigation",
-    },
-  },
-  actions: {},
-});
-```
-
-The generation prompt teaches TanStack Router's `$param` and `$` splat route
-syntax, reusable layouts, escaped JSON Patch route keys, and the built-in
-`Slot`, `Link`, and `navigate` capabilities.
-
-Include `startComponentDefinitions` in the catalog so generated `Slot` and
-`Link` elements pass validation. `PageRenderer` supplies their React
-implementations automatically.
-
-## createStartApp
-
-Create helpers for a TanStack Start splat route.
-
-```typescript
-import { createStartApp } from "@json-render/tanstack-start/server";
-
-export const { getPageData, getHead, getStaticPaths } = createStartApp({
-  spec,
-  loaders: {
-    post: async ({ slug }) => ({
-      post: await getPost(slug as string),
-    }),
-  },
-});
-```
-
-### Options
-
-<table>
-  <thead>
-    <tr>
-      <th>Option</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>
-        <code>spec</code>
-      </td>
-      <td>
-        <code>
-          {"StartAppSpec | (() => StartAppSpec | Promise<StartAppSpec>)"}
-        </code>
-      </td>
-      <td>A static application spec or an async spec factory</td>
-    </tr>
-    <tr>
-      <td>
-        <code>loaders</code>
-      </td>
-      <td>
-        <code>{"Record<string, LoaderFn>"}</code>
-      </td>
-      <td>Named data loaders referenced by route specs</td>
-    </tr>
-  </tbody>
-</table>
-
-### Returns
-
-<table>
-  <thead>
-    <tr>
-      <th>Helper</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>
-        <code>getPageData</code>
-      </td>
-      <td>
-        Matches a pathname, runs its loader, and returns serializable page and
-        layout data
-      </td>
-    </tr>
-    <tr>
-      <td>
-        <code>getHead</code>
-      </td>
-      <td>
-        Returns TanStack Router <code>meta</code> and <code>links</code>{" "}
-        descriptors
-      </td>
-    </tr>
-    <tr>
-      <td>
-        <code>getStaticPaths</code>
-      </td>
-      <td>Returns concrete paths for TanStack Start prerendering</td>
-    </tr>
-  </tbody>
-</table>
-
-State is merged in this order: application state, layout state, page state,
-then loader data. Later sources override earlier values.
-
-## StartAppSpec
-
-```typescript
-interface StartAppSpec {
-  metadata?: StartMetadata;
-  routes: Record<string, StartRouteSpec>;
-  layouts?: Record<string, Spec>;
-  state?: Record<string, unknown>;
-}
-```
-
-Each route requires a `page` spec and can select a layout, metadata, a named
-loader, loading/error/not-found specs, and static parameters.
-
-### Route Patterns
-
-<table>
-  <thead>
-    <tr>
-      <th>Pattern</th>
-      <th>Example</th>
-      <th>Params</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>
-        <code>/</code>
-      </td>
-      <td>
-        <code>/</code>
-      </td>
-      <td>
-        <code>{"{}"}</code>
-      </td>
-    </tr>
-    <tr>
-      <td>
-        <code>/about</code>
-      </td>
-      <td>
-        <code>/about</code>
-      </td>
-      <td>
-        <code>{"{}"}</code>
-      </td>
-    </tr>
-    <tr>
-      <td>
-        <code>{"/blog/$slug"}</code>
-      </td>
-      <td>
-        <code>/blog/hello</code>
-      </td>
-      <td>
-        <code>{'{ slug: "hello" }'}</code>
-      </td>
-    </tr>
-    <tr>
-      <td>
-        <code>{"/docs/$"}</code>
-      </td>
-      <td>
-        <code>/docs/guides/intro</code>
-      </td>
-      <td>
-        <code>{'{ _splat: "guides/intro" }'}</code>
-      </td>
-    </tr>
-  </tbody>
-</table>
-
-Loader parameters are URL-decoded before they reach named loaders. Splat
-content is a slash-delimited string under `_splat`. Parameter values supplied
-through `staticParams` are URL-encoded in the paths returned by
-`getStaticPaths()`.
-
-Route matching treats trailing slashes as optional and accepts both encoded and
-decoded pathname representations. This keeps loader data and route metadata in
-sync for static paths containing spaces or non-ASCII characters.
-
-For prerendered dynamic routes, provide `staticParams`:
-
-```typescript
-routes: {
-  '/blog/$slug': {
-    page,
-    staticParams: [{ slug: 'hello' }, { slug: 'world' }],
-  },
-  '/docs/$': {
-    page: docsPage,
-    staticParams: [{ _splat: 'guides/intro' }],
-  },
-}
-```
-
-Map `getStaticPaths()` into TanStack Start's top-level `pages` configuration:
-
-```typescript
-const pages = (await getStaticPaths()).map((path) => ({ path }));
-```
-
-## TanStack Route Setup
-
-Wire the helpers to a file-based `$` splat route:
-
-```tsx
-// src/routes/$.tsx
-import { createFileRoute, notFound } from "@tanstack/react-router";
-import {
-  PageRenderer,
-  StartErrorBoundary,
-  StartLoading,
-  StartNotFound,
-} from "@json-render/tanstack-start";
-import { getHead, getPageData } from "@/lib/json-app";
-
-export const Route = createFileRoute("/$")({
-  loader: async ({ location }) => {
-    const data = await getPageData({ pathname: location.pathname });
-    if (!data) throw notFound();
-    return data;
-  },
-  head: ({ match }) => getHead({ pathname: match.pathname }),
-  component: Page,
-  pendingComponent: StartLoading,
-  errorComponent: StartErrorBoundary,
-  notFoundComponent: StartNotFound,
-});
-
-function Page() {
-  return <PageRenderer {...Route.useLoaderData()} />;
-}
-```
-
-TanStack Router loaders are isomorphic. When a spec factory or named loader
-uses database clients, credentials, or server-only imports, invoke
-`getPageData` and `getHead` inside a TanStack Start `createServerFn` and call
-that server function from the route loader.
-
-## StartAppProvider
-
-Provide component implementations and action handlers around the root
-`Outlet`. Render `HeadContent` for route metadata.
-
-```tsx
-import {
-  createRootRoute,
-  HeadContent,
-  Outlet,
-  Scripts,
-} from "@tanstack/react-router";
-import { StartAppProvider } from "@json-render/tanstack-start";
-import { spec } from "@/lib/spec";
-
-export const Route = createRootRoute({
-  component: () => (
-    <html lang="en">
-      <head>
-        <HeadContent />
-      </head>
-      <body>
-        <StartAppProvider
-          registry={registry}
-          handlers={handlers}
-          spec={spec}
-        >
-          <Outlet />
-        </StartAppProvider>
-        <Scripts />
-      </body>
-    </html>
-  ),
-});
-```
-
-Passing `spec` lets `StartLoading`, `StartErrorBoundary`, and `StartNotFound`
-automatically select the matched route's fallback specs. Their explicit
-`loadingSpec`, `errorSpec`, and `notFoundSpec` props take precedence. For a
-server-only application spec, omit `spec` and pass client-safe fallback specs
-explicitly.
-
-Pass named functions through `functions` when props use `$computed`:
-
-```tsx
-<StartAppProvider
-  registry={registry}
-  spec={spec}
-  functions={{ uppercase: ({ value }) => String(value).toUpperCase() }}
->
-  <Outlet />
-</StartAppProvider>
-```
-
-## Built-ins
-
-- `Slot` inserts page content into a JSON-defined layout.
-- `Link` wraps TanStack Router's `Link`; generated specs use an `href` prop.
-- `navigate` performs client-side navigation from action bindings.
-- `StartLoading`, `StartErrorBoundary`, and `StartNotFound` resolve the matched
-  route's fallback specs when they are used as TanStack Router boundary
-  components and the provider receives `spec`.
-
-The default `StartErrorBoundary` fallback invalidates the router and reruns the
-failed loader when the user selects **Try again**.
-
-`Slot` and `Link` are automatically added to the page registry.
-
-## Server Utilities
-
-```typescript
-import {
-  collectStaticPaths,
-  matchRoute,
-  metadataToHead,
-  resolveMetadata,
-  splatToPath,
-} from "@json-render/tanstack-start/server";
-```
-
-## Entry Points
-
-<table>
-  <thead>
-    <tr>
-      <th>Import</th>
-      <th>Contents</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>
-        <code>@json-render/tanstack-start</code>
-      </td>
-      <td>Provider, page renderer, Link, and route fallback components</td>
-    </tr>
-    <tr>
-      <td>
-        <code>@json-render/tanstack-start/server</code>
-      </td>
-      <td>App factory, schema, matcher, metadata, and prerender helpers</td>
-    </tr>
-    <tr>
-      <td>
-        <code>@json-render/tanstack-start/catalog</code>
-      </td>
-      <td>Server-safe definitions for built-in Slot and Link components</td>
-    </tr>
-  </tbody>
-</table>

apps/web/content/docs/api/vue.mdx

@@ -1,357 +0,0 @@
----
-title: "@json-render/vue"
----
-
-Vue 3 components, providers, and composables.
-
-## Providers
-
-### StateProvider
-
-```vue
-<StateProvider :initial-state="object" :on-state-change="fn">
-  <!-- children -->
-</StateProvider>
-```
-
-<table>
-  <thead>
-    <tr>
-      <th>Prop</th>
-      <th>Type</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>store</code></td>
-      <td><code>StateStore</code></td>
-      <td>External store (controlled mode). When provided, <code>initialState</code> and <code>onStateChange</code> are ignored.</td>
-    </tr>
-    <tr>
-      <td><code>initialState</code></td>
-      <td><code>Record&lt;string, unknown&gt;</code></td>
-      <td>Initial state model (uncontrolled mode).</td>
-    </tr>
-    <tr>
-      <td><code>onStateChange</code></td>
-      <td><code>{'(changes: Array<{ path: string; value: unknown }>) => void'}</code></td>
-      <td>Callback when state changes (uncontrolled mode). Called once per <code>set</code> or <code>update</code> with all changed entries.</td>
-    </tr>
-  </tbody>
-</table>
-
-#### External Store (Controlled Mode)
-
-Pass a `StateStore` to bypass the internal state and wire json-render to any state management library:
-
-```typescript
-import { createStateStore, type StateStore } from "@json-render/vue";
-
-const store = createStateStore({ count: 0 });
-```
-
-```vue
-<StateProvider :store="store">
-  <!-- children -->
-</StateProvider>
-```
-
-```typescript
-// Mutate from anywhere — Vue re-renders automatically:
-store.set("/count", 1);
-```
-
-### ActionProvider
-
-```vue
-<ActionProvider :handlers="Record<string, ActionHandler>" :navigate="fn">
-  <!-- children -->
-</ActionProvider>
-
-// type ActionHandler = (params: Record<string, unknown>) => void | Promise<void>;
-```
-
-### VisibilityProvider
-
-```vue
-<VisibilityProvider>
-  <!-- children -->
-</VisibilityProvider>
-```
-
-`VisibilityProvider` reads state from the parent `StateProvider` automatically. Conditions in specs use the `VisibilityCondition` format with `$state` paths (e.g. `{ "$state": "/path" }`, `{ "$state": "/path", "eq": value }`). See [visibility](/docs/visibility) for the full syntax.
-
-### ValidationProvider
-
-```vue
-<ValidationProvider :custom-functions="Record<string, ValidationFunction>">
-  <!-- children -->
-</ValidationProvider>
-
-// type ValidationFunction = (value: unknown, args?: object) => boolean | Promise<boolean>;
-```
-
-## defineRegistry
-
-Create a type-safe component registry from a catalog. Components receive `props`, `children`, `slots`, `emit`, `on`, and `loading` with catalog-inferred types.
-
-When the catalog declares actions, the `actions` field is required. When the catalog has no actions (e.g. `actions: {}`), the field is optional. When passing stubs, any `async () => {}` is sufficient.
-
-```typescript
-import { h } from "vue";
-import { defineRegistry } from "@json-render/vue";
-
-const { registry } = defineRegistry(catalog, {
-  components: {
-    Layout: ({ slots }) =>
-      h("div", { class: "layout" }, [
-        h("header", null, slots.header?.()),
-        h("main", null, slots.default?.()),
-        h("footer", null, slots.footer?.()),
-      ]),
-    Button: ({ props, emit }) =>
-      h("button", { onClick: () => emit("press") }, props.label),
-  },
-  // Required when catalog declares actions:
-  actions: {
-    submit: async (params) => { /* ... */ },
-  },
-});
-
-// Pass to <Renderer>
-// <Renderer :spec="spec" :registry="registry" />
-```
-
-## Components
-
-### Renderer
-
-```vue
-<Renderer
-  :spec="Spec"           // The UI spec to render
-  :registry="Registry"   // Component registry (from defineRegistry)
-  :loading="boolean"     // Optional loading state
-  :fallback="Component"  // Optional fallback for unknown types
-/>
-```
-
-### Component Props (via defineRegistry)
-
-```typescript
-import type { Slots, VNode } from "vue";
-
-interface ComponentContext<P> {
-  props: P;                          // Typed props from catalog
-  children?: VNode | VNode[];        // Rendered children (for container components)
-  slots: Slots;                      // Vue-native slot functions
-  emit: (event: string) => void;     // Emit a named event (always defined)
-  on: (event: string) => EventHandle; // Get event handle with metadata
-  loading?: boolean;
-  bindings?: Record<string, string>; // State paths from $bindState/$bindItem expressions
-}
-
-interface EventHandle {
-  emit: () => void;              // Fire the event
-  shouldPreventDefault: boolean; // Whether any binding requested preventDefault
-  bound: boolean;                // Whether any handler is bound
-}
-```
-
-Use `children` for the default slot. For other slots declared by the catalog, add a top-level `slots` map to the spec element:
-
-```json
-{
-  "type": "Layout",
-  "props": {},
-  "children": ["main-content"],
-  "slots": {
-    "header": ["page-heading"],
-    "footer": ["page-actions"]
-  }
-}
-```
-
-The component renders these regions with Vue's native slot functions: `slots.header?.()`, `slots.footer?.()`, and so on. `slots.default?.()` renders the spec's `children`; `children` is a convenience alias for that rendered result. In the JSON spec, keep default content in `children` rather than adding a `default` entry to `slots`.
-
-Use `emit("press")` for simple event firing. Use `on("click")` when you need metadata like `shouldPreventDefault`:
-
-```typescript
-Link: ({ props, on }) => {
-  const click = on("click");
-  return h("a", {
-    href: props.href,
-    onClick: (e: MouseEvent) => {
-      if (click.shouldPreventDefault) e.preventDefault();
-      click.emit();
-    },
-  }, props.label);
-},
-```
-
-### BaseComponentProps
-
-Catalog-agnostic base type for building reusable component libraries that are not tied to a specific catalog:
-
-```typescript
-import type { BaseComponentProps } from "@json-render/vue";
-
-const Card = ({ props, children }: BaseComponentProps<{ title?: string }>) =>
-  h("div", null, [props.title, children]);
-```
-
-## Composables
-
-### useStateStore
-
-```typescript
-const {
-  state,   // ShallowRef<StateModel> — access with state.value
-  get,     // (path: string) => unknown
-  set,     // (path: string, value: unknown) => void
-  update,  // (updates: Record<string, unknown>) => void
-} = useStateStore();
-```
-
-> **Note:** `state` is a `ShallowRef<StateModel>`, not a plain object. Use `state.value` to read the current state. This differs from the React renderer.
-
-### useStateValue
-
-```typescript
-const value = useStateValue(path: string); // ComputedRef<T | undefined>
-```
-
-Returns a `ComputedRef` that automatically updates when the state at `path` changes. Use `.value` to access the current value.
-
-### useStateBinding (deprecated)
-
-> **Deprecated.** Use `$bindState` expressions with `bindings` prop instead.
-
-```typescript
-const [value, setValue] = useStateBinding(path: string);
-// value: ComputedRef<T | undefined>
-// setValue: (value: T) => void
-```
-
-### useActions
-
-```typescript
-const { execute } = useActions();
-// execute(binding: ActionBinding) => Promise<void>
-```
-
-### useAction
-
-```typescript
-const { execute, isLoading } = useAction(binding: ActionBinding);
-// execute: () => Promise<void>
-// isLoading: ComputedRef<boolean>
-```
-
-### useIsVisible
-
-```typescript
-const isVisible = useIsVisible(condition?: VisibilityCondition);
-```
-
-### useFieldValidation
-
-```typescript
-const {
-  state,     // ComputedRef<FieldValidationState>
-  validate,  // () => ValidationResult
-  touch,     // () => void
-  clear,     // () => void
-  errors,    // ComputedRef<string[]>
-  isValid,   // ComputedRef<boolean>
-} = useFieldValidation(path: string, config?: ValidationConfig);
-```
-
-`ValidationConfig` is `{ checks?: ValidationCheck[], validateOn?: 'change' | 'blur' | 'submit' }`.
-
-## Differences from `@json-render/react`
-
-<table>
-  <thead>
-    <tr>
-      <th>API</th>
-      <th>React</th>
-      <th>Vue</th>
-      <th>Note</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>useStateStore().state</code></td>
-      <td><code>StateModel</code> (plain object)</td>
-      <td><code>ShallowRef&lt;StateModel&gt;</code></td>
-      <td>Vue reactivity; use <code>state.value</code></td>
-    </tr>
-    <tr>
-      <td><code>useStateValue()</code></td>
-      <td><code>T | undefined</code></td>
-      <td><code>ComputedRef&lt;T | undefined&gt;</code></td>
-      <td>Vue reactivity; use <code>.value</code></td>
-    </tr>
-    <tr>
-      <td><code>useStateBinding()</code></td>
-      <td><code>[T | undefined, setter]</code></td>
-      <td><code>[ComputedRef&lt;T | undefined&gt;, setter]</code></td>
-      <td>Vue reactivity; use <code>value.value</code></td>
-    </tr>
-    <tr>
-      <td><code>useAction().isLoading</code></td>
-      <td><code>boolean</code></td>
-      <td><code>ComputedRef&lt;boolean&gt;</code></td>
-      <td>Vue reactivity; use <code>.value</code></td>
-    </tr>
-    <tr>
-      <td><code>useFieldValidation().state</code></td>
-      <td><code>FieldValidationState</code></td>
-      <td><code>ComputedRef&lt;FieldValidationState&gt;</code></td>
-      <td>Vue reactivity; use <code>.value</code></td>
-    </tr>
-    <tr>
-      <td><code>useFieldValidation().errors</code></td>
-      <td><code>string[]</code></td>
-      <td><code>ComputedRef&lt;string[]&gt;</code></td>
-      <td>Vue reactivity; use <code>.value</code></td>
-    </tr>
-    <tr>
-      <td><code>useFieldValidation().isValid</code></td>
-      <td><code>boolean</code></td>
-      <td><code>ComputedRef&lt;boolean&gt;</code></td>
-      <td>Vue reactivity; use <code>.value</code></td>
-    </tr>
-    <tr>
-      <td><code>VisibilityContextValue.ctx</code></td>
-      <td><code>CoreVisibilityContext</code></td>
-      <td><code>ComputedRef&lt;CoreVisibilityContext&gt;</code></td>
-      <td>Vue reactivity; use <code>ctx.value</code></td>
-    </tr>
-    <tr>
-      <td><code>children</code> type</td>
-      <td><code>React.ReactNode</code></td>
-      <td><code>VNode | VNode[]</code></td>
-      <td>Platform-specific</td>
-    </tr>
-    <tr>
-      <td><code>useBoundProp</code></td>
-      <td>exported</td>
-      <td>exported</td>
-      <td>Same API; returns <code>[value, setValue]</code></td>
-    </tr>
-    <tr>
-      <td><code>VisibilityProviderProps</code></td>
-      <td>exported</td>
-      <td>not exported (no props)</td>
-      <td>Vue uses slot, no prop needed</td>
-    </tr>
-    <tr>
-      <td>Streaming hooks</td>
-      <td><code>useUIStream</code>, <code>useChatUI</code></td>
-      <td><code>useUIStream</code>, <code>useChatUI</code></td>
-      <td>Same API; returns Vue <code>Ref</code> values</td>
-    </tr>
-  </tbody>
-</table>

apps/web/content/docs/api/xstate.mdx

@@ -1,76 +0,0 @@
----
-title: "@json-render/xstate"
----
-
-[XState Store](https://stately.ai/docs/xstate-store) adapter for json-render's `StateStore` interface.
-
-Requires `@xstate/store` v3+.
-
-## Installation
-
-```bash
-npm install @json-render/xstate @json-render/core @json-render/react @xstate/store
-```
-
-## xstateStoreStateStore
-
-Create a `StateStore` backed by an `@xstate/store` atom.
-
-```typescript
-import { xstateStoreStateStore } from "@json-render/xstate";
-```
-
-### Options
-
-<table>
-  <thead>
-    <tr>
-      <th>Option</th>
-      <th>Type</th>
-      <th>Required</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>atom</code></td>
-      <td><code>{'Atom<StateModel>'}</code></td>
-      <td>Yes</td>
-      <td>An <code>@xstate/store</code> atom (from <code>createAtom</code>) holding the json-render state model.</td>
-    </tr>
-  </tbody>
-</table>
-
-### Example
-
-```typescript
-import { createAtom } from "@xstate/store";
-import { xstateStoreStateStore } from "@json-render/xstate";
-import { StateProvider } from "@json-render/react";
-
-const uiAtom = createAtom({ count: 0 });
-const store = xstateStoreStateStore({ atom: uiAtom });
-```
-
-```tsx
-<StateProvider store={store}>
-  {/* json-render reads/writes go through @xstate/store */}
-</StateProvider>
-```
-
-## Re-exports
-
-<table>
-  <thead>
-    <tr>
-      <th>Export</th>
-      <th>Source</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>StateStore</code></td>
-      <td><code>@json-render/core</code></td>
-    </tr>
-  </tbody>
-</table>

apps/web/content/docs/api/yaml.mdx

@@ -1,231 +0,0 @@
----
-title: "@json-render/yaml"
----
-
-YAML wire format for json-render. Progressive rendering and surgical edits via streaming YAML.
-
-## Prompt Generation
-
-### yamlPrompt
-
-Generate a YAML-format system prompt from any json-render catalog. Works with catalogs from any renderer.
-
-```typescript
-function yamlPrompt(
-  catalog: Catalog,
-  options?: YamlPromptOptions
-): string
-```
-
-```typescript
-import { yamlPrompt } from "@json-render/yaml";
-
-const systemPrompt = yamlPrompt(catalog, {
-  mode: "standalone",
-  customRules: ["Always use dark theme"],
-  editModes: ["merge"],
-});
-```
-
-### YamlPromptOptions
-
-<table>
-  <thead>
-    <tr>
-      <th>Option</th>
-      <th>Type</th>
-      <th>Default</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>system</code></td>
-      <td><code>string</code></td>
-      <td><code>{'\"You are a UI generator that outputs YAML.\"'}</code></td>
-      <td>Custom system message intro</td>
-    </tr>
-    <tr>
-      <td><code>mode</code></td>
-      <td><code>{'\"standalone\" | \"inline\"'}</code></td>
-      <td><code>{'\"standalone\"'}</code></td>
-      <td>Standalone outputs only YAML; inline allows conversational responses with embedded YAML fences</td>
-    </tr>
-    <tr>
-      <td><code>customRules</code></td>
-      <td><code>{'string[]'}</code></td>
-      <td><code>{'[]'}</code></td>
-      <td>Additional rules appended to the prompt</td>
-    </tr>
-    <tr>
-      <td><code>editModes</code></td>
-      <td><code>{'EditMode[]'}</code></td>
-      <td><code>{'[\"merge\"]'}</code></td>
-      <td>Edit modes to document in the prompt (patch, merge, diff)</td>
-    </tr>
-  </tbody>
-</table>
-
-## AI SDK Transform
-
-### createYamlTransform
-
-Creates a `TransformStream` that intercepts AI SDK stream chunks and converts YAML spec/edit blocks into json-render patch data parts.
-
-```typescript
-function createYamlTransform(
-  options?: YamlTransformOptions
-): TransformStream<StreamChunk, StreamChunk>
-```
-
-Recognized fence types:
-
-- <code>{'```yaml-spec'}</code> -- Full YAML spec, parsed progressively
-- <code>{'```yaml-edit'}</code> -- Partial YAML, deep-merged with current spec
-- <code>{'```yaml-patch'}</code> -- RFC 6902 JSON Patch lines
-- <code>{'```diff'}</code> -- Unified diff against serialized spec
-
-### pipeYamlRender
-
-Convenience wrapper that pipes an AI SDK stream through the YAML transform. Drop-in replacement for `pipeJsonRender` from `@json-render/core`.
-
-```typescript
-function pipeYamlRender<T>(
-  stream: ReadableStream<T>,
-  options?: YamlTransformOptions
-): ReadableStream<T>
-```
-
-```typescript
-import { pipeYamlRender } from "@json-render/yaml";
-import { createUIMessageStream, createUIMessageStreamResponse } from "ai";
-
-const stream = createUIMessageStream({
-  execute: async ({ writer }) => {
-    writer.merge(pipeYamlRender(result.toUIMessageStream()));
-  },
-});
-return createUIMessageStreamResponse({ stream });
-```
-
-## Streaming Parser
-
-### createYamlStreamCompiler
-
-Create a streaming YAML compiler that incrementally parses YAML text and emits JSON Patch operations by diffing each successful parse against the previous snapshot.
-
-```typescript
-function createYamlStreamCompiler<T>(
-  initial?: Partial<T>
-): YamlStreamCompiler<T>
-```
-
-```typescript
-import { createYamlStreamCompiler } from "@json-render/yaml";
-
-const compiler = createYamlStreamCompiler<Spec>();
-
-compiler.push("root: main\n");
-compiler.push("elements:\n  main:\n    type: Card\n");
-
-const { result, newPatches } = compiler.flush();
-```
-
-### YamlStreamCompiler
-
-<table>
-  <thead>
-    <tr>
-      <th>Method</th>
-      <th>Returns</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>push(chunk)</code></td>
-      <td><code>{'{ result: T; newPatches: JsonPatch[] }'}</code></td>
-      <td>Push a chunk of text, returns current result and new patches</td>
-    </tr>
-    <tr>
-      <td><code>flush()</code></td>
-      <td><code>{'{ result: T; newPatches: JsonPatch[] }'}</code></td>
-      <td>Flush remaining buffer, return final result</td>
-    </tr>
-    <tr>
-      <td><code>getResult()</code></td>
-      <td><code>T</code></td>
-      <td>Get the current compiled result</td>
-    </tr>
-    <tr>
-      <td><code>getPatches()</code></td>
-      <td><code>{'JsonPatch[]'}</code></td>
-      <td>Get all patches applied so far</td>
-    </tr>
-    <tr>
-      <td><code>reset(initial?)</code></td>
-      <td><code>void</code></td>
-      <td>Reset to initial state</td>
-    </tr>
-  </tbody>
-</table>
-
-## Fence Constants
-
-Exported string constants for fence detection in custom parsers:
-
-<table>
-  <thead>
-    <tr>
-      <th>Constant</th>
-      <th>Value</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>YAML_SPEC_FENCE</code></td>
-      <td><code>{'\"```yaml-spec\"'}</code></td>
-    </tr>
-    <tr>
-      <td><code>YAML_EDIT_FENCE</code></td>
-      <td><code>{'\"```yaml-edit\"'}</code></td>
-    </tr>
-    <tr>
-      <td><code>YAML_PATCH_FENCE</code></td>
-      <td><code>{'\"```yaml-patch\"'}</code></td>
-    </tr>
-    <tr>
-      <td><code>DIFF_FENCE</code></td>
-      <td><code>{'\"```diff\"'}</code></td>
-    </tr>
-    <tr>
-      <td><code>FENCE_CLOSE</code></td>
-      <td><code>{'\"```\"'}</code></td>
-    </tr>
-  </tbody>
-</table>
-
-## Re-exports from @json-render/core
-
-### diffToPatches
-
-Generate RFC 6902 JSON Patch operations that transform one object into another.
-
-```typescript
-function diffToPatches(
-  oldObj: Record<string, unknown>,
-  newObj: Record<string, unknown>,
-  basePath?: string
-): JsonPatch[]
-```
-
-### deepMergeSpec
-
-Deep-merge with RFC 7396 semantics: `null` deletes, arrays replace, objects recurse.
-
-```typescript
-function deepMergeSpec(
-  base: Record<string, unknown>,
-  patch: Record<string, unknown>
-): Record<string, unknown>
-```

apps/web/content/docs/api/zustand.mdx

@@ -1,107 +0,0 @@
----
-title: "@json-render/zustand"
----
-
-Zustand adapter for json-render's `StateStore` interface.
-
-Requires Zustand v5+. Zustand v4 is not supported due to breaking API changes in the vanilla store interface.
-
-## Installation
-
-```bash
-npm install @json-render/zustand @json-render/core @json-render/react zustand
-```
-
-## zustandStateStore
-
-Create a `StateStore` backed by a Zustand vanilla store.
-
-```typescript
-import { zustandStateStore } from "@json-render/zustand";
-```
-
-### Options
-
-<table>
-  <thead>
-    <tr>
-      <th>Option</th>
-      <th>Type</th>
-      <th>Required</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>store</code></td>
-      <td><code>{'StoreApi<S>'}</code></td>
-      <td>Yes</td>
-      <td>A Zustand vanilla store (from <code>createStore</code> in <code>zustand/vanilla</code>).</td>
-    </tr>
-    <tr>
-      <td><code>selector</code></td>
-      <td><code>{'(state: S) => StateModel'}</code></td>
-      <td>No</td>
-      <td>Select the json-render slice from the store state. Defaults to the entire state.</td>
-    </tr>
-    <tr>
-      <td><code>updater</code></td>
-      <td><code>{'(nextState: StateModel, store: StoreApi<S>) => void'}</code></td>
-      <td>No</td>
-      <td>Apply a state change back to the store. Defaults to a shallow merge.</td>
-    </tr>
-  </tbody>
-</table>
-
-### Example
-
-```typescript
-import { createStore } from "zustand/vanilla";
-import { zustandStateStore } from "@json-render/zustand";
-import { StateProvider } from "@json-render/react";
-
-const bearStore = createStore(() => ({
-  count: 0,
-  name: "Bear",
-}));
-
-const store = zustandStateStore({ store: bearStore });
-```
-
-```tsx
-<StateProvider store={store}>
-  {/* json-render reads/writes go through Zustand */}
-</StateProvider>
-```
-
-### Nested Slice
-
-```typescript
-const appStore = createStore(() => ({
-  ui: { count: 0 },
-  auth: { token: null },
-}));
-
-const store = zustandStateStore({
-  store: appStore,
-  selector: (s) => s.ui,
-  updater: (next, s) => s.setState({ ui: next }),
-});
-```
-
-## Re-exports
-
-<table>
-  <thead>
-    <tr>
-      <th>Export</th>
-      <th>Source</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>StateStore</code></td>
-      <td><code>@json-render/core</code></td>
-    </tr>
-  </tbody>
-</table>