fix(ui/product): ship the component classes with the components; @ts-ignore the Gui ref

hz-mono/hz-tnum/hz-paper/hz-menu-in/hz-row were only defined in the console's
globals.css, so every OTHER host of these components rendered them unstyled.
They now live in the package's one stylesheet next to hz-skeleton, with the
elevation variables falling back so a host that defines its own --hz-* still wins.

SlideOver's panel ref used @ts-expect-error, which is itself an error wherever the
consumer's resolved @types/react accepts the ref (the commerce admin does).

Co-authored-by: Hanzo Dev <dev@hanzo.ai>

.changeset/canvas-project-paas.md

@@ -0,0 +1,13 @@
+---
+"@hanzo/canvas": minor
+---
+
+feat: new `@hanzo/canvas` package — a Railway-grade PaaS project canvas.
+
+A pannable/zoomable board of service nodes (`ProjectCanvas`) with live status
+(`ServiceStatusBadge`), metric sparklines (`MetricSparkline`), deploy timelines
+(`DeployTimeline`), an environment switcher (`EnvSwitcher`), and a service detail
+drawer (`ServiceDetailDrawer`), plus the `ServiceNode` card and `SourceRef` /
+`ReplicaPill` primitives. Presentational and data-prop-driven, built on
+`@hanzo/gui` (brand/white-label aware via the design tokens) with an optional
+`@xyflow/react` peer. Pure folds (status/layout/time) are unit-tested.

.changeset/config.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://unpkg.com/@changesets/config@2.3.0/schema.json",
+  "changelog": ["@changesets/changelog-github", { "repo": "shadcn-ui/ui" }],
+  "commit": false,
+  "fixed": [],
+  "linked": [],
+  "access": "public",
+  "baseBranch": "main",
+  "updateInternalDependencies": "patch",
+  "ignore": ["v4", "tests"]
+}

.github/changeset-version.js

@@ -0,0 +1,12 @@
+// ORIGINALLY FROM CLOUDFLARE WRANGLER:
+// https://github.com/cloudflare/wrangler2/blob/main/.github/changeset-version.js
+
+import { execSync } from "child_process"
+
+// This script is used by the `release.yml` workflow to update the version of the packages being released.
+// The standard step is only to run `changeset version` but this does not update the pnpm-lock.yaml file.
+// So we also run `pnpm install`, which does this update.
+// This is a workaround until this is handled automatically by `changeset version`.
+// See https://github.com/changesets/changesets/issues/421.
+execSync("npx changeset version", { stdio: "inherit" })
+execSync("pnpm install --lockfile-only", { stdio: "inherit" })

.github/workflows/ci.yml

@@ -0,0 +1,261 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+      - develop
+  pull_request:
+    branches:
+      - main
+      - develop
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: hanzo-build-linux-amd64
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v3
+        with:
+          version: 9
+
+      - name: Get pnpm store directory
+        shell: bash
+        run: |
+          echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_ENV
+
+      - name: Setup pnpm cache
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.STORE_PATH }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
+      - name: Install dependencies
+        run: pnpm install --no-frozen-lockfile
+
+      - name: Run linting
+        run: pnpm run lint
+
+  typecheck:
+    name: Type Check
+    runs-on: hanzo-build-linux-amd64
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v3
+        with:
+          version: 9
+
+      - name: Get pnpm store directory
+        shell: bash
+        run: |
+          echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_ENV
+
+      - name: Setup pnpm cache
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.STORE_PATH }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
+      - name: Install dependencies
+        run: pnpm install --no-frozen-lockfile
+
+      - name: Build UI package
+        run: cd pkgs/ui && pnpm run build
+
+      - name: Run type checking
+        run: |
+          cd app && pnpm run typecheck
+          cd ../pkgs/ui && pnpm run tc --noEmit
+
+  build:
+    name: Build
+    runs-on: hanzo-build-linux-amd64
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v3
+        with:
+          version: 9
+
+      - name: Get pnpm store directory
+        shell: bash
+        run: |
+          echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_ENV
+
+      - name: Setup pnpm cache
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.STORE_PATH }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
+      - name: Install dependencies
+        run: pnpm install --no-frozen-lockfile
+
+      - name: Build UI package
+        run: cd pkgs/ui && pnpm run build:full
+
+      - name: Build app
+        run: cd app && pnpm run build
+        env:
+          NEXT_PUBLIC_APP_URL: https://ui.hanzo.ai
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: build-artifacts
+          path: |
+            app/.next
+            pkgs/ui/dist
+
+  test:
+    name: Test
+    runs-on: hanzo-build-linux-amd64
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v3
+        with:
+          version: 9
+
+      - name: Get pnpm store directory
+        shell: bash
+        run: |
+          echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_ENV
+
+      - name: Setup pnpm cache
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.STORE_PATH }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
+      - name: Install dependencies
+        run: pnpm install --no-frozen-lockfile
+
+      - name: Run pkgs/ui tests
+        run: cd pkgs/ui && pnpm test -- --run
+
+      - name: Run app tests
+        run: |
+          if [ -f "app/package.json" ] && grep -q '"test"' app/package.json 2>/dev/null; then
+            cd app && pnpm test || echo "No tests configured"
+          else
+            echo "No test script found"
+          fi
+
+      - name: Upload coverage
+        if: always()
+        uses: codecov/codecov-action@v3
+        with:
+          files: ./pkgs/ui/coverage/lcov.info
+          flags: unit
+
+  deploy-preview:
+    name: Deploy Preview
+    runs-on: hanzo-deploy-linux-amd64
+    needs: [lint, typecheck, build]
+    if: github.event_name == 'pull_request'
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v3
+        with:
+          version: 9
+
+      - name: Install Vercel CLI
+        run: npm install --global vercel@latest
+
+      - name: Pull Vercel Environment Information
+        run: vercel pull --yes --environment=preview --token=${{ secrets.VERCEL_TOKEN }}
+        env:
+          VERCEL_ORG_ID: ${{ secrets.VERCEL_ORG_ID }}
+          VERCEL_PROJECT_ID: ${{ secrets.VERCEL_PROJECT_ID }}
+
+      - name: Build Project Artifacts
+        run: vercel build --token=${{ secrets.VERCEL_TOKEN }}
+
+      - name: Deploy Project Artifacts to Vercel
+        id: deploy
+        run: |
+          url=$(vercel deploy --prebuilt --token=${{ secrets.VERCEL_TOKEN }})
+          echo "preview_url=$url" >> $GITHUB_OUTPUT
+
+      - name: Comment PR with preview URL
+        if: github.event_name == 'pull_request'
+        uses: actions/github-script@v7
+        with:
+          script: |
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: '🚀 Preview deployed to: ${{ steps.deploy.outputs.preview_url }}'
+            })
+
+  status:
+    name: CI Status
+    runs-on: hanzo-build-linux-amd64
+    needs: [lint, typecheck, build, test]
+    if: always()
+    steps:
+      - name: Check status
+        run: |
+          if [ "${{ needs.lint.result }}" != "success" ] || \
+             [ "${{ needs.typecheck.result }}" != "success" ] || \
+             [ "${{ needs.build.result }}" != "success" ] || \
+             [ "${{ needs.test.result }}" != "success" ]; then
+            echo "CI checks failed"
+            exit 1
+          else
+            echo "All CI checks passed!"
+          fi

.github/workflows/code-check.yml

@@ -0,0 +1,122 @@
+name: Code check
+
+on:
+  pull_request:
+    branches: ["*"]
+
+jobs:
+  lint:
+    runs-on: hanzo-build-linux-amd64
+    name: pnpm lint
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Install Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 20
+
+      - uses: pnpm/action-setup@v4
+        name: Install pnpm
+        id: pnpm-install
+        with:
+          version: 9.0.6
+          run_install: false
+
+      - name: Get pnpm store directory
+        id: pnpm-cache
+        run: |
+          echo "pnpm_cache_dir=$(pnpm store path)" >> $GITHUB_OUTPUT
+      - uses: actions/cache@v3
+        name: Setup pnpm cache
+        with:
+          path: ${{ steps.pnpm-cache.outputs.pnpm_cache_dir }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+      - name: Install dependencies
+        run: pnpm install
+
+      - run: pnpm lint
+
+  format:
+    runs-on: hanzo-build-linux-amd64
+    name: pnpm format:check
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Install Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 20
+
+      - uses: pnpm/action-setup@v4
+        name: Install pnpm
+        id: pnpm-install
+        with:
+          version: 9.0.6
+          run_install: false
+
+      - name: Get pnpm store directory
+        id: pnpm-cache
+        run: |
+          echo "pnpm_cache_dir=$(pnpm store path)" >> $GITHUB_OUTPUT
+
+      - uses: actions/cache@v3
+        name: Setup pnpm cache
+        with:
+          path: ${{ steps.pnpm-cache.outputs.pnpm_cache_dir }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Build packages
+        run: pnpm --filter=shadcn build
+
+      - run: pnpm format:check
+
+  tsc:
+    runs-on: hanzo-build-linux-amd64
+    name: pnpm typecheck
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Install Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 20
+
+      - uses: pnpm/action-setup@v4
+        name: Install pnpm
+        id: pnpm-install
+        with:
+          version: 9.0.6
+          run_install: false
+
+      - name: Get pnpm store directory
+        id: pnpm-cache
+        run: |
+          echo "pnpm_cache_dir=$(pnpm store path)" >> $GITHUB_OUTPUT
+      - uses: actions/cache@v3
+        name: Setup pnpm cache
+        with:
+          path: ${{ steps.pnpm-cache.outputs.pnpm_cache_dir }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Build packages
+        run: pnpm --filter=shadcn build
+
+      - run: pnpm typecheck

.github/workflows/coverage.yml

@@ -0,0 +1,60 @@
+name: Test Coverage
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main, develop]
+
+jobs:
+  coverage:
+    name: Test Coverage
+    runs-on: hanzo-build-linux-amd64
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v3
+        with:
+          version: 9
+
+      - name: Install dependencies
+        run: pnpm install --no-frozen-lockfile
+
+      - name: Run tests with coverage
+        run: cd pkgs/ui && pnpm test:coverage
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v3
+        with:
+          files: ./pkgs/ui/coverage/lcov.info
+          flags: unit
+          name: hanzo-ui-coverage
+
+      - name: Comment PR with coverage
+        if: github.event_name == 'pull_request'
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            const coverage = JSON.parse(fs.readFileSync('./pkgs/ui/coverage/coverage-summary.json', 'utf8'));
+            const total = coverage.total;
+            const comment = `## Test Coverage Report\n\n` +
+              `Lines: ${total.lines.pct}%\n` +
+              `Statements: ${total.statements.pct}%\n` +
+              `Functions: ${total.functions.pct}%\n` +
+              `Branches: ${total.branches.pct}%`;
+
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: comment
+            });

.github/workflows/deploy-gh-pages.yml

@@ -0,0 +1,96 @@
+name: Deploy to GitHub Pages
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+    inputs:
+      capture_screenshots:
+        description: 'Capture component screenshots (slow, optional)'
+        required: false
+        type: boolean
+        default: false
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: hanzo-build-linux-amd64
+    timeout-minutes: 10
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v3
+        with:
+          version: 9
+
+      - name: Get pnpm store directory
+        shell: bash
+        run: |
+          echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_ENV
+
+      - name: Setup pnpm cache
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.STORE_PATH }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
+      - name: Install dependencies
+        run: |
+          pnpm install --no-frozen-lockfile
+
+      - name: Build @hanzo/ui package
+        run: |
+          cd pkgs/ui && pnpm build
+
+      - name: Capture screenshots (optional)
+        if: github.event.inputs.capture_screenshots == 'true'
+        working-directory: ./app
+        run: pnpm capture:registry
+        timeout-minutes: 5
+
+      - name: Build documentation
+        working-directory: ./app
+        run: |
+          pnpm build
+          touch out/.nojekyll
+        env:
+          NODE_ENV: production
+          GITHUB_ACTIONS: true
+          NEXT_PUBLIC_APP_URL: https://ui.hanzo.ai
+          SKIP_SCREENSHOTS: true
+
+      - name: Setup Pages
+        uses: actions/configure-pages@v4
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: ./app/out
+
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: hanzo-deploy-linux-amd64
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

.github/workflows/deprecated.yml

@@ -0,0 +1,78 @@
+name: Deprecated
+
+on:
+  pull_request_target:
+    types: [opened, synchronize]
+
+permissions:
+  issues: write
+  contents: read
+  pull-requests: write
+
+jobs:
+  deprecated:
+    runs-on: hanzo-build-linux-amd64
+    steps:
+      - name: Checkout PR
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+          fetch-depth: 0
+
+      - name: Get changed files
+        id: changed-files
+        uses: tj-actions/changed-files@v46
+        with:
+          files: |
+            apps/www/**
+          files_ignore: |
+            apps/www/public/r/**
+          base_sha: ${{ github.event.pull_request.base.sha }}
+          sha: ${{ github.event.pull_request.head.sha }}
+
+      - name: Comment on PR if www files changed
+        if: steps.changed-files.outputs.any_changed == 'true'
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const changedFiles = `${{ steps.changed-files.outputs.all_changed_files }}`.split(' ');
+            const wwwFiles = changedFiles.filter(file =>
+              file.startsWith('apps/www/') &&
+              !file.startsWith('apps/www/public/r/') &&
+              file !== 'apps/www/package.json'
+            );
+
+            if (wwwFiles.length > 0) {
+              const comment = `Looks like this PR modifies files in \`apps/www\`, which is deprecated.
+
+              Consider applying the change to \`apps/v4\` if relevant.`;
+
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number,
+                body: comment
+              });
+
+              // Add deprecated label
+              await github.rest.issues.addLabels({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number,
+                labels: ['deprecated']
+              });
+            } else {
+              // Remove deprecated label if no www files are changed
+              try {
+                await github.rest.issues.removeLabel({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: context.issue.number,
+                  name: 'deprecated'
+                });
+              } catch (error) {
+                // Label doesn't exist, which is fine
+                console.log('Deprecated label not found, skipping removal');
+              }
+            }

.github/workflows/issue-stale.yml

@@ -0,0 +1,45 @@
+# Adapted from vercel/next.js
+name: "Stale issue handler"
+on:
+  workflow_dispatch:
+  schedule:
+    # This runs every day 20 minutes before midnight: https://crontab.guru/#40_23_*_*_*
+    - cron: "40 23 * * *"
+
+jobs:
+  stale:
+    runs-on: hanzo-build-linux-amd64
+    if: github.repository_owner == 'shadcn-ui'
+    steps:
+      - uses: actions/stale@v9
+        id: issue-stale
+        name: "Mark stale issues, close stale issues"
+        with:
+          repo-token: ${{ secrets.STALE_TOKEN }}
+          ascending: true
+          days-before-issue-close: 7
+          days-before-issue-stale: 365
+          days-before-pr-stale: -1
+          days-before-pr-close: -1
+          remove-issue-stale-when-updated: true
+          stale-issue-label: "stale?"
+          exempt-issue-labels: "roadmap,next"
+          stale-issue-message: "This issue has been automatically marked as stale due to one year of inactivity. It will be closed in 7 days unless there’s further input. If you believe this issue is still relevant, please leave a comment or provide updated details. Thank you. (This is an automated message)"
+          close-issue-message: "This issue has been automatically closed due to one year of inactivity. If you’re still experiencing a similar problem or have additional details to share, please open a new issue following our current issue template. Your updated report helps us investigate and address concerns more efficiently. Thank you for your understanding! (This is an automated message)"
+          operations-per-run: 300
+      - uses: actions/stale@v9
+        id: pr-state
+        name: "Mark stale PRs, close stale PRs"
+        with:
+          repo-token: ${{ secrets.STALE_TOKEN }}
+          ascending: true
+          days-before-issue-close: -1
+          days-before-issue-stale: -1
+          days-before-pr-close: 7
+          days-before-pr-stale: 365
+          remove-pr-stale-when-updated: true
+          exempt-pr-labels: "roadmap,next,bug"
+          stale-pr-label: "stale?"
+          stale-pr-message: "This PR has been automatically marked as stale due to one year of inactivity. It will be closed in 7 days unless there’s further input. If you believe this PR is still relevant, please leave a comment or provide updated details. Thank you. (This is an automated message)"
+          close-pr-message: "This PR has been automatically closed due to one year of inactivity. Thank you for your understanding! (This is an automated message)"
+          operations-per-run: 300

.github/workflows/npm-publish.yml

@@ -0,0 +1,185 @@
+name: NPM Publish
+
+permissions:
+  contents: write
+  id-token: write
+
+on:
+  workflow_dispatch:
+    inputs:
+      package:
+        description: 'Package to publish'
+        required: true
+        type: choice
+        options:
+          - ui
+          - ui-mcp
+          - auth
+          - commerce
+          - checkout
+          - brand
+          - react
+          - all
+      version_bump:
+        description: 'Version bump type'
+        required: true
+        type: choice
+        options:
+          - patch
+          - minor
+          - major
+
+jobs:
+  publish:
+    runs-on: hanzo-build-linux-amd64
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v3
+        with:
+          version: 8
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Build packages
+        run: |
+          if [ "${{ github.event.inputs.package }}" = "all" ] || [ "${{ github.event.inputs.package }}" = "ui" ]; then
+            cd pkgs/ui && pnpm build
+            cd ../..
+          fi
+          if [ "${{ github.event.inputs.package }}" = "all" ] || [ "${{ github.event.inputs.package }}" = "ui-mcp" ]; then
+            cd pkgs/ui-mcp && pnpm build
+            cd ../..
+          fi
+          if [ "${{ github.event.inputs.package }}" = "all" ] || [ "${{ github.event.inputs.package }}" = "auth" ]; then
+            cd pkgs/auth && pnpm build
+            cd ../..
+          fi
+          if [ "${{ github.event.inputs.package }}" = "all" ] || [ "${{ github.event.inputs.package }}" = "commerce" ]; then
+            cd pkgs/commerce && pnpm build
+            cd ../..
+          fi
+          if [ "${{ github.event.inputs.package }}" = "all" ] || [ "${{ github.event.inputs.package }}" = "checkout" ]; then
+            cd pkgs/checkout && pnpm build
+            cd ../..
+          fi
+          if [ "${{ github.event.inputs.package }}" = "all" ] || [ "${{ github.event.inputs.package }}" = "brand" ]; then
+            cd pkgs/brand && pnpm build
+            cd ../..
+          fi
+          if [ "${{ github.event.inputs.package }}" = "all" ] || [ "${{ github.event.inputs.package }}" = "react" ]; then
+            cd pkgs/react && pnpm build
+            cd ../..
+          fi
+
+      - name: Bump version and publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NPM_CONFIG_PROVENANCE: true
+        run: |
+          # Set up npm and pnpm auth
+          npm config set //registry.npmjs.org/:_authToken $NODE_AUTH_TOKEN
+          echo "//registry.npmjs.org/:_authToken=${NODE_AUTH_TOKEN}" >> ~/.npmrc
+
+          publish_package() {
+            local pkg_dir=$1
+            local pkg_name=$(cd $pkg_dir && node -p "require('./package.json').name")
+            local pkg_version=$(cd $pkg_dir && node -p "require('./package.json').version")
+            echo "=== Publishing $pkg_name@$pkg_version from $pkg_dir ==="
+
+            # Change to package directory
+            pushd "$pkg_dir"
+
+            # Bump version manually using node to avoid any pnpm/npm hooks
+            echo "Bumping version (${{ github.event.inputs.version_bump }})..."
+            node -e "
+              const fs = require('fs');
+              const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+              const [major, minor, patch] = pkg.version.split('.').map(Number);
+              const bump = '${{ github.event.inputs.version_bump }}';
+              if (bump === 'major') pkg.version = (major + 1) + '.0.0';
+              else if (bump === 'minor') pkg.version = major + '.' + (minor + 1) + '.0';
+              else pkg.version = major + '.' + minor + '.' + (patch + 1);
+              fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2) + '\n');
+              console.log('New version:', pkg.version);
+            "
+
+            local new_version=$(node -p "require('./package.json').version")
+            echo "Version is now: $new_version"
+
+            # Pack the tarball
+            echo "Running pnpm pack..."
+            pnpm pack --pack-gzip-level 9
+            local tarball=$(ls -t *.tgz | head -1)
+            echo "Created tarball: $tarball"
+
+            # Verify tarball contents
+            echo "Tarball package.json:"
+            tar -xzf "$tarball" -O package/package.json
+
+            # Copy to temp dir and publish
+            local temp_dir="/tmp/publish-$$"
+            mkdir -p "$temp_dir"
+            cp "$tarball" "$temp_dir/"
+            echo "Publishing from $temp_dir..."
+            cd "$temp_dir"
+            npm publish "$tarball" --access public
+            cd -
+
+            # Cleanup
+            rm -rf "$temp_dir"
+            rm -f "$tarball"
+            popd
+          }
+          
+          case "${{ github.event.inputs.package }}" in
+            ui)
+              publish_package "pkgs/ui"
+              ;;
+            ui-mcp)
+              publish_package "pkgs/ui-mcp"
+              ;;
+            auth)
+              publish_package "pkgs/auth"
+              ;;
+            commerce)
+              publish_package "pkgs/commerce"
+              ;;
+            checkout)
+              publish_package "pkgs/checkout"
+              ;;
+            brand)
+              publish_package "pkgs/brand"
+              ;;
+            react)
+              publish_package "pkgs/react"
+              ;;
+            all)
+              publish_package "pkgs/ui"
+              publish_package "pkgs/ui-mcp"
+              publish_package "pkgs/auth"
+              publish_package "pkgs/commerce"
+              publish_package "pkgs/checkout"
+              publish_package "pkgs/brand"
+              publish_package "pkgs/react"
+              ;;
+          esac
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v6
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          commit-message: 'chore: bump ${{ github.event.inputs.package }} version to ${{ github.event.inputs.version_bump }}'
+          title: 'chore: bump ${{ github.event.inputs.package }} version'
+          body: |
+            Automated version bump for ${{ github.event.inputs.package }} package(s).
+            
+            Version bump type: ${{ github.event.inputs.version_bump }}
+          branch: version-bump-${{ github.event.inputs.package }}-${{ github.run_number }}

.github/workflows/prerelease-comment.yml

@@ -0,0 +1,65 @@
+# Adapted from create-t3-app.
+name: Write Beta Release comment
+
+on:
+  workflow_run:
+    workflows: ["Release - Beta"]
+    types:
+      - completed
+
+jobs:
+  comment:
+    if: |
+      github.repository_owner == 'shadcn-ui' &&
+      ${{ github.event.workflow_run.conclusion == 'success' }}
+    runs-on: hanzo-build-linux-amd64
+    name: Write comment to the PR
+    steps:
+      - name: "Comment on PR"
+        uses: actions/github-script@v6
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const allArtifacts = await github.rest.actions.listWorkflowRunArtifacts({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              run_id: context.payload.workflow_run.id,
+            });
+
+            for (const artifact of allArtifacts.data.artifacts) {
+              // Extract the PR number and package version from the artifact name
+              const match = /^npm-package-shadcn@(.*?)-pr-(\d+)/.exec(artifact.name);
+
+              if (match) {
+                require("fs").appendFileSync(
+                  process.env.GITHUB_ENV,
+                  `\nBETA_PACKAGE_VERSION=${match[1]}` +
+                  `\nWORKFLOW_RUN_PR=${match[2]}` +
+                  `\nWORKFLOW_RUN_ID=${context.payload.workflow_run.id}`
+                );
+                break;
+              }
+            }
+
+      - name: "Comment on PR with Link"
+        uses: marocchino/sticky-pull-request-comment@v2
+        with:
+          number: ${{ env.WORKFLOW_RUN_PR }}
+          message: |
+            A new prerelease is available for testing:
+
+            ```sh
+            pnpm dlx shadcn@${{ env.BETA_PACKAGE_VERSION }}
+            ```
+
+      - name: "Remove the autorelease label once published"
+        uses: actions/github-script@v6
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            github.rest.issues.removeLabel({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: '${{ env.WORKFLOW_RUN_PR }}',
+              name: '🚀 autorelease',
+            });

.github/workflows/prerelease.yml

@@ -0,0 +1,63 @@
+# Adapted from create-t3-app.
+
+name: Release - Beta
+
+on:
+  pull_request:
+    types: [labeled]
+    branches:
+      - main
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  prerelease:
+    if: |
+      github.repository_owner == 'shadcn-ui' &&
+      contains(github.event.pull_request.labels.*.name, '🚀 autorelease')
+    name: Build & Publish a beta release to NPM
+    runs-on: hanzo-build-linux-amd64
+    environment: Preview
+
+    steps:
+      - name: Checkout Repo
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Use PNPM
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9.0.6
+
+      - name: Use Node.js 20
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Update npm for OIDC support
+        run: npm install -g npm@latest
+
+      - name: Install NPM Dependencies
+        run: pnpm install
+
+      - name: Modify package.json version
+        run: node .github/version-script-beta.js
+
+      - name: Publish Beta to NPM
+        run: pnpm pub:beta
+
+      - name: get-npm-version
+        id: package-version
+        uses: martinbeentjes/npm-get-version-action@main
+        with:
+          path: pkgs/shadcn
+
+      - name: Upload packaged artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: npm-package-shadcn@${{ steps.package-version.outputs.current-version }}-pr-${{ github.event.number }} # encode the PR number into the artifact name
+          path: pkgs/shadcn/dist/index.js

.github/workflows/publish-on-tag.yml

@@ -0,0 +1,150 @@
+name: Publish on Tag
+
+on:
+  push:
+    tags:
+      - 'v*'  # Match @hanzo/ui version (e.g., v5.1.1)
+
+jobs:
+  test:
+    name: Run Tests
+    runs-on: hanzo-build-linux-amd64
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v3
+        with:
+          version: 9
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install dependencies
+        run: pnpm install --no-frozen-lockfile
+
+      - name: Build packages
+        run: |
+          cd pkgs/ui && pnpm build && cd ../..
+          cd pkgs/commerce && pnpm build && cd ../..
+          cd pkgs/brand && pnpm build && cd ../..
+          cd pkgs/react && pnpm build && cd ../..
+
+      - name: Run tests
+        run: |
+          cd pkgs/ui && pnpm test
+          cd ../react && pnpm test
+          cd ../..
+
+  publish:
+    name: Publish to NPM
+    needs: test
+    runs-on: hanzo-build-linux-amd64
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v3
+        with:
+          version: 9
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: pnpm install --no-frozen-lockfile
+
+      - name: Build all packages
+        run: |
+          cd pkgs/ui && pnpm build && cd ../..
+          cd pkgs/commerce && pnpm build && cd ../..
+          cd pkgs/brand && pnpm build && cd ../..
+          cd pkgs/react && pnpm build && cd ../..
+
+      - name: Configure npm authentication
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: |
+          npm config set //registry.npmjs.org/:_authToken $NODE_AUTH_TOKEN
+          npm whoami
+
+      - name: Check and publish packages
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: |
+          echo "Checking all packages for unpublished versions..."
+
+          PUBLISHED_COUNT=0
+          SKIPPED_COUNT=0
+          PUBLISHED_PACKAGES=""
+
+          for package in ui commerce brand react; do
+            cd "pkgs/$package"
+
+            CURRENT_VERSION=$(node -p "require('./package.json').version")
+            PACKAGE_NAME=$(node -p "require('./package.json').name")
+
+            echo ""
+            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+            echo "📦 Checking $PACKAGE_NAME@$CURRENT_VERSION"
+            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+            # Check if this version already exists on npm
+            if npm view "$PACKAGE_NAME@$CURRENT_VERSION" version 2>/dev/null; then
+              echo "⏭️  Already published - skipping"
+              SKIPPED_COUNT=$((SKIPPED_COUNT + 1))
+            else
+              echo "🚀 Publishing to npm..."
+              npm publish --access public
+              echo "✅ Successfully published $PACKAGE_NAME@$CURRENT_VERSION"
+              PUBLISHED_COUNT=$((PUBLISHED_COUNT + 1))
+              PUBLISHED_PACKAGES="$PUBLISHED_PACKAGES\n- $PACKAGE_NAME@$CURRENT_VERSION"
+            fi
+
+            cd ../..
+          done
+
+          echo ""
+          echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+          echo "📊 Publishing Summary"
+          echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+          echo "✅ Published: $PUBLISHED_COUNT package(s)"
+          echo "⏭️  Skipped: $SKIPPED_COUNT package(s)"
+
+          if [ $PUBLISHED_COUNT -gt 0 ]; then
+            echo ""
+            echo -e "Published packages:$PUBLISHED_PACKAGES"
+          fi
+
+          # Save for GitHub release notes
+          echo "PUBLISHED_COUNT=$PUBLISHED_COUNT" >> $GITHUB_ENV
+          echo "PUBLISHED_PACKAGES<<EOF" >> $GITHUB_ENV
+          echo -e "$PUBLISHED_PACKAGES" >> $GITHUB_ENV
+          echo "EOF" >> $GITHUB_ENV
+
+      - name: Create GitHub Release
+        if: ${{ env.PUBLISHED_COUNT > 0 }}
+        uses: softprops/action-gh-release@v1
+        with:
+          generate_release_notes: true
+          body: |
+            ## 📦 NPM Packages Published
+
+            ${{ env.PUBLISHED_PACKAGES }}
+
+            ### Installation
+
+            ```bash
+            # Install latest versions
+            npm install @hanzo/ui @hanzo/commerce @hanzo/brand @hanzo/react
+            ```
+          files: |
+            CHANGELOG.md
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/publish.yml

@@ -0,0 +1,86 @@
+name: Publish Packages
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'pkgs/*/package.json'
+      - 'pkgs/*/package.json'
+
+jobs:
+  detect-changes:
+    runs-on: hanzo-build-linux-amd64
+    outputs:
+      packages: ${{ steps.changed.outputs.packages }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+
+      - name: Detect changed packages
+        id: changed
+        run: |
+          CHANGED=()
+          for pkg_json in pkgs/*/package.json pkgs/*/package.json; do
+            [ ! -f "$pkg_json" ] && continue
+            pkg_dir=$(dirname "$pkg_json")
+
+            # Skip private packages
+            IS_PRIVATE=$(jq -r '.private // false' "$pkg_json")
+            [ "$IS_PRIVATE" = "true" ] && continue
+
+            # Only publish @hanzo/* packages
+            PKG_NAME=$(jq -r '.name' "$pkg_json")
+            case "$PKG_NAME" in
+              @hanzo/*) ;;
+              *) continue ;;
+            esac
+
+            # Check version changed
+            if git diff HEAD~1 HEAD --quiet "$pkg_json" 2>/dev/null; then
+              continue
+            fi
+
+            OLD=$(git show HEAD~1:"$pkg_json" 2>/dev/null | jq -r '.version' || echo "0.0.0")
+            NEW=$(jq -r '.version' "$pkg_json")
+
+            if [ "$OLD" != "$NEW" ]; then
+              echo "Version change: $PKG_NAME ($OLD -> $NEW)"
+              CHANGED+=("$(basename "$pkg_dir")")
+            fi
+          done
+
+          if [ ${#CHANGED[@]} -eq 0 ]; then
+            echo "packages=[]" >> $GITHUB_OUTPUT
+          else
+            JSON=$(printf '%s\n' "${CHANGED[@]}" | jq -R . | jq -s -c .)
+            echo "packages=$JSON" >> $GITHUB_OUTPUT
+          fi
+
+  publish:
+    needs: detect-changes
+    if: needs.detect-changes.outputs.packages != '[]'
+    runs-on: hanzo-build-linux-amd64
+    strategy:
+      matrix:
+        package: ${{ fromJson(needs.detect-changes.outputs.packages) }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Build package
+        run: pnpm --filter ${{ matrix.package }} build
+
+      - name: Publish package
+        run: pnpm --filter ${{ matrix.package }} publish --no-git-checks --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/release.yml

@@ -0,0 +1,59 @@
+# Adapted from create-t3-app.
+
+name: Release
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  id-token: write
+  contents: write
+  pull-requests: write
+
+jobs:
+  release:
+    if: ${{ github.repository_owner == 'shadcn-ui' }}
+    name: Create a PR for release workflow
+    runs-on: hanzo-build-linux-amd64
+    steps:
+      - name: Checkout Repo
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Use PNPM
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9.0.6
+
+      - name: Use Node.js 20
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Update npm for OIDC support
+        run: npm install -g npm@latest
+
+      - name: Install NPM Dependencies
+        run: pnpm install
+
+      # - name: Check for errors
+      #   run: pnpm check
+
+      - name: Build the package
+        run: pnpm shadcn:build
+
+      - name: Create Version PR or Publish to NPM
+        id: changesets
+        uses: changesets/action@v1
+        with:
+          commit: "chore(release): version packages"
+          title: "chore(release): version packages"
+          version: node .github/changeset-version.js
+          publish: npx changeset publish
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NODE_ENV: "production"

.github/workflows/test.yml

@@ -0,0 +1,45 @@
+name: Test
+
+on:
+  pull_request:
+    branches: ["*"]
+
+jobs:
+  test:
+    runs-on: hanzo-build-linux-amd64
+    name: pnpm test
+    env:
+      NEXT_PUBLIC_APP_URL: http://localhost:4000
+      NEXT_PUBLIC_V0_URL: https://v0.dev
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Install Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 22
+
+      - uses: pnpm/action-setup@v4
+        name: Install pnpm
+        id: pnpm-install
+        with:
+          version: 9.0.6
+          run_install: false
+
+      - name: Get pnpm store directory
+        id: pnpm-cache
+        run: |
+          echo "pnpm_cache_dir=$(pnpm store path)" >> $GITHUB_OUTPUT
+      - uses: actions/cache@v3
+        name: Setup pnpm cache
+        with:
+          path: ${{ steps.pnpm-cache.outputs.pnpm_cache_dir }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+      - name: Install dependencies
+        run: pnpm install
+
+      - run: pnpm test

.github/workflows/validate-registries.yml

@@ -13,6 +13,44 @@ on:
       - "apps/v4/registry/directory.json"
 
 jobs:
+  check-registry-sync:
+    if: github.event_name == 'pull_request'
+    runs-on: hanzo-build-linux-amd64
+    name: check-registry-sync
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - name: Check changed files
+        id: changed
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          CHANGED_FILES=$(gh pr diff ${{ github.event.pull_request.number }} --repo ${{ github.repository }} --name-only)
+
+          DIRECTORY_CHANGED=false
+          REGISTRIES_CHANGED=false
+
+          if echo "$CHANGED_FILES" | grep -q "^apps/v4/registry/directory.json$"; then
+            DIRECTORY_CHANGED=true
+          fi
+
+          if echo "$CHANGED_FILES" | grep -q "^apps/v4/public/r/registries.json$"; then
+            REGISTRIES_CHANGED=true
+          fi
+
+          echo "directory_changed=$DIRECTORY_CHANGED" >> $GITHUB_OUTPUT
+          echo "registries_changed=$REGISTRIES_CHANGED" >> $GITHUB_OUTPUT
+
+      - name: Flag missing registries.json update
+        if: steps.changed.outputs.directory_changed == 'true' && steps.changed.outputs.registries_changed == 'false'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh pr edit ${{ github.event.pull_request.number }} --repo ${{ github.repository }} --add-label "registries: invalid"
+          gh pr comment ${{ github.event.pull_request.number }} --repo ${{ github.repository }} --body "can you run \`pnpm registry:build\` and commit the json files please?"
+          exit 1
+
   validate:
     runs-on: hanzo-build-linux-amd64
     name: pnpm validate:registries

.gitignore

@@ -5,6 +5,7 @@ node_modules
 **/node_modules
 .pnp
 .pnp.js
+/pnpm-lock.yaml
 
 # testing
 coverage

.hanzo/workflows/cicd.yml

@@ -1,26 +0,0 @@
-# The whole caller. Every decision this pipeline makes — what to test, what to
-# build, where to roll it — is read from the root hanzo.yml, so this file only
-# ever names the triggers and the reusable.
-#
-# `.hanzo/workflows`, not `.github/workflows`, and that is not a style choice:
-# CI for this repo runs on git.hanzo.ai, which resolves ONLY `.hanzo/workflows`.
-# github.com has zero self-hosted runners registered for the `hanzo-build-*`
-# labels this pipeline asks for, so the same file under `.github/workflows`
-# would queue there forever and never report anything at all.
-name: CI/CD
-
-on:
-  push:
-    branches: [main]
-    tags: ['v*']
-  pull_request:
-  workflow_dispatch:
-
-concurrency:
-  group: cicd-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  cicd:
-    uses: hanzoai/ci/.hanzo/workflows/build.yml@v1
-    secrets: inherit

.hanzo/workflows/deploy.yml

@@ -1,70 +0,0 @@
-name: deploy
-
-# RETIRED as an automatic lane. The image is built by hanzo.yml's `images:` block
-# through hanzoai/ci (.hanzo/workflows/cicd.yml), and this job is kept only as a
-# manually-dispatched fallback.
-#
-# The reason is one capability, not tidiness. ui.hanzo.ai is a static export, so
-# its ingest key has to be BAKED IN at build; the key lives in KMS as
-# `deploy/PUBLISHABLE_KEY`, and hanzoai/ci is the only lane that reads it and
-# passes it as `--build-arg PUBLISHABLE_KEY=…`. The `docker build -t "$image" .`
-# below cannot — there is no KMS hop in it and nowhere to put the value — so any
-# image it produced would ship a client with no key at all, and cloud answers
-# `401 ingest_key_required` for an unattributed write. With the Dockerfile now
-# failing closed on an empty key, this job fails on every run instead of quietly
-# publishing an inert site.
-#
-# Left in place rather than deleted, and dispatch-only rather than on push:
-# deleting a repo's only build lane strands the host with no failing run to show
-# it, and two push-triggered builders for one image means one commit yields two
-# images under two tag schemes. Dispatching this publishes `<short-sha>` with an
-# EMPTY key and the Dockerfile will refuse it — so if you dispatch it, pass the
-# key yourself or expect the gate to fire.
-
-on:
-  workflow_dispatch:
-
-concurrency:
-  group: deploy-${{ github.ref }}
-  cancel-in-progress: false
-
-jobs:
-  image:
-    # hanzo-build-linux-amd64, not ubuntu-latest. This file lives in
-    # .hanzo/workflows, which GitHub never reads -- git.hanzo.ai is the only
-    # thing that can run it, and the fleet deliberately advertises no generic
-    # ubuntu-* label (~1400 mirrored forks all ask for it; one bad job was
-    # retried ~520 times across 10 runners). An unmatched label is not an
-    # error here, it is silence: the job queues until the 24h timeout, so this
-    # deploy has never produced an image and nothing ever said so.
-    runs-on: hanzo-build-linux-amd64
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: build and push
-        # GHCR_TOKEN/GHCR_USER, which are the org secrets that actually exist.
-        # This job asked for REGISTRY_TOKEN, which was never defined anywhere —
-        # the org has exactly GHCR_TOKEN, GHCR_USER, GH_PAT, KMS_CLIENT_ID,
-        # KMS_CLIENT_SECRET, OCI_TOKEN, OCI_USER — so the guard below fired on
-        # every run and nothing was ever published. Every other image build in
-        # the org already uses the GHCR_* pair; this file and papers were the
-        # two that invented a name.
-        #
-        # The username comes from the secret too, rather than being hardcoded to
-        # hanzo-dev, so rotating the publishing identity is one org-level change.
-        env:
-          GHCR_TOKEN: ${{ secrets.GHCR_TOKEN }}
-          GHCR_USER: ${{ secrets.GHCR_USER }}
-        run: |
-          set -euo pipefail
-          if [ -z "${GHCR_TOKEN:-}" ] || [ -z "${GHCR_USER:-}" ]; then
-            echo "::error::GHCR_TOKEN/GHCR_USER are unset, so nothing was published."
-            exit 1
-          fi
-          tag="$(git rev-parse --short HEAD)"
-          image="ghcr.io/hanzoai/ui:${tag}"
-          echo "${GHCR_TOKEN}" | docker login ghcr.io -u "${GHCR_USER}" --password-stdin
-          docker build -t "${image}" .
-          docker push "${image}"
-          echo "published ${image} — set image.tag AND image.digest in universe charts/app/values/hanzo/ui.yaml"

.hanzo/workflows/publish.yml

@@ -1,343 +0,0 @@
-name: Publish Packages
-
-on:
-  push:
-    branches: [main]
-    paths:
-      # BOTH package roots, and the singular one is not a typo — `@hanzo/ui` and
-      # `@hanzo/data` live under pkg/, everything else under pkgs/.
-      #
-      # ⚠️ This list and the `for pkg_json in …` loop below are ONE FACT. The loop
-      # was already fixed to walk both roots, with a comment explaining that a
-      # `pkgs/*` glob made pkg/ packages invisible — but this gate was left
-      # matching `pkgs/*` only, so for a pkg/-only change the corrected job could
-      # never be REACHED. The fix was reasoned about in the body and not applied
-      # to the thing that decides whether the body runs.
-      #
-      # Cost: @hanzo/ui 8.0.29 sat unpublished while npmjs served 8.0.28, so
-      # every consumer resolving `^8.0.17` silently got a version without the
-      # `./chat` entrypoint — an import error in the dependent, nothing at all in
-      # this repo. Add a root here whenever one is added to the loop.
-      - 'pkg/*/package.json'
-      - 'pkgs/*/package.json'
-  # A publish that fails for an infrastructure reason — the runner missing a
-  # tool, npmjs answering slowly — could only be retried by pushing another
-  # commit that touches a package.json, i.e. by burning a version number to
-  # re-run a job that was never wrong about the code. detect-changes reads what
-  # npmjs SERVES, so a dispatch is idempotent by construction: it publishes
-  # exactly the packages that are ahead of the registry, and nothing when none
-  # are.
-  workflow_dispatch:
-
-jobs:
-  detect-changes:
-    runs-on: hanzo-build-linux-amd64
-    outputs:
-      packages: ${{ steps.changed.outputs.packages }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 2
-
-      - name: Detect changed packages
-        id: changed
-        run: |
-          CHANGED=()
-          # Both package roots. `@hanzo/ui` and `@hanzo/data` live under pkg/ (singular)
-          # and were invisible to a `pkgs/*` glob, so no version bump of either could
-          # ever reach npmjs from here.
-          for pkg_json in pkg/*/package.json pkgs/*/package.json; do
-            [ ! -f "$pkg_json" ] && continue
-            # Skip private packages
-            IS_PRIVATE=$(jq -r '.private // false' "$pkg_json")
-            [ "$IS_PRIVATE" = "true" ] && continue
-
-            # Only publish @hanzo/* packages
-            PKG_NAME=$(jq -r '.name' "$pkg_json")
-            case "$PKG_NAME" in
-              @hanzo/*) ;;
-              *) continue ;;
-            esac
-
-            # What npm SERVES, not what the previous commit said. HEAD~1 is the
-            # FIRST PARENT, so a merge whose first parent is the feature branch
-            # already carries the new version and the diff is empty — the publish
-            # is skipped and npm keeps serving the old release, silently. Asking
-            # the registry is independent of merge topology and of how many
-            # commits the runner fetched.
-            NEW=$(jq -r '.version' "$pkg_json")
-            OLD=$(curl -sf "https://registry.npmjs.org/${PKG_NAME}" \
-                    | jq -r '."dist-tags".latest // "0.0.0"' 2>/dev/null || echo "0.0.0")
-
-            # FORWARD ONLY. `!=` fires in both directions, and several packages
-            # sit BEHIND npm (a release cut elsewhere, a revert) — publishing
-            # those walks the registry backwards. Only a strictly greater local
-            # version is a release.
-            NEWEST=$(printf '%s\n%s\n' "$OLD" "$NEW" | sort -V | tail -1)
-            if [ "$OLD" != "$NEW" ] && [ "$NEWEST" = "$NEW" ]; then
-              echo "Version change: $PKG_NAME ($OLD -> $NEW)"
-              # The package NAME, because every downstream step spends this as a
-              # `pnpm --filter` argument and a directory basename matches nothing.
-              # An unmatched filter exits 0, so the build silently no-ops and the
-              # publish ships an unbuilt tarball — how 8.0.17 and 8.0.19 shipped broken.
-              CHANGED+=("$PKG_NAME")
-            fi
-          done
-
-          if [ ${#CHANGED[@]} -eq 0 ]; then
-            echo "packages=[]" >> $GITHUB_OUTPUT
-          else
-            JSON=$(printf '%s\n' "${CHANGED[@]}" | jq -R . | jq -s -c .)
-            echo "packages=$JSON" >> $GITHUB_OUTPUT
-          fi
-
-  publish:
-    needs: detect-changes
-    if: needs.detect-changes.outputs.packages != '[]'
-    runs-on: hanzo-build-linux-amd64
-    strategy:
-      # One package's broken build must not withhold every other package's
-      # release: the matrix legs are independent publishes, not one artifact.
-      fail-fast: false
-      matrix:
-        package: ${{ fromJson(needs.detect-changes.outputs.packages) }}
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: pnpm/action-setup@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: Install dependencies
-        run: pnpm install
-
-      - name: Build package
-        # The trailing `...` is load-bearing: it builds the package's WORKSPACE
-        # DEPENDENCIES first, in topological order.
-        #
-        # Without it, `pnpm --filter @hanzo/ui build` runs alone against siblings
-        # that have no `dist/`. Those siblings type themselves through
-        # `"types": "dist/index.d.ts"`, so tsc reports them as missing modules and
-        # the errors do not name the real cause:
-        #   src/product/SiteNav.tsx: Cannot find module '@hanzo/products'
-        #   src/core/tokens.ts:      Cannot find module '@hanzo/tokens'
-        #   src/gitops.ts:           Cannot find module '@hanzo/cd'
-        # plus a wave of implicit-any errors in the files that imported them,
-        # which read like a source problem in @hanzo/ui and are not.
-        run: pnpm --filter ${{ matrix.package }}... build
-
-      - name: Provision bun (only for a package whose test script asks for it)
-        # @hanzo/canvas declares `bun test` and this runner has no bun, so its
-        # suite has been `spawn ENOENT` on every run — which fails the leg before
-        # the publish and is why canvas has sat at 0.2.2 here against 0.2.1 on
-        # npmjs. The step that exists to stop an untested release was itself the
-        # thing stopping the release.
-        #
-        # Read from the package's OWN manifest, not from a list here, so a
-        # package that adopts or drops bun needs no edit to this file. A package
-        # that does not ask for bun does not pay for it.
-        run: |
-          set -euo pipefail
-          PKG_DIR=$(pnpm --filter ${{ matrix.package }} exec pwd | tail -1)
-          if ! jq -r '.scripts.test // ""' "$PKG_DIR/package.json" | grep -qw bun; then
-            echo "::notice::${{ matrix.package }} does not run bun"
-            exit 0
-          fi
-          if command -v bun >/dev/null 2>&1; then
-            echo "bun already on PATH: $(bun --version)"
-            exit 0
-          fi
-          # From npmjs, not bun.sh/install: this job already reaches the npm
-          # registry (it is what the job exists to publish to) and setup-node
-          # already put the global bin on PATH, so this adds no new host to
-          # trust and no new failure mode. The shell installer would also want
-          # unzip, which a minimal runner image need not carry.
-          npm install -g bun
-          bun --version
-
-      - name: Test package
-        # A published version is IMMUTABLE, so this is the last point at which a
-        # defect costs nothing. Nothing else runs a package's own tests before it
-        # ships: ci.yml's test job runs `cd pkgs/ui && …` — that one directory —
-        # and this workflow went checkout → build → publish. So @hanzo/event's
-        # suite, which pins the version the client stamps on every event, ran in
-        # no workflow that gates a release, and the stale stamp it was written to
-        # catch could still have reached npmjs.
-        #
-        # `--if-present` so a package with no test script is skipped rather than
-        # failing the release: the set of testable packages is read from each
-        # package.json, not listed here, so a new package is covered the day it
-        # adds a `test` script.
-        #
-        # This step needs `test` to mean the same thing in every package — the
-        # package's own suite, no browser, no network. @hanzo/ui briefly chained
-        # its two CONSUMER suites onto it (pack a tarball, npm-install it into a
-        # throwaway app, drive it in chromium), which is a real gate and belongs
-        # exactly where hanzo.yml already runs it: on the push, in its own
-        # `ui-consumer` job, next to the `playwright install` that gives it a
-        # browser. Here there is no such step, so a chained `test` could only
-        # fail — the last gate before an immutable version would have been one
-        # that cannot pass, which is the failure mode this repo has already paid
-        # for twice.
-        run: pnpm --filter ${{ matrix.package }} run --if-present test
-
-      - name: Verify the tarball carries what package.json promises
-        # `types` is a PROMISE to every consumer, and tsup writes dist/*.mjs in a
-        # separate pass from dist/*.d.ts — so a declaration failure yields a
-        # package whose JS is fine and whose types are absent. That is invisible
-        # here and surfaces in dependents as "Could not find a declaration file".
-        #
-        # Asserted from the package's OWN manifest, so it holds for every package
-        # this workflow publishes and needs no per-package list.
-        run: |
-          set -euo pipefail
-          PKG_DIR=$(pnpm --filter ${{ matrix.package }} exec pwd | tail -1)
-          TYPES=$(jq -r '.types // .typings // empty' "$PKG_DIR/package.json")
-          if [ -z "$TYPES" ]; then
-            echo "::notice::${{ matrix.package }} declares no types entrypoint — nothing to verify"
-            exit 0
-          fi
-          if [ ! -f "$PKG_DIR/$TYPES" ]; then
-            echo "::error::${{ matrix.package }} declares types at $TYPES but the build produced no such file."
-            echo "::error::Publishing would ship a package that silently has no types. Fix the declaration build."
-            exit 1
-          fi
-          echo "types present: $TYPES"
-
-      - name: Fetch the npm token from KMS
-        id: npmtok
-        # publish.yml used secrets.NPM_TOKEN, which exists on NEITHER the hanzoai
-        # org nor this repo on git.hanzo.ai. An absent secret interpolates to the
-        # empty string rather than failing, so every publish reached npmjs
-        # unauthenticated and 401'd -- the reason @hanzo/ui has never shipped from
-        # CI and each release was a hand publish.
-        #
-        # KMS is where a secret lives, so the token is read at run time from the
-        # same org path and with the same machine identity every other workflow
-        # here already uses. Nothing new to rotate, and no npm credential is
-        # stored on the forge.
-        env:
-          KMS_CLIENT_ID: ${{ secrets.KMS_CLIENT_ID }}
-          KMS_CLIENT_SECRET: ${{ secrets.KMS_CLIENT_SECRET }}
-          KMS_ENDPOINT: ${{ vars.KMS_ENDPOINT || 'https://kms.hanzo.ai' }}
-          KMS_ORG: ${{ vars.KMS_ORG || 'hanzo' }}
-          KMS_SECRET_ENV: ${{ vars.KMS_SECRET_ENV || 'prod' }}
-          # Where the token actually lives, MEASURED: NPM_TOKEN sits at the org
-          # root, not under deploy/ (which holds CLOUDFLARE_*, GIT_TOKEN,
-          # KUBECONFIG, UNIVERSE_PIN_TOKEN). Empty means root; set the
-          # KMS_NPM_PATH variable to move it without editing this file.
-          KMS_NPM_PATH: ${{ vars.KMS_NPM_PATH || '' }}
-        run: |
-          token=$(curl -fsS "${KMS_ENDPOINT}/v1/kms/auth/login" \
-            -H 'Content-Type: application/json' \
-            -d "{\"clientId\":\"${KMS_CLIENT_ID}\",\"clientSecret\":\"${KMS_CLIENT_SECRET}\"}" \
-            | jq -r '.accessToken // empty')
-          if [ -z "${token}" ]; then
-            echo "::error::KMS login failed at ${KMS_ENDPOINT}/v1/kms/auth/login (check KMS_CLIENT_ID/KMS_CLIENT_SECRET)."
-            exit 1
-          fi
-          # The read is org-scoped by the TOKEN's owner claim, not by a path
-          # segment: the flat form is the contract cloud's embedded KMS serves,
-          # and it answers {name, env, value}. The older
-          # /v1/kms/orgs/<org>/secrets/... form with .secret.value 404s here.
-          secret_url="${KMS_ENDPOINT}/v1/kms/secrets/${KMS_NPM_PATH:+${KMS_NPM_PATH}/}NPM_TOKEN?env=${KMS_SECRET_ENV}"
-          # No -f: a 404 must report WHICH path was empty, not just exit 22.
-          npm_token=$(curl -sS "${secret_url}" -H "Authorization: Bearer ${token}" | jq -r '.value // empty')
-          if [ -z "${npm_token}" ]; then
-            echo "::error::No NPM_TOKEN at ${secret_url}."
-            echo "::error::Put it there, or set the KMS_NPM_PATH variable to the path that has it."
-            exit 1
-          fi
-          # Masked before it is ever an output, so it cannot surface in a log.
-          echo "::add-mask::${npm_token}"
-          echo "token=${npm_token}" >> "$GITHUB_OUTPUT"
-
-      - name: Publish package
-        # Idempotent on purpose: the desired state is "npmjs holds this version", and
-        # a version already there satisfies it. Versions are immutable, so a conflict
-        # means the release already happened (a re-run, or a hand publish) — that is
-        # success, not a failure. Every other error still fails the job.
-        env:
-          NODE_AUTH_TOKEN: ${{ steps.npmtok.outputs.token }}
-        run: |
-          set -o pipefail
-          OUT=$(pnpm --filter ${{ matrix.package }} publish \
-            --no-git-checks --access public 2>&1) || true
-          echo "$OUT"
-          case "$OUT" in
-            *EPUBLISHCONFLICT*|*"cannot publish over"*|*"previously published versions"*)
-              echo "::notice::${{ matrix.package }} is already on npmjs at this version — nothing to do" ;;
-            *)
-              # Not a conflict: confirm the version really landed, else fail loudly.
-              #
-              # RETRIED, because npmjs is read-after-write eventually consistent
-              # and this asked it exactly once, about two seconds after the
-              # write. On run 26906 both @hanzo/og@1.0.0 and @hanzo/shop@1.0.0
-              # failed here having printed npm's own `+ @hanzo/og@1.0.0` success
-              # line moments earlier, and both are on the registry now: the
-              # publishes worked and the check was simply too early.
-              #
-              # A false red here is worse than a slow green. It reports that a
-              # release did not happen when it did, so the next person bumps the
-              # version to "fix" it and burns a number over a replication lag —
-              # and the real signal, a publish that genuinely failed, becomes
-              # indistinguishable from the noise.
-              PKG_DIR=$(pnpm --filter ${{ matrix.package }} exec pwd | tail -1)
-              NAME=$(jq -r '.name' "$PKG_DIR/package.json")
-              WANT=$(jq -r '.version' "$PKG_DIR/package.json")
-              landed=
-              for attempt in 1 2 3 4 5 6; do
-                if npm view "$NAME@$WANT" version >/dev/null 2>&1; then landed=1; break; fi
-                echo "$NAME@$WANT not visible to npmjs yet (attempt $attempt/6); waiting 10s"
-                sleep 10
-              done
-              [ -n "$landed" ] \
-                || { echo "::error::$NAME@$WANT is not on npmjs 60s after publish"; exit 1; }
-              echo "published $NAME@$WANT" ;;
-          esac
-
-      - name: Publish to the Hanzo registry
-        # Second home for the same tarball: api.hanzo.ai/v1/packages/hanzo/npm, our
-        # own registry (hanzoai/git), so an install does not have to reach npmjs.
-        # Same artifact, same version — this republishes what the step above just
-        # built, it does not rebuild or re-version.
-        #
-        # BEST-EFFORT by construction. No token ⇒ skip with a notice, so this can
-        # land before the credential exists and starts working the moment it does.
-        # An already-published version is a success, not a failure: the registry
-        # holding it is the desired state either way. npmjs is authoritative and is
-        # never affected by anything here.
-        env:
-          # REGISTRY_TOKEN is the fleet-wide name (six other workflows use it and
-          # the hanzoai org carries it). This asked for HANZO_REGISTRY_TOKEN, which
-          # is defined nowhere, so it read as empty and the step below took its
-          # "not set" branch and exited 0 on every run -- the mirror to
-          # api.hanzo.ai has never happened, and said so only as a notice.
-          HANZO_REGISTRY_TOKEN: ${{ secrets.REGISTRY_TOKEN }}
-        run: |
-          set -uo pipefail
-          if [ -z "${HANZO_REGISTRY_TOKEN:-}" ]; then
-            echo "::notice::HANZO_REGISTRY_TOKEN not set — package published to npmjs only."
-            echo "::notice::Add it (a Hanzo Git token with package:write) to mirror to api.hanzo.ai."
-            exit 0
-          fi
-          REG=https://api.hanzo.ai/v1/packages/hanzo/npm/
-          NPMRC="$RUNNER_TEMP/.npmrc-hanzo"
-          {
-            echo "@hanzo:registry=${REG}"
-            echo "//api.hanzo.ai/v1/packages/hanzo/npm/:_authToken=${HANZO_REGISTRY_TOKEN}"
-          } > "$NPMRC"
-          out=$(npm_config_userconfig="$NPMRC" \
-                pnpm --filter ${{ matrix.package }} publish \
-                  --no-git-checks --access public --registry "$REG" 2>&1) || true
-          echo "$out"
-          case "$out" in
-            *EPUBLISHCONFLICT*|*"cannot publish over"*|*"already exists"*)
-              echo "::notice::already in the Hanzo registry at this version — nothing to do" ;;
-            *) echo "$out" | grep -qiE 'error|failed' \
-                 && echo "::warning::mirror to api.hanzo.ai failed (npmjs publish unaffected)" \
-                 || echo "mirrored to the Hanzo registry" ;;
-          esac

.prettierignore

@@ -6,9 +6,3 @@ build
 **/fixtures
 deprecated
 apps/v4/registry/styles/**/*.css
-
-# Byte-coupled: hz.js carries the marked region of src/anon.js VERBATIM, and
-# pkgs/event/src/anon.test.ts compares them byte for byte. Reformatting either
-# one alone breaks the build; the same region is also vendored by hanzoai/cloud.
-pkgs/event/src/anon.js
-pkgs/event/hz.js

CONSOLIDATION.md

@@ -80,7 +80,7 @@ The brief's premise (`globals.css` `t_dark`/`t_light` token blocks) is **correct
 |---|---|---|
 | Calm dark-first tokens (surface, text, accent `#60a5fa`, tag tones) — raw hex, theme-config independent | `pkg/data/src/theme.ts` | `@hanzo/ui` (top-level `tokens`/`TAG_TONES`/`tagTone`) |
 | OKLCH shadcn-compatible palette (soft-charcoal `oklch(0.145 0 0)`, `--radius: 0.5rem`, indigo sidebar accent) | `pkgs/ui/style/hanzo-default-colors.css`, `@hanzo/tokens` | unchanged (legacy shadcn line); the gui line uses the hex tokens above |
-| **Motion vocabulary** — `fade-up` (FadeIn), `collapse`/`slide`/`fade` (shell/drawer), `drag`, `skeleton`/`pulse`/`row-in`; all `prefers-reduced-motion`-guarded | `console2/app/globals.css` (motion section) | **`@hanzo/ui/styles/motion.css`** (verbatim) — `import '@hanzo/ui/styles/motion.css'` once at app root |
+| **Motion vocabulary** — `hz-fade-up` (FadeIn), `hz-collapse`/`hz-slide`/`hz-fade` (shell/drawer), `hz-drag-item`, `hz-skeleton`/`hz-pulse`/`hz-row-in`; all `prefers-reduced-motion`-guarded | `console2/app/globals.css` (motion section) | **`@hanzo/ui/styles/motion.css`** (verbatim) — `import '@hanzo/ui/styles/motion.css'` once at app root |
 
 ### D. Generic DocType renderer → `@hanzo/ui`  ⏳ (Step 3, FINAL — active lane)
 
@@ -125,7 +125,7 @@ These import app `~/lib`/session/router/branding and must be made presentational
 
 New in **`pkg/ui`** (was a bare `src/` staging dir — no package):
 
-- `package.json` — `@hanzo/ui` `8.0.0`, source-published (`files: ["src"]`, exports map to `.ts`), peers `@hanzo/gui >=7.2.2`, `@hanzo/data >=1.2.0`, `react >=19`; MIT (repo `LICENSE.md`). Exports: `.`, `./product`, `./data`, `./primitives/bases/data`, `./styles/motion.css`.
+- `package.json` — `@hanzo/ui` `8.0.0`, source-published (`files: ["src"]`, exports map to `.ts`), peers `@hanzo/gui >=7.2.2`, `@hanzo/data >=1.2.0`, `react >=19`; BSD-3-Clause. Exports: `.`, `./product`, `./data`, `./primitives/bases/data`, `./styles/motion.css`.
 - `src/index.ts` — top-level barrel (product layer + tokens).
 - `src/product/index.ts` — product barrel; **collision-free** (Charts `Sparkline`/`Donut` canonical; Metric's → `MetricSparkline`; standalone ring → `DonutRing`; `ComboOption` from the one filter module) — **zero loss**.
 - `src/data.ts` — `export * from '@hanzo/data'` (the record layer, one home).
@@ -137,7 +137,7 @@ New in **`pkg/ui`** (was a bare `src/` staging dir — no package):
 
 ## Clean-room guarantee (preserved)
 
-`pkg/data` audited for GPL/Twenty contamination: **none.** No GPL, no copied license headers/SPDX, no Twenty entity/decorator architecture. The field/record model is an independent `FieldType` union + `FieldDefinition` + runtime `Map` registry (records are plain `Record<string, unknown>`). "Twenty" appears **only as benchmark prose** ("Airtable/Twenty-class polish, clean-room"). License: MIT (repo `LICENSE.md`). `@hanzo/ui` inherits the same posture.
+`pkg/data` audited for GPL/Twenty contamination: **none.** No GPL, no copied license headers/SPDX, no Twenty entity/decorator architecture. The field/record model is an independent `FieldType` union + `FieldDefinition` + runtime `Map` registry (records are plain `Record<string, unknown>`). "Twenty" appears **only as benchmark prose** ("Airtable/Twenty-class polish, clean-room"). License: BSD-3-Clause. `@hanzo/ui` inherits the same posture.
 
 ---
 

CONTRIBUTING.md

@@ -12,9 +12,7 @@ This repository is a monorepo.
 
 - We use [pnpm](https://pnpm.io) and [`workspaces`](https://pnpm.io/workspaces) for development.
 - We use [Turborepo](https://turbo.build/repo) as our build system.
-- Releases are semver-driven: bump a package's `version` in its `package.json` and
-  merge to `main`. CI (`.github/workflows/publish.yml`) detects the version change
-  and publishes that package to npm. One step, one source of truth.
+- We use [changesets](https://github.com/changesets/changesets) for managing releases.
 
 ## Structure
 

DESIGN.md

@@ -6,12 +6,9 @@ Change a value here; apps converge on it. This file is that source of truth for
 three things that must read as **one product**: typography, the sidebar/panel system,
 and the dark-black palette.
 
-> One library: **`@hanzo/ui@8`** (`pkg/ui`, on **`@hanzo/gui`**) IS the component
-> library — the cross-platform product/record layer every surface consumes.
-> **`@hanzo/ui-shadcn`** (`pkgs/ui`) is the legacy shadcn/Tailwind/Radix kit, kept
-> only for existing v5 consumers (pin `@hanzo/ui-shadcn@^5`; no new adoptions).
-> This file stays the source of truth for the *token values* (fonts, dark palette,
-> the sidebar glyph) both render.
+> Two design systems, do not confuse them: **`@hanzo/ui`** = shadcn/ui + Tailwind +
+> Radix (this repo). **`@hanzo/gui`** = the Tamagui/RN system (hanzo console). They
+> share these *token values* (fonts, dark palette, the sidebar glyph), not code.
 
 ---
 

Dockerfile

@@ -1,97 +0,0 @@
-# ui.hanzo.ai — the @hanzo/ui docs + component registry, served by the house
-# static server (ghcr.io/hanzoai/static, a Go binary), same as every other Hanzo
-# static site. Built on our own runners, never on a laptop and never by a
-# third-party builder.
-#
-# The app is a Next.js static export: `pnpm build` in app/ writes app/out, which
-# is the entire site — docs, the registry JSON the CLI reads, and the static
-# /api/registry/*.json index.
-FROM node:22 AS builder
-WORKDIR /src
-
-ENV NEXT_TELEMETRY_DISABLED=1
-
-# Publishable ingest key (pk-…), baked in at build because a static export has no
-# server to read config at runtime. Write-only and HMAC-verified to one org, so it
-# is safe in a public bundle; the deployment that builds decides which org the
-# site reports as.
-#
-# ONE name, end to end: KMS holds `deploy/PUBLISHABLE_KEY`, hanzo.yml declares it
-# as this image's build_secret, and the KMS name IS the build-arg name. NEXT_PUBLIC_
-# is added HERE because that prefix is what makes Next inline it — the app reads
-# process.env.NEXT_PUBLIC_PUBLISHABLE_KEY.
-#
-# Do NOT re-declare `ARG NEXT_PUBLIC_PUBLISHABLE_KEY` after the ENV below. A later
-# ARG of the same name shadows the ENV with its own (empty) default, and the build
-# stays green while the bundle ships blank — which is exactly how hanzo.chat 1.0.58
-# shipped a keyless site from a fully green run.
-#
-# Fail CLOSED, on BOTH ways this goes wrong.
-#
-#   empty   — builds, serves and looks correct while cloud answers
-#             `401 ingest_key_required` for every anonymous pageview. The previous
-#             `ARG …=""` default made that the normal outcome of an unattended
-#             build, which is why no automated lane could ever publish a working
-#             image.
-#   `pk_…`  — the OLDER key format. v5.7.6 shipped one, passed by hand on a local
-#             `docker build`, and it is now dead: api.hanzo.ai 401s it on both the
-#             fetch and beacon transports. A hand-passed key goes stale in silence,
-#             so requiring the current `pk-` shape refuses the stale one outright.
-#
-# Neither failure is visible from outside the artifact, so refuse the artifact.
-ARG PUBLISHABLE_KEY
-ENV NEXT_PUBLIC_PUBLISHABLE_KEY=$PUBLISHABLE_KEY
-RUN case "$PUBLISHABLE_KEY" in \
-      pk-*) : ;; \
-      '')   echo "PUBLISHABLE_KEY is empty - pass --build-arg PUBLISHABLE_KEY=<pk-...> (KMS deploy/PUBLISHABLE_KEY, env prod)" >&2; exit 1 ;; \
-      *)    echo "PUBLISHABLE_KEY is not a publishable key (expected a pk- prefix)" >&2; exit 1 ;; \
-    esac
-# 300+ prerendered pages; the default heap is not enough.
-ENV NODE_OPTIONS=--max-old-space-size=8192
-
-RUN corepack enable
-
-COPY . .
-
-# The lockfile is committed, so the build resolves exactly what was reviewed.
-RUN pnpm install --frozen-lockfile
-
-# Workspace packages the app imports must be built first: their package.json
-# exports point at dist/. Only @hanzo/event qualifies -- .npmrc sets
-# link-workspace-packages=true and the lockfile resolves it to link:../pkgs/event.
-#
-# There used to be a `cd pkgs/ui` line here. pkgs/ui was @hanzo/ui-shadcn, deleted
-# in 5dbdb2943 when shadcn was consolidated to one home, and that commit did not
-# touch this file -- so every build since has run `cd` into a directory that does
-# not exist and died with exit code 2 before compiling anything. The app takes
-# @hanzo/ui from the registry now (npm:@hanzo/ui-shadcn@^5), not the workspace.
-RUN cd pkgs/event && pnpm build
-
-# Builds the component registry, then the site (app/package.json build script).
-#
-# ...and then PROVES the key reached the client bundle. The gate above proves a
-# key was PASSED; only this proves it was INLINED. Those are different failures:
-# a rename on either side of `process.env.NEXT_PUBLIC_PUBLISHABLE_KEY` leaves the
-# build-arg intact and the bundle keyless, and a static export cannot report that
-# at runtime because there is no runtime.
-#
-# `&&`, never `;` — a `;` chain returns the LAST command's status, so a failed
-# build followed by a passing grep exits 0 and the image is published.
-RUN cd app && pnpm build && \
-    if [ -z "${NEXT_PUBLIC_PUBLISHABLE_KEY}" ]; then \
-      echo "ERROR: NEXT_PUBLIC_PUBLISHABLE_KEY is empty after a successful build." >&2; exit 1; \
-    elif grep -rqF "${NEXT_PUBLIC_PUBLISHABLE_KEY}" out; then \
-      echo "Build OK - ingest key inlined into app/out, verified"; \
-    else \
-      echo "ERROR: key supplied but NOT present in app/out - ui would ship unattributed" >&2; exit 1; \
-    fi
-
-# 0.5.1 serves a directory's index.html in place. On 0.4.1 every page 301'd to
-# an explicit /index.html, which leaks that filename into the address bar and
-# into the URLs Next builds for its route prefetches.
-FROM ghcr.io/hanzoai/static:0.5.2-amd64
-COPY --from=builder /src/app/out /public
-EXPOSE 3000
-# No -spa: the export writes a real index.html per route (trailingSlash), so a
-# missing path must 404 rather than silently render the home page.
-ENTRYPOINT ["/static", "-port", "3000", "-root", "/public"]

LLM.md

@@ -1,307 +1,10 @@
-# @hanzo/ui — LLM context
+# Hanzo UI - LLM Context
 
-**What this is.** The React component library for AI applications: 161+
-components, 24+ blocks, two themes, and a single typed import surface, all on ONE
-substrate (`@hanzo/gui`) so the same import runs on web, native and desktop.
-Published as `@hanzo/ui` (v8) on npm. Docs at https://ui.hanzo.ai. Dev port: 3003.
+## Overview
 
-**Canonical role.** This is the canonical impl repo for Hanzo's web UI kit —
-frontend components, not an SDK. It sits alongside the two SDK lines (full cloud
-SDK generated from OpenAPI in `hanzo-<lang>/sdk` + wrapper in `hanzoai/<lang>-sdk`;
-AI/agents lib `hanzo` in `hanzoai/python-sdk` flagship, `@hanzo/ai` in `hanzo-js/ai`).
-`@hanzo/event` (telemetry, `POST /v1/event`) lives here in `pkgs/event`. DRY: one
-impl, one place — link out, never duplicate.
+React component library (shadcn/ui fork). 161 components, 24+ blocks, two themes, multi-framework. Published as `@hanzo/ui` on npm.
 
-**Brand rules (hard).**
-- Never call Hanzo an "LLM gateway" or position it against LiteLLM — it is a full
-  AI SDK / AI cloud, not a proxy. Purge that framing on sight.
-- Paths are `/v1/…` only — never an `/api/` prefix.
-- Zen models are our own family — never name upstream models.
-- Voice: "Hanzo — the Open AI Cloud." Developer-first, crisp, no emoji-spam.
-
-**Install / run.**
-```bash
-pnpm add @hanzo/ui         # consume
-# dev:
-pnpm install && pnpm build:registry && pnpm dev   # registry MUST build before app
-```
-
-**Key entry points.** `pkg/ui/` (core lib + v8 subpaths: /product /data /canvas
-/dashboard /usage /gitops) · `app/registry/{default,new-york}/`
-(component SOURCE OF TRUTH) · `pkgs/*` (auto-published `@hanzo/*` packages) ·
-`packages/shadcn/` (CLI) · `app/content/docs/` (MDX docs). Publish = bump a
-package `version` + merge to main (`.github/workflows/publish.yml`).
-
-**Spec / more context.** Canonical SDK + docs model: `~/work/hanzo/SDK-ARCHITECTURE.md`.
-Detailed engineering notes (build order, import surface, telemetry, upstream sync,
-gotchas) follow below.
-
----
-
-## v8 — the canonical `@hanzo/ui` (`pkg/ui`)
-
-`@hanzo/ui@8` (`pkg/ui`) is THE Hanzo component library, and there is ONE
-substrate: every component renders through `@hanzo/gui` (Tamagui) primitives on
-the `@hanzo/tokens` scale, so one import works on web, native (expo) and desktop
-(Tauri). The Radix + Tailwind surface it used to ship alongside is gone — it
-lives on as its own package, `@hanzo/shadcn`, and `@hanzo/ui` no longer depends
-on it, on any `@radix-ui/*` package, on cva, cmdk or sonner.
-
-`@hanzo/ui-shadcn` (`pkgs/ui`, v5.x) is the legacy standalone package —
-superseded, being retired.
-
-### Layout
-
-```
-pkg/ui/src/
-  core/            design core: cn.ts (clsx+tailwind-merge),
-                   tokens.ts (re-export of @hanzo/tokens), fonts.ts (Geist vars)
-  root.tsx         <Hanzo> — the root. Carries the gui config AND the stylesheet.
-  gallery.tsx      EVERY component, once, in every variant. The one list.
-  theme.css        SELF-CONTAINED token CSS vars + Geist Sans/Mono — the identity
-  backends/gui/    THE component surface on @hanzo/gui. index.ts is its manifest.
-  product/         the product/app layer (charts, PageHeader, ComboBox, …)
-  models/          the unified ModelSelector + catalog helpers
-  primitives/      GENERATED per-member entrypoints (scripts/gen-primitives.mjs)
-  index.ts         root barrel = the component surface + cn
-```
-
-### Out of the box — the package carries its own config and its own CSS
-
-```tsx
-import { Hanzo, Button } from '@hanzo/ui'
-<Hanzo><Button>Ship</Button></Hanzo>
-```
-
-That is the entire setup. No `gui.config.ts`, no CSS import, no generator script.
-Three things used to be each app's job:
-
-1. **The stylesheet.** gui compiles a style prop to an atomic class the first
-   time something RENDERS it, so the sheet does not exist until a render has
-   happened — which is why every app ran a `gen-gui-css.mjs` of its own. hanzo.app
-   never did: it shipped 103 `_bg-` classes and 26 `_dsp-` classes against a
-   stylesheet containing ZERO of either, every gui-styled element unstyled in
-   production, green build throughout. The render happens at OUR publish time now
-   (`scripts/gen-css.mjs` renders `src/gallery.tsx` in both themes and writes
-   `dist/styles.css` — 381 KB, 35 KB gzipped, 340 atomic selectors), and
-   `<Hanzo>` imports it. Styles gui generates at RUNTIME for props we could not
-   know at publish time still reach the document through `insertStyleRules`;
-   the shipped sheet is what makes the FIRST paint and every SSR/static render
-   correct.
-
-2. **The config.** `<Hanzo>` passes `config` from `gui-config.ts` to
-   `GuiProvider` — as a VALUE, never a bare `import './gui-config'`. Vite 8
-   (rolldown) ignores package.json `sideEffects` ARRAYS outright: with any array
-   the registration is dropped and the first render dies on "Missing hanzogui
-   config"; only `sideEffects: true` keeps it, and that costs +63% bundle
-   (404 KB → 661 KB measured). Correctness does not live in bundler metadata.
-
-3. **The theme.** gui throws `Missing theme.` for any component with no root
-   theme context, so a root is structurally required — there is no version of
-   this with no root at all. Forgetting `<Hanzo>` is therefore a hard crash on
-   first paint, never a silently unstyled page.
-
-`theme.css` is dark-first at `:root` (it used to claim dark-first while shipping
-LIGHT at `:root`, so an app that mounted the dark default and read `--background`
-got white). `.light` retunes, and both answer to gui's own `.t_light`/`.t_dark`
-that `<Hanzo>` stamps on the body — one theme, named the same by the CSS custom
-properties and the component tokens.
-
-### Three tests, one list of components
-
-`src/gallery.tsx` is the specification of "what this package has to style", and
-all three layers render THAT — a second copy of the list is how a component gets
-styled by one and missed by another.
-
-| Layer | Command | What it catches |
-|---|---|---|
-| `src/styles.test.tsx` | `pnpm test:unit` | every atomic class the gallery renders vs every class `dist/styles.css` defines a rule for. Not "the intersection is large" — TOTAL. Catches a stale sheet. |
-| `src/backends/gui/render.test.tsx` | `pnpm test:unit` | the surface mounts under the real provider; a component that throws on first paint fails. |
-| `test/consumer.spec.ts` | `pnpm test:consumer` | packs the tarball, installs it into a temp app OUTSIDE the repo (never a workspace link — that hides `files`/`exports`/`workspace:*` defects), builds, serves, and asserts COMPUTED styles + screenshots at 390 and 1280 in both themes. |
-
-The consumer spec also fails on a solid-white border (the `@hanzo/design`
-`border-card: var(--white…)` defect — borders are low-alpha hairlines) and on any
-element that has a text child and a zero-height box.
-
-### House rules for a component
-
-- Style through gui props and theme tokens (`$background`, `$color12`,
-  `$borderColor`) — never a utility class string, never a hard-coded font.
-- Touch targets meet the 44px floor via `hitSlop`, never via padding.
-- Behaviour (focus, portalling, keyboard, a11y) comes from the matching
-  `@hanzogui/*` primitive; nothing reimplements it.
-- Free-form text children go through `ink()`; `data-slot` markers through
-  `slot()`. One helper each, one place.
-- Module scope stays side-effect free — `forwardRef`/`createContext` calls carry
-  `/* @__PURE__ */` and nothing assigns `displayName`, so importing one symbol
-  never drags a neighbour in. A one-symbol import bundles ~4.7KB against ~29KB
-  for the whole barrel.
-- Utility classes carry `hz-`. This sheet used to claim `.row`, `.skeleton`,
-  `.fade`, `.mono`, `.drag` and `.tnum` at the document level, in a package an
-  app imports once at its root; an app with its own `.row` got no warning, it got
-  whichever rule the cascade preferred. The unprefixed selectors survive as
-  aliases on the same rules for one minor version and are **REMOVED IN 8.1.0**.
-  Nothing here emits them — `styles.test.tsx` scans every `className=` literal in
-  `src/` and fails on an unprefixed one. `glass`/`elevation-N` are the one family
-  still bare: they are an API VALUE (`glass(3).className`), not a typed literal,
-  so they move on their own change.
-- A prop must actually arrive. gui is not the DOM, and two measured cases prove
-  it in both directions: **`name` is gui's OWN prop** (it names a styled component
-  and a theme) and is consumed before it reaches the element, so a `name` on a
-  field type-checks and renders nothing; and gui **drops `secureTextEntry` on
-  web**, which is why masking needs BOTH spellings via `masked()` in
-  `backends/gui/mask.ts` and why `<Input type="password">` rendered passwords in
-  PLAIN TEXT until 8.0.61 (the wrapper destructured `type` out and never
-  forwarded it, next to an eye offering to reveal what was already visible).
-  Render it and read the markup before you believe a prop works.
-
-### Subpaths
-
-| Subpath | What |
-|---|---|
-| `@hanzo/ui` | the component API: Button, Badge, Card*, Checkbox, Dialog*, DropdownMenu*, Input, Toaster, Avatar*, Tabs*, Select*, Tooltip*, Popover*, Command*, Collapsible*, Resizable*, ScrollArea, Slider, Switch, Progress, Separator, Label, Textarea, AspectRatio — + `cn` (the product layer is kept off root, at `/product`) |
-| `@hanzo/ui/components` | alias of the root surface, for hosts that shim the package through a `declare module` |
-| `@hanzo/ui/product` | the product/app layer: charts, metrics, PageHeader, StatusTag, EmptyState, ComboBox, SlideOver, Toast, Reorder, Field |
-| `@hanzo/ui/models` | ModelSelector + fetchModelCatalog + catalog helpers |
-| `@hanzo/ui/core` · `/tokens` | cn, Geist font vars, the @hanzo/tokens color/theme/radii/spacing scale |
-| `@hanzo/ui/theme.css` | the design tokens alone (custom properties + Geist + touch/elevation) |
-| `@hanzo/ui/styles.css` | the COMPLETE sheet — tokens + motion + the generated gui atomic/theme CSS. `<Hanzo>` imports it, so an app never has to |
-| `@hanzo/ui/gallery` | every component, once — what the generator, the unit test and the consumer test all render |
-| `@hanzo/ui/primitives/<Member>` | per-member entrypoints (for hosts that modularize `@hanzo/ui` imports) |
-| `@hanzo/ui/data` | `@hanzo/data`: RecordsView, DataTable, typed field editors |
-| `@hanzo/ui/{canvas,dashboard,usage,gitops}` | the optional-peer kits (each re-exports its home package) |
-| `@hanzo/ui/product/*` · `/primitives/*` | deep imports — one module without its barrel |
-| `@hanzo/ui/product/pure` | the product layer's RULES with none of the layer (below) |
-| `@hanzo/ui/product/theme-toggle-next` | the `@hanzogui/next-theme` binding, off the barrel on purpose (below) |
-| `@hanzo/ui/css` | `substitute()` — resolve a `var()` chain, for tests jsdom cannot answer (below) |
-
-Everything ships COMPILED from `dist` — every `exports` target is a real file in
-the tarball, including `theme.css` and all 90 `primitives/*` entrypoints.
-`src/dist.test.ts` asserts that against the built output, wildcards included; a
-subpath pointing at a file tsc never emitted is invisible from source.
-
-### Three doors that exist because the barrel is not one
-
-`@hanzo/ui/product` mounts the whole gui runtime to give you one component, and
-for three kinds of caller that is not a cost — it is a wall.
-
-**`@hanzo/ui/product/pure` — the rules, without the layer.** `pages()`,
-`masked()`, `displayName()`, `tone()`, `orgScope`, `filterOptions`,
-`resolveBrand` and the wordmark geometry. Every module it re-exports imports
-NOTHING (`src/dist.test.ts` asserts the closure is empty) and is on
-`postbuild.mjs`'s `DATA` list, so none is stamped `'use client'` — a stamped
-module is a client REFERENCE on React's server layer, and calling `pages()`
-through one in a server component throws instead of paging. It loads under a
-bare `require()` with no transform and no DOM; the test proves it in a child
-node process rather than under vitest, which has vite's transform already
-installed and would prove nothing.
-
-The components import these same modules, so there is one definition and not a
-testable copy of a shipped one.
-
-**`@hanzo/ui/product/theme-toggle-next` — Next, quarantined.**
-`@hanzogui/next-theme`'s provider imports `next/script`, so the product barrel's
-one `export { ThemeToggleNext }` line put Next in the graph of every Vite,
-Express and Tauri host — the hosts this layer promises to run on. A barrel
-re-export is a static edge no bundler can split. It is off the barrel; `<ThemeToggle />`
-with no props still reaches it by dynamic import and degrades when next-theme is
-absent, and `dist.test.ts` asserts BOTH — no static edge, and the dynamic one
-still there, because a test that only asserted the absence would pass on a
-deleted feature. `next` is now an OPTIONAL peer here: next-theme requires it and
-nothing in this package admitted that.
-
-**`@hanzo/ui/css` — `substitute(value, vars?)`.** jsdom does not resolve
-`var()`; it hands a test the text verbatim. The theme rungs are
-`var(--border, rgb(255 255 255 / .10))` on purpose (follow the live cascade
-where design's sheet is mounted, keep the audited literal where it is not), so
-every consumer trying to assert a border's contrast compared a colour to a
-function call. With no `vars` map the answer is exact rather than approximate:
-jsdom mounts no design sheet, so the fallback IS what a browser computes. It is
-NOT part of `@hanzo/ui/core` — that subpath is ESM-only because @hanzo/design
-publishes no `require` condition, and a jest consumer is the caller that needs
-this. Importing nothing is what lets it ship both formats.
-
-### One DropdownMenu
-
-There is one `DropdownMenu`, with one API. It is the compound surface (Trigger,
-Content, Item, CheckboxItem, RadioItem, Label, Separator, Shortcut, Group,
-Portal, Sub*, RadioGroup) AND it accepts the declarative `trigger` + `items`
-spec, which it renders through those very same parts. `@hanzo/ui` and
-`@hanzo/ui/product` export the same component; there is no second shape.
-
-### modularizeImports support
-
-`scripts/gen-primitives.mjs` reads the gui backend barrel and emits one
-`src/primitives/<Member>.tsx` per exported value (re-export from the backend).
-This makes `@hanzo/ui/primitives/Button` etc. resolve, so a host whose
-`next.config` rewrites `@hanzo/ui` → `@hanzo/ui/primitives/{{member}}` works
-unchanged. Re-run `pnpm gen:primitives` after changing the surface.
-
-### Build — plain `tsc`, one file in, one file out
-
-There is no bundler. `pnpm build` is two `tsc` passes, `scripts/postbuild.mjs`,
-then `scripts/gen-css.mjs` (which renders the gallery through vite's SSR pipeline
-to harvest `config.getCSS()` into `dist/styles.css` — the slow step, ~2 min):
-
-| Pass | Config | Emits |
-|---|---|---|
-| ESM + types | `tsconfig.build.json` | `dist/**/*.js`, `.d.ts`, `.js.map`, `.d.ts.map` |
-| CJS | `tsconfig.cjs.json` (`--noCheck`) | `dist-cjs/**/*.js`, folded into `dist/**/*.cjs` |
-
-`postbuild.mjs` does the only two things `tsc` will not: it resolves every
-relative specifier to a fully-specified path (`./button` → `./button.js`,
-`./x` → `./x/index.js`; `.cjs` on the CJS half) so Node ESM and strict bundlers
-resolve, and it prepends `'use client'` to every emitted module — the whole
-library is client-side @hanzo/gui UI and Next's flight-client loader wants the
-directive first. It is prepended without a newline so source-map lines hold.
-
-**`@hanzo/data` runs this same script**, with its package root and its own data
-modules as arguments (`node ../ui/scripts/postbuild.mjs . theme,table/logic,…`).
-It has the same two formats and the same two problems, and a second copy of the
-file would be a second place to get the barrel rule wrong. That package used to
-point its `exports` at `src/index.ts` and ship raw TSX — every consumer had to
-transpile it, and `require('@hanzo/data')` could not load at all, which is one of
-the two edges that broke `require('@hanzo/ui')`. It emits `dist/` now, both
-formats, from 1.2.2.
-
-The output is UNBUNDLED and mirrors `src/` one-for-one, so a consumer importing
-one symbol pulls one module. A bundler here would be actively harmful: tsup's
-code splitting emitted 11 shared `chunk-*.js`, and importing `Button` alone
-dragged in `chunk-RCMDRI6V.js` (48K of source). Measured with esbuild, `import
-{ Button } from '@hanzo/ui'` costs 4717 bytes bundled from tsup output vs 2021
-from `tsc` output. Dropping `rollup-plugin-dts` (tsup's `dts` worker) is also
-what makes the package build on TypeScript 7, which it cannot do otherwise.
-
-Everything under `src/` is emitted, so every `exports` subpath resolves by
-construction — no hand-maintained entry list to drift.
-
-NOTE: `pkg/ui` (singular) sits OUTSIDE the `pkgs/*` pnpm workspace, installs
-standalone, and publishes via the maintainer flow, not `publish.yml`. Because the
-optional-peer kits (canvas/dashboard/gitops/usage) are not on the public
-registry, a standalone install must skip auto-installing peers. `.npmrc` and
-`pnpm-lock.yaml` are gitignored here, so create the `.npmrc` once:
-
-```bash
-cd pkg/ui
-printf 'auto-install-peers=false\nstrict-peer-dependencies=false\n' > .npmrc
-pnpm install --ignore-workspace     # component-surface deps (radix, cmdk, sonner, …) + @hanzo/tokens
-pnpm gen:primitives                 # refresh the per-member entrypoints
-pnpm typecheck:ui                   # scoped typecheck of the component surface (green)
-```
-
-`@hanzo/tokens` (`pkgs/tokens`) must be built first (`pnpm --filter @hanzo/tokens build`)
-so the `file:` link resolves. The scoped `typecheck:ui` excludes the optional-peer
-subpaths, whose homes aren't installed standalone.
-
-The **kits** = canvas, wallet, network, billing, dashboard, usage, gitops, data.
-Add one by mirroring `src/gitops.ts` (a one-line `export *`) + a `./name` export
-+ an optional peer/devDep. `pkg/*` is a pnpm workspace member (for `workspace:*`
-dev links), but `pkg/ui` publishes via the maintainer flow, not `publish.yml`
-(which auto-publishes only `pkgs/*` on a version bump — see PUBLISH_GUIDE.md). The
-shared shell lives here too: `AppHeader` + `BrandMark` (@hanzo/logo) +
-`OrgSwitcher` + `orgScope` (the console org-scope contract, hoisted per #36). Lux
-surfaces use `@luxfi/web3` for wallet/login; `@hanzo/ui/wallet`+`/network` are the
-Hanzo-branded equivalents.
+**Docs**: https://ui.hanzo.ai | **Dev port**: 3003
 
 ## Repository Structure
 
@@ -355,173 +58,14 @@ pnpm lint              # Lint all workspaces
 pnpm typecheck         # Type checking
 pnpm test              # Unit tests
 pnpm test:e2e          # Playwright E2E
+pnpm changeset         # Create changeset for publishing
 ```
 
-## How this ships
-
-One way, and it runs on our own stack:
-
-    push  ->  github.com/hanzoai/ui            (a mirror)
-              .github/workflows/sync.yml        carries refs onward
-      ->  git.hanzo.ai/hanzoai/ui               CANONICAL
-              .hanzo/workflows/ci.yml           lint, typecheck, build, test
-              .hanzo/workflows/registries.yml   the v4 registry check
-              .hanzo/workflows/publish.yml      publishes every pkgs/* package
-              .hanzo/workflows/deploy.yml       builds ghcr.io/hanzoai/ui
-      ->  hanzoai/universe crs/ui.yaml          names the tag that is live
-      ->  hanzoai/operator                      reconciles the App
-      ->  hanzoai/static behind hanzoai/ingress serves ui.hanzo.ai
-
-**git.hanzo.ai is canonical; GitHub is a mirror.** `.github/workflows/` holds
-exactly one file, `sync.yml`, and its only job is getting refs to the forge. Every
-build, check, publish and deploy is a workflow under `.hanzo/workflows/`, which the
-forge reads. `.hanzo/workflows` uses GitHub Actions syntax, so a workflow moves
-between the two by changing directory and nothing else.
-
-No Vercel. `ci.yml` used to end in a `deploy-preview` job that ran `vercel deploy`
-on every PR; previews come from our own stack or not at all, so that job is gone.
-Its `status` job never depended on it.
-
-## Publishing
-
-One way: bump a package's `version` in its `package.json` and merge to `main`.
-`.hanzo/workflows/publish.yml` detects the changed `@hanzo/*` package and publishes
-it to npm (needs `NPM_TOKEN` as a forge secret). No changesets, no version-PR bot
-— the semver bump is the trigger.
-
-It is the SOLE publisher of every non-private `@hanzo/*` in `pkgs/*`, and it
-mirrors the same tarball to `api.hanzo.ai/v1/packages/hanzo/npm` when
-`HANZO_REGISTRY_TOKEN` is present. That mirror is best-effort by construction: no
-token means a notice, not a failure, and npmjs stays authoritative either way.
-
-## Deploying the site
-
-`app/` is a Next.js static export (`output: "export"`, `trailingSlash: true`);
-`pnpm build` there writes `app/out`, which `Dockerfile` copies into
-`ghcr.io/hanzoai/static`. ui.hanzo.ai has been served that way since 2026-07-25 —
-no Cloudflare, no GitHub Pages.
-
-What was missing until now is the build. `crs/ui.yaml` is live and promoted, but no
-workflow ever produced the image it pins: every tag up to `v5.7.6` was pushed by
-hand. `.hanzo/workflows/deploy.yml` is that step. It publishes
-`ghcr.io/hanzoai/ui:<sha>` and stops there — a build never deploys itself. A human
-sets `spec.image.tag` in `hanzoai/universe`
-`infra/k8s/operator/crs/ui.yaml`, which is the one live thing that says which build
-serves.
-
-Coverage lives in `ci.yml`'s `test` job, which runs `pnpm test:coverage` so the
-lcov it uploads to Codecov actually exists. A separate `coverage.yml` used to run
-the same suite a second time for the same upload plus a PR comment through the
-GitHub API; one workflow does it now.
-
-`registries.yml` keeps the `apps/v4` registry honest: reserved namespaces are
-rejected and `pnpm --filter=v4 validate:registries` must pass. Its other job
-labelled and commented on pull requests with the `gh` CLI against the GitHub API,
-which does not exist on the forge, so that job did not come along.
-
-## Telemetry — `@hanzo/event` is the ONE client (`pkgs/event`)
-
-`@hanzo/event` is the single canonical telemetry client for every Hanzo surface.
-ONE API surface over **TWO** planes — the client never sends the org; the server
-resolves the tenant.
-
-1. **Event stream** — pageview/event/identify/group (and an error breadcrumb),
-   batched to `POST {host}/v1/event` with `{ batch: [Event, …] }`
-   `-> { accepted, dropped }`. Tenant from the session or a publishable `pk_` key.
-2. **Error plane** — every captured exception is ALSO framed as a real **Sentry
-   envelope** and POSTed to `POST {dsn.origin}/v1/sentry/{projectId}/envelope/?sentry_key=…`.
-   This is the ONLY thing that reaches the Sentry error dashboard.
-
-> **There is NO server-side fan-out from `/v1/event` into Sentry.** Versions
-> ≤ 0.3.1 claimed there was ("lensed server-side into … error tracking"). There
-> is not: cloud's handler folds the exception into `properties.$exception`,
-> writes one row to the event warehouse (readable via `GET /v1/errors`), and
-> stops. Because every property believed that claim, the whole fleet reported
-> **zero** errors to Sentry until 0.3.2 added the envelope. Do not re-collapse
-> these planes.
-
-Configure the error plane with `dsn` (or `NEXT_PUBLIC_HANZO_EVENT_DSN`), minted
-per property via `POST /v1/sentry/projects`. The DSN key is publishable and
-write-only — safe in a bundle, same trust class as `pk_`. **No DSN => the error
-plane is inert** (fail-safe: nothing sent, nothing thrown, event stream
-unaffected); assert `client.errorPlaneEnabled` if you need to know.
-
-There is NO third plane. Web analytics used to be one — `analytics.hanzo.ai/hz.js`
-posting a bare JSON array of `{site, ts, type, …}` to a second collector behind an
-identical path spelling — and 0.3.7 deleted both. `hz.js` now lives in this package
-as the script-tag DISTRIBUTION of this client: same `WireEvent`, same
-`{ batch: [ … ] }`, same `POST {host}/v1/event`. Point everything at the API host.
-
-It could not authenticate until 0.3.12: it sent no `Authorization` and no
-`?ingest_key=`, so a keyed static surface's writes were unattributed, the door
-refused them (`401`), and nothing in the page said so. `data-ingest-key="pk-…"`.
-
-Entries: `.` (framework-agnostic: `createAnalytics`, `EVENTS`, `GOALS`,
-attribution + DSN/scrub helpers) and `./react` (`AnalyticsProvider`,
-`useAnalytics`, `usePageview`, `ErrorBoundary`). Auto error capture
-(window.onerror / unhandledrejection / React boundary) makes it the drop-in
-error-tracking replacement. Secrets and PII are scrubbed client-side before an
-error leaves the device. SSR-safe, fail-soft, beacon-on-unload.
-
-Build is a tsup dual bundle: **CJS → `.cjs`, ESM → `.mjs`** (required under
-`"type": "module"` — a CJS `.js` is parsed as ESM and crashes `require()` with
-"exports is not defined"). Each `exports` condition carries its own types.
-
-### Interaction analytics — `<Hanzo analytics>` is the one wiring
-
-An app instruments nothing. `<Hanzo analytics>` (`pkg/ui/src/root.tsx`) is the
-whole setup, and every click / change / submit / route change inside the tree
-reaches `POST /v1/event` named by the component it happened on:
-
-```tsx
-<Hanzo analytics={{ product: 'console', ingestKey: process.env.NEXT_PUBLIC_PUBLISHABLE_KEY }}>
-```
-
-Four packages, one of each concern, no duplication:
-
-| Concern | Where | Note |
-|---|---|---|
-| client + wire | `@hanzo/event` (`pkgs/event`) | one endpoint, one key |
-| capture engine | `@hanzo/observe` (`pkgs/observe`) | delegated listeners, semantic annotation, redaction |
-| provider + consent | `@hanzogui/telemetry` (`~/work/hanzo/gui`) | `<TelemetryProvider/>`; owns DNT/GPC + stored choice |
-| curated events | `@hanzo/ui/product` `instrument.ts` | `emit({component, action})` — what autocapture cannot know |
-
-**`analytics` is a prop, not a default.** Mounting a component library must not
-start a network conversation the app did not ask for. Off, no provider renders.
-
-**Component names are real in production.** Every primitive already carries a
-`data-slot` (via `slot()`); `componentName()` in `pkgs/observe/src/annotate.ts`
-reads it, ranked ABOVE the React fiber owner deliberately — the fiber name is
-dev-only, so grouping on it silently empties the dashboard at deploy. Labels keep
-the qualifier: `card/button[Save]`.
-
-**It cannot double-count.** The engine installs *delegated* listeners on a root,
-so two engines on one root report everything twice — which is what an app got by
-mounting a library provider AND `<ObserveProvider/>`, both correct instructions.
-Since observe 0.1.7 the first engine claims its root under a `Symbol.for`
-registry (page-wide, so duplicate copies of the package still see each other) and
-any later one stays inert (`engine.capturing === false`). Verified in Chromium,
-not only in jsdom.
-
-**Consent is decided in ONE layer.** The engine takes `enabled` as a value; the
-provider resolves policy (GPC, DNT, stored `hz_consent`, build kill switch) and
-passes the answer down. Do not add a second, partial copy to the engine — the two
-then disagree about an explicit opt-in.
-
-### One way — supersessions (no divergent telemetry client)
-
-| Package | Status | Note |
-|---|---|---|
-| `@hanzo/event` | **canonical** | `pkgs/event`, posts `/v1/event` only |
-| `@hanzo/capture` (npm) | **deprecated → `@hanzo/event`** | the old name of this package; `@hanzo/event` is a superset |
-| `pkgs/capture` (`@hanzo/analytics@0.1.0` dup) | **deleted** | stale in-repo duplicate, removed |
-| `hanzoai/analytics` `packages/event` (`@hanzo/event@0.2.0`) | **deleted** | An unpublished FORK of this package in another repo. It was the only copy that could actually reach Sentry, while the published one here could not — the fleet's error telemetry died in that gap. Its envelope + scrub implementation was merged here in 0.3.2. Never fork this package again; it publishes from `pkgs/event` only. |
-
 ## Three-Layer Architecture
 
-1. **Components** (`registry/{style}/ui/`) — single primitives (Button, Card, Dialog). CLI-installable.
-2. **Examples** (`registry/{style}/example/`) — usage demos for docs via `<ComponentPreview />`.
-3. **Blocks** (`registry/{style}/blocks/`) — full-page sections (Dashboard, Login). NOT CLI-installable, docs only.
+1. **Components** (`registry/{style}/ui/`) -- Single primitives (Button, Card, Dialog). CLI-installable.
+2. **Examples** (`registry/{style}/example/`) -- Usage demos for docs via `<ComponentPreview />`.
+3. **Blocks** (`registry/{style}/blocks/`) -- Full-page sections (Dashboard, Login). NOT CLI-installable, docs only.
 
 ## Import Path Transformation
 
@@ -550,25 +94,37 @@ React 19, Next.js 15.3+, Tailwind CSS 4 (OKLCH colors), Radix UI, Turborepo + pn
 
 ## Upstream Sync
 
-Remote `shadcn` points to a local clone of shadcn-ui/ui.
-hanzoai/ui is NOT a GitHub fork — no shared object store, so large merges can fail on push.
+Remote `shadcn` points to `/Users/z/work/shadcn/ui` (local clone of shadcn-ui/ui).
+hanzoai/ui is NOT a GitHub fork -- no shared object store, so large merges can fail on push.
+
+Last sync: 2026-03-24 (shadcn@4.1.0, commit 8bec9c123)
 Strategy: file-level checkout from shadcn/main for specific directories (not git merge).
 - Take theirs: packages/shadcn/, packages/tests/, apps/, templates/, scripts/, skills/
 - Keep ours: app/, pkg/, demo/, docs/, template/next/, pnpm-workspace.yaml, package.json
+- Remove: deprecated/ (upstream deleted it)
 - Regenerate: pnpm-lock.yaml after sync
 
 ## Key Features
 
-- **Page Builder** (`/builder`): drag-drop block assembly with @dnd-kit, export to TSX
+- **Page Builder** (`/builder`): Drag-drop block assembly with @dnd-kit, export to TSX
 - **White-Label**: Zoo/Lux forks via `brands/{BRAND}.brand.ts`
 - **External Registries**: 35+ sources in `app/registries.json`, install via `npx @hanzo/ui add @aceternity/spotlight`
 
 ## Gotchas
 
-- Registry index is `Index[style][name]`, NOT `Index[name]` — caused silent block render failures
-- Shiki `getHighlighter` incompatible with static export — replaced with basic pre/code
+- Registry index is `Index[style][name]`, NOT `Index[name]` -- caused silent block render failures
+- Shiki `getHighlighter` incompatible with static export -- replaced with basic pre/code
 - Some blocks (login-01, login-02, sidebar-02) have Server Component issues with event handlers
-- `@hanzo/auth` v2.6.0 uses a pluggable provider registry: `registerAuthProvider('firebase', FirebaseAuthService)`
+- Zod validation removed from `_getAllBlocks()`/`_getBlockCode()` -- we control generation
+- Firebase split to optional `@hanzo/auth-firebase` package (Jan 2025)
+- `@hanzo/auth` v2.6.0 uses pluggable provider registry: `registerAuthProvider('firebase', FirebaseAuthService)`
+
+## Component Stats
+
+- 161 total files, ~127 implemented, ~34 stubs
+- Unique: 9 3D components, 12 AI components, 13 animation components, 15 nav variants
+- 3x more components than upstream shadcn/ui (161 vs 58)
+- shadcn CLI: v4.1.0 with font transformers, chart color picker, scaffold from github
 
 ## Rules
 

PUBLISH_GUIDE.md

@@ -1,39 +1,174 @@
-# Publishing
+# NPM Publishing Guide - React 19 Packages
 
-Two lanes, one trigger each. No changesets, no version-PR bot.
+## Current Package Versions
 
-## 1. `pkgs/*` — auto-publish on version bump (`publish.yml`)
+All packages updated to support **React 19.2.0**:
 
-Bump a package's `version` in `pkgs/<name>/package.json` and merge to `main`.
-`.github/workflows/publish.yml` detects the changed public `@hanzo/*` package,
-builds it, and publishes to npm (repo secret `NPM_TOKEN`). Patch bumps only
-(`x.y.z` → `x.y.z+1`).
+- `@hanzo/ui` - v5.1.1
+- `@hanzo/auth` - Latest
+- `@hanzo/commerce` - Latest
+- `@hanzo/brand` - Latest
+- `@hanzo/react` - v1.0.0
 
-## 2. `pkg/ui` — `@hanzo/ui@8`, the v8 lane (maintainer flow)
+## Publishing Methods
 
-`pkg/ui` (with `pkg/data`) is the modern cross-platform library on `@hanzo/gui`.
-It publishes from the package directory (`prepack` builds the `types/`):
+### 1. Automatic Publishing (Tag-based)
+
+When you push a git tag starting with `v` (typically matching @hanzo/ui version), the workflow automatically checks all packages and publishes any with new versions:
 
 ```bash
+# Tag with @hanzo/ui version (workflow checks all packages)
+git tag v5.1.1
+git push origin v5.1.1
+```
+
+**What happens:**
+1. Tests run (pkg/ui and pkg/react)
+2. All 5 packages build
+3. **Automatic version detection:**
+   - Checks each package's current version in package.json
+   - Queries npm to see if that version already exists
+   - Only publishes packages with new versions not on npm
+4. GitHub release created (only if packages were published)
+
+**Example workflow output:**
+```
+📦 Checking @hanzo/ui@5.1.1
+⏭️  Already published - skipping
+
+📦 Checking @hanzo/auth@2.5.5
+🚀 Publishing to npm...
+✅ Successfully published @hanzo/auth@2.5.5
+
+📊 Publishing Summary
+✅ Published: 1 package(s)
+⏭️  Skipped: 4 package(s)
+```
+
+This approach means you:
+- Only need to tag once (with @hanzo/ui version)
+- Don't need to track which packages need publishing
+- Can bump any package version and it auto-publishes on next tag
+- Similar to python-sdk monorepo publishing
+
+**Workflow:** `.github/workflows/publish-on-tag.yml`
+
+### 2. Manual Publishing (Workflow Dispatch)
+
+Use GitHub Actions UI to manually publish specific packages:
+
+1. Go to **Actions** → **NPM Publish**
+2. Click **Run workflow**
+3. Select package: `ui`, `auth`, `commerce`, `brand`, `react`, or `all`
+4. Select version bump: `patch`, `minor`, or `major`
+5. Click **Run workflow**
+
+**What happens:**
+- Selected package(s) build
+- Version bumped automatically
+- Package(s) published to npm
+- PR created with version bump
+
+**Workflow:** `.github/workflows/npm-publish.yml`
+
+### 3. Local Publishing (Manual)
+
+For quick patches or testing:
+
+```bash
+# Build and test
 cd pkg/ui
-pnpm typecheck && pnpm test && pnpm build
-# bump "version" in package.json (patch), commit to main, then:
+pnpm build
+pnpm test
+
+# Bump version
+npm version patch  # or minor/major
+
+# Publish
 npm publish --access public
 ```
 
-`@hanzo/ui-shadcn` (`pkgs/ui`) is the legacy v5 kit — existing consumers pin
-`@hanzo/ui-shadcn@^5`; it rides lane 1 like any other `pkgs/*` package.
-
-> The old tag-driven flow (`publish-on-tag.yml`, `npm-publish.yml`, the
-> `pkg/commerce|brand|react` paths) is gone — do not tag to publish here.
-
 ## Prerequisites
 
-- `NPM_TOKEN` repo secret (lane 1) / npm auth as a maintainer (lane 2)
-- Every package carries `"publishConfig": { "access": "public" }`
+### NPM Authentication Token
 
-## Checklist
+The GitHub secret `NPM_AUTH_TOKEN` must be set:
 
-- [ ] `pnpm typecheck` + `pnpm test` green in the package
-- [ ] Patch version bump (check the last published patch first)
-- [ ] Commit to `main`; lane 1 publishes on merge, lane 2 via `npm publish`
+1. Generate token at https://www.npmjs.com/settings/tokens
+2. Add to GitHub: Settings → Secrets → Actions → `NPM_AUTH_TOKEN`
+
+### Package Publish Configuration
+
+All packages already configured with:
+```json
+{
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}
+```
+
+## React 19 Compatibility
+
+### Key Updates Made
+
+1. **Type Declarations**: Added `hanzo-ui.d.ts` files for React 19 compatibility
+2. **Peer Dependencies**: Force React 19.2.0 via pnpm overrides
+3. **Test Environment**: Switched to happy-dom for better React 19 support
+4. **Build Configuration**: All packages build successfully with React 19
+
+### Test Status
+
+- **pkg/ui**: 206/207 tests passing (99.5%)
+- **pkg/react**: 10/10 tests passing (100%)
+
+## Publishing Checklist
+
+Before publishing:
+
+- [ ] All packages build successfully: `pnpm build`
+- [ ] Tests pass: `pnpm test`
+- [ ] Types check: `cd app && pnpm typecheck`
+- [ ] Lint passes: `cd app && pnpm lint`
+- [ ] Update CHANGELOG.md
+- [ ] Update version in package.json (if manual)
+- [ ] Commit changes
+
+## Troubleshooting
+
+### Build Failures
+
+```bash
+# Clean install
+rm -rf node_modules pnpm-lock.yaml
+pnpm install
+
+# Rebuild
+pnpm build
+```
+
+### Test Failures
+
+```bash
+# Run specific package tests
+cd pkg/ui && pnpm test
+cd pkg/react && pnpm test
+```
+
+### Publish Failures
+
+- Check NPM_AUTH_TOKEN is valid
+- Ensure version is unique (not already published)
+- Verify package builds: `cd pkg/<name> && pnpm build`
+
+## Package URLs
+
+- npm: https://www.npmjs.com/org/hanzo
+- GitHub: https://github.com/hanzoai/ui
+- Docs: https://ui.hanzo.ai
+
+---
+
+**Last Updated:** 2025-10-05
+**React Version:** 19.2.0

README.md

@@ -1,42 +1,37 @@
-<p align="center"><img src=".github/hero.svg" alt="@hanzo/ui" width="880"></p>
+<p align="center"><img src=".github/hero.svg" alt="ui" width="880"></p>
 
 # @hanzo/ui
 
-**The React component library for AI applications.** Accessible, customizable primitives for React, Vue, Svelte, and React Native — built on shadcn/ui, extended with AI, 3D, animation, and commerce components, and a single typed import surface.
-
-<p align="center">
-  <a href="https://www.npmjs.com/package/@hanzo/ui"><img src="https://img.shields.io/npm/v/@hanzo/ui?color=black&label=%40hanzo%2Fui" alt="npm"></a>
-  <a href="./LICENSE.md"><img src="https://img.shields.io/badge/license-MIT-black" alt="MIT"></a>
-  <a href="https://ui.hanzo.ai"><img src="https://img.shields.io/badge/docs-ui.hanzo.ai-black" alt="docs"></a>
-</p>
+Accessible and customizable components for React, Vue, Svelte, and React Native. **Built on shadcn/ui with multi-framework support, 3D components, AI components, and advanced features.**
 
 ![hero](app/public/og.jpg)
 
 ## Features
 
-- **161+ components** — 3x the surface of upstream shadcn/ui
-- **Multi-framework** — React, Vue, Svelte, React Native
-- **Two themes** — Default & New York variants
-- **AI components** — chat, assistants, agent UI, playground
-- **3D components** — interactive 3D elements
-- **Animations** — advanced motion components
-- **Page builder** — visual drag-and-drop assembly, export to TSX
-- **Blocks** — 24+ production-ready full-page templates
-- **White-label** — fork and rebrand by domain (Zoo, Lux, …)
-- **Accessible** — built on Radix UI primitives
-- **Customizable** — Tailwind CSS 4 (OKLCH), fully typed TypeScript
+- **161+ Components** - 3x more than shadcn/ui
+- **Multi-Framework** - React, Vue, Svelte, React Native
+- **Two Themes** - Default & New York variants
+- **AI Components** - Chat, assistants, playground
+- **3D Components** - Interactive 3D elements
+- **Animations** - Advanced motion components
+- **Page Builder** - Visual drag-drop interface
+- **White-Label** - Fork and rebrand easily
+- **Blocks** - 24+ production-ready templates
+- **Accessible** - Built with Radix UI primitives
+- **Customizable** - Tailwind CSS powered
+- **TypeScript** - Fully typed
 
-## Quick start
+## Quick Start
 
-### Install
+### Installation
 
 ```bash
-pnpm add @hanzo/ui
-# or
 npm install @hanzo/ui
+# or
+pnpm add @hanzo/ui
 ```
 
-### Use
+### Usage
 
 ```tsx
 import { Button, Card, Input } from '@hanzo/ui'
@@ -58,59 +53,23 @@ export function App() {
 }
 ```
 
-## One import surface (v8)
+## Documentation
 
-`@hanzo/ui@8` is the single entry point for the whole kit. Each capability is a
-thin subpath that re-exports its home package — code lives once, and each home is
-an optional peer, pulled only when you use its subpath.
-
-| Import | What you get |
-|---|---|
-| `@hanzo/ui` · `/product` | charts, metrics, PageHeader, StatusTag, EmptyState, ComboBox, SlideOver, Toast |
-| `@hanzo/ui/data` | RecordsView, DataTable, typed field editors |
-| `@hanzo/ui/canvas` | ProjectCanvas, ServiceNode, DeployTimeline, EnvSwitcher |
-| `@hanzo/ui/dashboard` | landing + deploy-pipeline + overview kit |
-| `@hanzo/ui/usage` | UsageMeter, UsageProviderCard, UsageDashboard |
-| `@hanzo/ui/gitops` | GitopsAppList, tree, diff, sync/rollback, HealthBadge |
-
-Also available as granular imports:
-
-```ts
-import { Button, Card } from '@hanzo/ui/components'
-import * as Dialog from '@hanzo/ui/primitives/dialog'
-import { cn } from '@hanzo/ui/lib/utils'
-```
+Visit **[ui.hanzo.ai](https://ui.hanzo.ai)** for full docs.
 
 ## CLI
 
-Add components straight into your project — the CLI copies source you own:
-
 ```bash
 npx @hanzo/ui add button
 npx @hanzo/ui add card dialog
 ```
 
-Install from 35+ external registries too:
-
-```bash
-npx @hanzo/ui add @aceternity/spotlight
-```
-
 ## Packages
 
-The workspace publishes a family of scoped packages under `@hanzo/*`:
-
-| Package | Purpose |
-|---|---|
-| `@hanzo/ui` | Core library + the v8 import surface (161+ components) |
-| `@hanzo/react` | React primitives |
-| `@hanzo/data` | Records, data tables, typed field editors |
-| `@hanzo/canvas` | Service/deploy canvas components |
-| `@hanzo/dashboard` | Dashboard + deploy-pipeline kit |
-| `@hanzo/commerce` · `@hanzo/checkout` · `@hanzo/shop` | Commerce components |
-| `@hanzo/agent-ui` | AI agent UI components |
-| `@hanzo/brand` · `@hanzo/tokens` | Branding system & design tokens |
-| `@hanzo/event` | Telemetry client (`POST /v1/event`) |
+- `@hanzo/ui` - Main UI library (161 components)
+- `@hanzo/auth` - Authentication components
+- `@hanzo/commerce` - E-commerce components
+- `@hanzo/brand` - Branding system
 
 ## Development
 
@@ -118,39 +77,17 @@ The workspace publishes a family of scoped packages under `@hanzo/*`:
 git clone https://github.com/hanzoai/ui.git
 cd ui
 pnpm install
-
-pnpm build:registry   # generate the component registry FIRST
-pnpm dev              # docs site + registry (http://localhost:3003)
+pnpm dev
 ```
 
-> The registry generates the JSON the CLI reads, so `build:registry` must run
-> before `build`. Keep the Default and New York themes in sync when adding
-> components. Use pnpm — not npm or yarn.
-
-```bash
-pnpm build            # build the docs app
-pnpm lint             # lint all workspaces
-pnpm typecheck        # type check
-pnpm test             # unit tests
-pnpm test:e2e         # Playwright E2E
-```
-
-## Documentation
-
-Full docs, live previews, and the component catalog: **[ui.hanzo.ai](https://ui.hanzo.ai)**.
-
 ## Contributing
 
-See the [contributing guide](/CONTRIBUTING.md).
+Please read the [contributing guide](/CONTRIBUTING.md).
 
 ## License
 
-MIT — see [LICENSE.md](./LICENSE.md).
+MIT - See [LICENSE.md](./LICENSE.md) for details.
 
 ---
 
-## Hanzo — the Open AI Cloud
-
-Open source · every language · on-chain settlement. [hanzo.ai](https://hanzo.ai) · [docs.hanzo.ai](https://docs.hanzo.ai)
-
-**SDKs in every language** — [Python](https://github.com/hanzoai/python-sdk) (flagship) · [TypeScript](https://github.com/hanzo-js/sdk) · [Go](https://github.com/hanzo-go/sdk) · [Rust](https://github.com/hanzo-rs/sdk) · [C++](https://github.com/hanzo-cpp/sdk) · [Swift](https://github.com/hanzo-swift/sdk) · [Kotlin](https://github.com/hanzo-kt/sdk) · [umbrella](https://github.com/hanzoai/sdk)
+Built by [Hanzo](https://hanzo.ai)

app/IDENTITY_README.md

@@ -94,7 +94,7 @@ forge script script/DeployIdentitySystem.s.sol:DeployIdentitySystem \
 
 # For Lux Mainnet
 forge script script/DeployIdentitySystem.s.sol:DeployIdentitySystem \
-  --rpc-url https://api.lux.network/v1/bc/C/rpc \
+  --rpc-url https://api.lux.network/ext/bc/C/rpc \
   --broadcast
 
 # For Zoo Mainnet
@@ -131,8 +131,8 @@ Visit `http://localhost:3333/identity` to access the identity registration page.
 |---------|----------|---------|----------|
 | Hanzo Mainnet | 36963 | https://rpc.hanzo.ai | https://explorer.hanzo.ai |
 | Hanzo Testnet | 36962 | https://testnet-rpc.hanzo.ai | https://testnet-explorer.hanzo.ai |
-| Lux Mainnet | 96369 | https://api.lux.network/v1/bc/C/rpc | https://explorer.lux.network |
-| Lux Testnet | 96368 | https://testnet-api.lux.network/v1/bc/C/rpc | https://testnet-explorer.lux.network |
+| Lux Mainnet | 96369 | https://api.lux.network/ext/bc/C/rpc | https://explorer.lux.network |
+| Lux Testnet | 96368 | https://testnet-api.lux.network/ext/bc/C/rpc | https://testnet-explorer.lux.network |
 | Zoo Mainnet | 200200 | https://rpc.zoo.network | https://explorer.zoo.network |
 | Zoo Testnet | 200201 | https://testnet-rpc.zoo.network | https://testnet-explorer.zoo.network |
 

app/app/(app)/identity/identity-form.tsx

@@ -1,6 +1,7 @@
 "use client"
 
 import { useEffect, useState } from "react"
+import { ConnectButton } from "@rainbow-me/rainbowkit"
 import { formatEther } from "viem"
 import {
   useAccount,
@@ -10,7 +11,6 @@ import {
   useWriteContract,
 } from "wagmi"
 
-import { ConnectWallet } from "@/components/connect-wallet"
 import {
   AI_TOKEN_ABI,
   CONTRACT_ADDRESSES,
@@ -208,7 +208,7 @@ export function IdentityForm() {
             </CardDescription>
           </CardHeader>
           <CardContent>
-            <ConnectWallet />
+            <ConnectButton />
 
             {isConnected && aiBalance !== undefined && (
               <div className="mt-4">

app/app/(app)/mcp/page.tsx

@@ -304,7 +304,7 @@ export default function MCPPage() {
             </p>
             <div className="flex gap-4">
               <Button asChild>
-                <Link href="https://discord.gg/CJCyAsm9Vr">Join Discord</Link>
+                <Link href="https://discord.gg/hanzo">Join Discord</Link>
               </Button>
               <Button variant="outline" asChild>
                 <Link href="/docs">Read Documentation</Link>

app/components/analytics.tsx

@@ -1,21 +1,7 @@
 "use client"
 
-import { useEffect, useRef } from "react"
-import { usePathname } from "next/navigation"
-
-import { analytics } from "@/lib/analytics"
+import { Analytics as VercelAnalytics } from "@vercel/analytics/react"
 
 export function Analytics() {
-  const pathname = usePathname()
-  const started = useRef(false)
-
-  useEffect(() => {
-    if (!started.current) {
-      started.current = true
-      analytics.init()
-    }
-    analytics.pageview(pathname ?? undefined)
-  }, [pathname])
-
-  return null
+  return <VercelAnalytics />
 }

app/components/connect-wallet.tsx

@@ -1,40 +0,0 @@
-"use client"
-
-import { useAccount, useConnect, useDisconnect } from "wagmi"
-
-import { Button } from "@/registry/default/ui/button"
-
-const short = (address: string) => `${address.slice(0, 6)}…${address.slice(-4)}`
-
-/**
- * Connect the wallet the browser already has, over EIP-1193. There is no
- * third-party modal and no bridge service in the page — the extension is the
- * only party involved.
- */
-export function ConnectWallet() {
-  const { address, isConnected } = useAccount()
-  const { connect, connectors, isPending } = useConnect()
-  const { disconnect } = useDisconnect()
-
-  if (isConnected && address) {
-    return (
-      <div className="flex items-center gap-3">
-        <span className="font-mono text-sm">{short(address)}</span>
-        <Button variant="outline" size="sm" onClick={() => disconnect()}>
-          Disconnect
-        </Button>
-      </div>
-    )
-  }
-
-  const injected = connectors[0]
-
-  return (
-    <Button
-      onClick={() => injected && connect({ connector: injected })}
-      disabled={!injected || isPending}
-    >
-      {isPending ? "Connecting…" : "Connect Wallet"}
-    </Button>
-  )
-}

app/components/web3-provider.tsx

@@ -1,18 +1,34 @@
 "use client"
 
-import { type ReactNode } from "react"
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
-import { WagmiProvider } from "wagmi"
+import "@rainbow-me/rainbowkit/styles.css"
 
-import { getConfig } from "@/lib/wagmi"
+import { useEffect, useState, type ReactNode } from "react"
+import { RainbowKitProvider } from "@rainbow-me/rainbowkit"
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
+import { WagmiProvider, type Config } from "wagmi"
 
 const queryClient = new QueryClient()
-const config = getConfig()
 
 export function Web3Provider({ children }: { children: ReactNode }) {
+  const [config, setConfig] = useState<Config | null>(null)
+
+  useEffect(() => {
+    // Dynamically import wagmi config only on client side
+    import("@/lib/wagmi").then((mod) => {
+      setConfig(mod.getConfig())
+    })
+  }, [])
+
+  // Don't render until config is loaded
+  if (!config) {
+    return <>{children}</>
+  }
+
   return (
     <WagmiProvider config={config}>
-      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+      <QueryClientProvider client={queryClient}>
+        <RainbowKitProvider modalSize="compact">{children}</RainbowKitProvider>
+      </QueryClientProvider>
     </WagmiProvider>
   )
 }

app/config/site.ts

@@ -8,7 +8,7 @@ export const siteConfig = {
   links: {
     twitter: "https://x.com/hanzoai",
     github: "https://github.com/hanzoai/ui",
-    discord: "https://discord.gg/CJCyAsm9Vr",
+    discord: "https://discord.gg/hanzo",
   },
 }
 

app/lib/analytics.ts

@@ -1,35 +0,0 @@
-import { createAnalytics } from "@hanzo/event"
-
-// One client for the whole site. Pageviews (components/analytics.tsx) and
-// product events (lib/events.ts) share it, so there is a single place that
-// knows where telemetry goes — call sites only name what happened. Host
-// defaults to the one edge (api.hanzo.ai), which is what a static site wants.
-//
-// /v1/event is authed, and deliberately does not trust the request Host — a Host
-// header is spoofable, so a static page proves which org it belongs to by
-// carrying a publishable key. `pk-` keys are write-only and HMAC-verified with no
-// database hop, which is what makes them safe to ship inside a public bundle (the
-// same reason a Sentry DSN is public). The build supplies it, so each deployment
-// reports as the org that deployed it; without one cloud answers
-// `401 ingest_key_required` and every logged-out pageview is dropped in silence.
-//
-// NEXT_PUBLIC_PUBLISHABLE_KEY is the ONE name, and it is the name the fleet
-// already carries end to end: KMS holds `deploy/PUBLISHABLE_KEY`, the Dockerfile
-// takes it as the PUBLISHABLE_KEY build-arg and re-exports it with the
-// NEXT_PUBLIC_ prefix that makes Next inline it.
-//
-// This file used to read NEXT_PUBLIC_HANZO_INGEST_KEY — a spelling nothing in KMS
-// or CI carries, so no builder could ever supply it. A key reached the live bundle
-// exactly once, passed by hand on a local `docker build`, and that is the failure
-// this rename removes: a name only a human can satisfy gets satisfied once and
-// then goes stale silently. The key v5.7.6 shipped (`pk_…`, the older format) is
-// now dead — api.hanzo.ai answers `401 ingest_key_required` for it on both
-// transports, so ui.hanzo.ai has been dropping every logged-out pageview.
-//
-// Written as a full literal on purpose: Next replaces textual `process.env.
-// NEXT_PUBLIC_*` occurrences at build time, so a name assembled at runtime
-// resolves to undefined in a static export.
-export const analytics = createAnalytics({
-  product: "site",
-  ingestKey: process.env.NEXT_PUBLIC_PUBLISHABLE_KEY,
-})

app/lib/events.ts

@@ -1,7 +1,6 @@
+import va from "@vercel/analytics"
 import { z } from "zod"
 
-import { analytics } from "@/lib/analytics"
-
 const eventSchema = z.object({
   name: z.enum([
     "copy_npm_command",
@@ -28,6 +27,11 @@ export type Event = z.infer<typeof eventSchema>
 export function trackEvent(input: Event): void {
   const event = eventSchema.parse(input)
   if (event) {
-    analytics.capture(event.name, event.properties)
+    va.track(
+      event.name,
+      event.properties as
+        | Record<string, string | number | boolean | null>
+        | undefined
+    )
   }
 }

app/lib/highlight-code.ts

@@ -3,9 +3,10 @@ import { promises as fs } from "fs"
 import path from "path"
 import type { Highlighter } from "shiki"
 
-// Highlight on the server while developing. A production build is a static
-// export, which highlights on the client instead — so the build stays cheap.
-const highlightCodeEnabled = process.env.NODE_ENV === "development"
+// Enable syntax highlighting in development
+// For static exports, we can use client-side highlighting instead
+const highlightCodeEnabled =
+  process.env.NODE_ENV === "development" || !process.env.GITHUB_ACTIONS
 
 // Singleton highlighter instance to prevent memory leaks
 let highlighterInstance: Highlighter | null = null

app/lib/wagmi.ts

@@ -1,8 +1,7 @@
 "use client"
 
+import { getDefaultConfig } from "@rainbow-me/rainbowkit"
 import { defineChain } from "viem"
-import { createConfig, http } from "wagmi"
-import { injected } from "wagmi/connectors"
 
 // Localhost (Anvil)
 export const localhost = defineChain({
@@ -77,7 +76,7 @@ export const luxMainnet = defineChain({
   },
   rpcUrls: {
     default: {
-      http: ["https://api.lux.network/v1/bc/C/rpc"],
+      http: ["https://api.lux.network/ext/bc/C/rpc"],
     },
   },
   blockExplorers: {
@@ -99,7 +98,7 @@ export const luxTestnet = defineChain({
   },
   rpcUrls: {
     default: {
-      http: ["https://testnet-api.lux.network/v1/bc/C/rpc"],
+      http: ["https://testnet-api.lux.network/ext/bc/C/rpc"],
     },
   },
   blockExplorers: {
@@ -156,30 +155,28 @@ export const zooTestnet = defineChain({
   testnet: true,
 })
 
-const chains = [
-  localhost,
-  hanzoMainnet,
-  hanzoTestnet,
-  luxMainnet,
-  luxTestnet,
-  zooMainnet,
-  zooTestnet,
-] as const
+let _config: ReturnType<typeof getDefaultConfig> | undefined
 
-type Config = ReturnType<typeof createConfig>
+export const getConfig = () => {
+  if (typeof window === "undefined") {
+    // Return a minimal config for SSR that won't be used
+    return {} as ReturnType<typeof getDefaultConfig>
+  }
 
-let _config: Config | undefined
-
-export const getConfig = (): Config => {
   if (!_config) {
-    _config = createConfig({
-      chains,
-      // The browser wallet speaks EIP-1193 directly. No third-party bridge, no
-      // vendor project id, and nothing phoning home from a docs page.
-      connectors: [injected()],
-      transports: Object.fromEntries(
-        chains.map((chain) => [chain.id, http()])
-      ) as Record<(typeof chains)[number]["id"], ReturnType<typeof http>>,
+    _config = getDefaultConfig({
+      appName: "Hanzo Identity",
+      projectId:
+        process.env.NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID || "YOUR_PROJECT_ID",
+      chains: [
+        localhost,
+        hanzoMainnet,
+        hanzoTestnet,
+        luxMainnet,
+        luxTestnet,
+        zooMainnet,
+        zooTestnet,
+      ],
       ssr: true,
     })
   }
@@ -187,4 +184,8 @@ export const getConfig = (): Config => {
   return _config
 }
 
-export const config = getConfig()
+// For backward compatibility
+export const config =
+  typeof window !== "undefined"
+    ? getConfig()
+    : ({} as ReturnType<typeof getDefaultConfig>)

app/next.config.mjs

@@ -5,13 +5,15 @@ const nextConfig = {
   // Transpile packages that might have issues with pnpm symlinks
   transpilePackages: ["chrono-node", "@hanzo/ui"],
 
-  // The docs site is a static export, wherever it is built. It is served by
-  // hanzoai/static; `next dev` is unaffected by this.
-  output: "export",
+  // Enable static export for GitHub Pages / Cloudflare Pages deployment (but not for E2E tests)
+  output: (process.env.GITHUB_ACTIONS || process.env.CF_PAGES) && !process.env.E2E_TEST ? "export" : undefined,
 
-  // Directory-style URLs, so a static server resolves /docs/button/index.html.
+  // Use trailing slashes for GitHub Pages compatibility
   trailingSlash: true,
 
+  // Base path for GitHub Pages (when deployed to github.io subdirectory)
+  basePath: process.env.GITHUB_PAGES ? "/react-sdk" : "",
+
   // Asset prefix for proper loading on custom domain
   assetPrefix: process.env.NEXT_PUBLIC_APP_URL || "",
 

app/package.json

@@ -31,13 +31,12 @@
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
     "@faker-js/faker": "^10.4.0",
-    "@hanzo/event": "^0.3.3",
     "@hanzo/docs-core": "16.5.3",
     "@hanzo/docs-docgen": "3.0.7",
     "@hanzo/docs-mdx": "14.3.0",
     "@hanzo/docs-ui": "16.5.3",
     "@hanzo/logo": "^1.0.5",
-    "@hanzo/ui": "npm:@hanzo/ui-shadcn@^5",
+    "@hanzo/ui": "workspace:@hanzo/ui-shadcn@^",
     "@hookform/resolvers": "5.2.2",
     "@monaco-editor/react": "^4.7.0",
     "@radix-ui/react-accessible-icon": "^1.1.8",
@@ -71,6 +70,7 @@
     "@radix-ui/react-toggle": "^1.1.10",
     "@radix-ui/react-toggle-group": "^1.1.11",
     "@radix-ui/react-tooltip": "^1.2.8",
+    "@rainbow-me/rainbowkit": "^2.2.10",
     "@rc-component/color-picker": "^3.1.1",
     "@tabler/icons-react": "^3.40.0",
     "@tanstack/react-query": "^5.94.5",
@@ -79,6 +79,7 @@
     "@tiptap/react": "^3.20.4",
     "@tiptap/starter-kit": "^3.20.4",
     "@types/react-syntax-highlighter": "^15.5.13",
+    "@vercel/analytics": "^2.0.1",
     "@vercel/og": "^0.11.1",
     "@xyflow/react": "^12.10.1",
     "chrono-node": "^2.9.0",

app/pages/api/components.ts

@@ -0,0 +1,14 @@
+import { NextApiRequest, NextApiResponse } from "next"
+
+import components from "./components.json"
+
+export default async function handler(
+  req: NextApiRequest,
+  res: NextApiResponse
+) {
+  if (req.method !== "GET") {
+    return res.status(405).end()
+  }
+
+  return res.status(200).json(components)
+}

app/public/CNAME

@@ -0,0 +1 @@
+ui.hanzo.ai

app/registry/default/ui/ai-voice.tsx

@@ -34,68 +34,57 @@ import { Slider } from "@/registry/default/ui/slider"
 import { Switch } from "@/registry/default/ui/switch"
 import { Textarea } from "@/registry/default/ui/textarea"
 
-// Web Speech API shapes, declared MODULE-LOCALLY and deliberately not in
-// `declare global`.
-//
-// The Speech API is only partly standardised, so how much of it lib.dom ships
-// varies by TypeScript version — and this file has now been broken from both
-// directions by that. Declaring the names globally MERGES with whatever the lib
-// provides instead of shadowing it, so every small difference became an error
-// (`readonly` vs mutable → TS2687, a second `[index: number]` → TS2374,
-// `error: string` against the real `SpeechRecognitionErrorCode` union → TS2717).
-// Deleting the declarations instead broke the opposite way on a lib that does
-// NOT carry them: TS2552 "Cannot find name 'SpeechRecognitionEvent'".
-//
-// Local names collide with neither. They describe exactly the surface this
-// component touches, and the version of lib.dom in use stops mattering.
-interface SpeechAlternative {
-  readonly transcript: string
-}
+declare global {
+  interface Window {
+    SpeechRecognition: typeof SpeechRecognition
+    webkitSpeechRecognition: typeof SpeechRecognition
+    webkitAudioContext: typeof AudioContext
+  }
 
-interface SpeechResult {
-  readonly isFinal: boolean
-  readonly [index: number]: SpeechAlternative
-}
+  interface SpeechRecognition extends EventTarget {
+    continuous: boolean
+    interimResults: boolean
+    lang: string
+    onresult: (event: SpeechRecognitionEvent) => void
+    onerror: (event: SpeechRecognitionErrorEvent) => void
+    onend: () => void
+    start(): void
+    stop(): void
+    abort(): void
+  }
 
-interface SpeechResultList {
-  readonly length: number
-  readonly [index: number]: SpeechResult
-}
+  interface SpeechRecognitionEvent extends Event {
+    results: SpeechRecognitionResultList
+    resultIndex: number
+  }
 
-interface SpeechRecognitionEventLike {
-  readonly resultIndex: number
-  readonly results: SpeechResultList
-}
+  interface SpeechRecognitionErrorEvent extends Event {
+    error: string
+    message: string
+  }
 
-interface SpeechRecognitionErrorEventLike {
-  readonly error: string
-}
+  interface SpeechRecognitionResultList {
+    readonly length: number
+    item(index: number): SpeechRecognitionResult
+    [index: number]: SpeechRecognitionResult
+  }
 
-interface SpeechRecognizer {
-  continuous: boolean
-  interimResults: boolean
-  lang: string
-  onresult: (event: SpeechRecognitionEventLike) => void
-  onerror: (event: SpeechRecognitionErrorEventLike) => void
-  onend: () => void
-  start(): void
-  stop(): void
-  abort(): void
-}
+  interface SpeechRecognitionResult {
+    readonly length: number
+    readonly isFinal: boolean
+    item(index: number): SpeechRecognitionAlternative
+    [index: number]: SpeechRecognitionAlternative
+  }
 
-// The constructor is read off `window` through a narrow cast rather than a
-// `Window` augmentation, for the same reason: lib.dom may or may not already
-// declare `SpeechRecognition` there, and re-declaring it with a different type
-// is itself an error.
-type SpeechRecognizerCtor = new () => SpeechRecognizer
+  interface SpeechRecognitionAlternative {
+    readonly transcript: string
+    readonly confidence: number
+  }
 
-const getSpeechRecognizerCtor = (): SpeechRecognizerCtor | undefined => {
-  if (typeof window === "undefined") return undefined
-  const w = window as unknown as {
-    SpeechRecognition?: SpeechRecognizerCtor
-    webkitSpeechRecognition?: SpeechRecognizerCtor
+  const SpeechRecognition: {
+    prototype: SpeechRecognition
+    new (): SpeechRecognition
   }
-  return w.webkitSpeechRecognition ?? w.SpeechRecognition
 }
 
 interface VoiceProfile {
@@ -219,7 +208,7 @@ export function AIVoice({
   const [error, setError] = useState<string | null>(null)
   const [audioLevel, setAudioLevel] = useState(0)
 
-  const recognitionRef = useRef<SpeechRecognizer | null>(null)
+  const recognitionRef = useRef<SpeechRecognition | null>(null)
   const synthRef = useRef<SpeechSynthesis | null>(null)
   const audioContextRef = useRef<AudioContext | null>(null)
   const analyserRef = useRef<AnalyserNode | null>(null)
@@ -229,9 +218,10 @@ export function AIVoice({
 
   // Initialize speech recognition
   useEffect(() => {
-    const Recognizer = getSpeechRecognizerCtor()
-    if (Recognizer) {
-      recognitionRef.current = new Recognizer()
+    if (typeof window !== "undefined" && "webkitSpeechRecognition" in window) {
+      const SpeechRecognition =
+        window.webkitSpeechRecognition || window.SpeechRecognition
+      recognitionRef.current = new SpeechRecognition()
 
       if (recognitionRef.current) {
         recognitionRef.current.continuous = true
@@ -309,15 +299,8 @@ export function AIVoice({
     try {
       const stream = await navigator.mediaDevices.getUserMedia({ audio: true })
 
-      // `webkitAudioContext` is a vendor prefix lib.dom does not declare, so it
-      // is read through the same narrow cast as the recogniser rather than by
-      // augmenting Window (see the note at the top of this file).
-      const AudioCtx =
-        window.AudioContext ??
-        (window as unknown as { webkitAudioContext?: typeof AudioContext })
-          .webkitAudioContext
-      if (!AudioCtx) throw new Error("Web Audio API is not available")
-      audioContextRef.current = new AudioCtx()
+      audioContextRef.current = new (window.AudioContext ||
+        window.webkitAudioContext)()
       analyserRef.current = audioContextRef.current.createAnalyser()
       microphoneRef.current =
         audioContextRef.current.createMediaStreamSource(stream)

app/tsconfig.json

@@ -19,18 +19,10 @@
     "resolveJsonModule": true,
     "isolatedModules": true,
     "jsx": "react-jsx",
-    // `types/nav` and `types/unist` are imported as BARE specifiers, which only
-    // ever resolved because of an implicit project root. Under TypeScript 7
-    // `baseUrl` is gone outright — the compiler answers TS5102 "Option 'baseUrl'
-    // has been removed … use '\"paths\": {\"*\": [\"./*\"]}' instead" — so the
-    // mapping has to be explicit. `paths` entries resolve relative to this file,
-    // so no baseUrl is needed or accepted.
+    "baseUrl": ".",
     "paths": {
       "@/*": [
         "./*"
-      ],
-      "types/*": [
-        "./types/*"
       ]
     },
     "plugins": [

apps/cd/.gitignore

@@ -1,4 +0,0 @@
-node_modules
-dist
-e2e-shots
-*.tsbuildinfo

apps/cd/LLM.md

@@ -1,78 +0,0 @@
-# Hanzo CD — the dedicated deploy dashboard (cd.hanzo.ai)
-
-A focused, mobile-first CD dashboard served at **cd.hanzo.ai**. It replaces the
-ArgoCD React fork (`~/work/hanzo/deploy/ui`, webpack/`argo-cd-ui`) with the shared
-Hanzo component packages over the native cloud CD plane. Its whole job: **see every
-service deployed as an operator App CR — stats · sync · health · resource tree ·
-logs · sync/rollback.**
-
-## Stack + why
-
-- **Vite + React 19 static SPA** → `dist/` (a static bundle, no runtime server).
-- **`@hanzo/cd`** (workspace) is the ArgoCD-replacement UI — a clean-room,
-  framework-free port (plain React + scoped CSS, no Tamagui/Tailwind). We mount
-  `GitopsAppList` (the fleet), and compose `GitopsSyncPanel` + `GitopsAppTree` +
-  `GitopsNodeInfo` + `GitopsRollbackDialog` for the app detail (lazy per-node
-  `/resource` + `/logs` fetch).
-- **`@hanzo/canvas/pure`** (workspace) for the pure helpers.
-- The workspace packages are resolved by **Vite path alias** (`vite.config.ts`),
-  so the app builds off `@hanzo/cd/dist` + `@hanzo/canvas/src` **without a full
-  monorepo install** (the shared pnpm store lacks the registry deps of the heavier
-  packages). Run `pnpm --filter @hanzo/cd build` once if its `dist` is stale.
-
-## Backend + auth (the contract this preserves)
-
-- **API = the cloud binary at `/v1/deploy`** (SuperAdmin-gated, clean paths —
-  `applications`, `:name/tree`, `:name/resource/:ref`, `:name/logs`, `sync`,
-  `rollback`). The cd.hanzo.ai ingress peels `/v1/deploy/*` off to `cloud:8000`;
-  the SPA calls it **same-origin** with `credentials: 'include'`.
-- **Auth = the `admin-console` PKCE gate** (`public/login.html`, ported verbatim
-  from the ArgoCD fork — self-contained, proven): `hanzo.id` → sets the non-httpOnly
-  `hanzo_iam_token` cookie the cloud binary validates (`SanitizeIdentity` →
-  `c.IsAdmin()`). The SPA reads that cookie for its gate; a missing/expired session
-  (or an API 401/403) lands on the sign-in screen — never a fabricated row.
-- `src/lib/adapt.ts` maps the `/v1/deploy` DTOs INTO the shared `@hanzo/cd`
-  view-models (reusing the package's own `foldHealth`/`foldSync`). Note: the cloud
-  wire uses the hyphenated `out-of-sync`, which `foldSync` (whitespace-only strip)
-  reads as Unknown — the adapter strips `[-_]` before folding.
-
-## Build + serve
-
-```bash
-pnpm --filter cd build      # tsc -b && vite build → dist/ (index.html + login.html + CNAME + assets)
-pnpm --filter cd preview    # serve dist locally
-pnpm --filter cd dev        # vite dev (proxies /v1 → CD_API, default https://cd.hanzo.ai)
-```
-
-Serving: the built `dist/` is a static bundle published to **`s3://cdn/cd`** — the
-existing static plane cd.hanzo.ai already serves (ingress `staticFiles` +
-`spaMode`, zero pods; see `universe/infra/k8s/operator/crs/static-sites.yaml`). No
-ingress or backend change: publish the bundle, retire the old ArgoCD `ui/` + the
-`deploy/dashboard.go` embed.
-
-## Verify
-
-- `tsc --noEmit -p tsconfig.app.json` — clean.
-- `npx vitest run src/lib/adapt.test.ts` — the `/v1/deploy` → `@hanzo/cd`
-  mapping (incl. the `out-of-sync` fold fix, `parentRefs` tree linking, clean-semver
-  rollback).
-- `npx playwright test` — builds + serves + proves the fleet renders, a row opens
-  the ArgoCD-grade detail (sync panel + resource topology), and **no horizontal body
-  scroll at 390px**. Screenshots in `e2e-shots/`.
-
-## Follow-ons (registry-install / routing gated — flagged, not fabricated)
-
-- **`@hanzo/canvas` fleet MAP** (the Railway board) needs `@hanzo/gui` (Tamagui),
-  which is an external npm dep not in the offline store here — so the map is a
-  registry-install follow-on. It already ships green in the console
-  (`hanzoai/console` `feat/cd-canvas-map`); lifting it in is an import once
-  `@hanzo/gui` installs.
-- **`@hanzo/ui-shadcn` shared shell** (`HanzoHeader` + org/project switcher + ⌘K)
-  needs a full monorepo install (its Tailwind deps aren't in the offline store).
-  This app ships a lean self-contained topbar (Geist, small mark, env scope) in the
-  interim; swap to the shared shell once installed. The **org/project↔IAM switcher**
-  additionally needs `/v1/iam` routed on cd.hanzo.ai (today the SuperAdmin cookie
-  sees the whole fleet; env is the scope control).
-- **Rollback targets** come from the app's `revisions` (forward-compat — the plane
-  doesn't expose prior tags yet; empty → the dialog's honest "no history"). Cloud
-  re-validates the clean semver.

apps/cd/e2e/cd-render.spec.ts

@@ -1,97 +0,0 @@
-/**
- * e2e: Hanzo CD — mocked-network render + RESPONSIVE proof.
- *
- * Serves the built static SPA; mocks the cloud CD plane (`/v1/deploy/*`) with
- * real-shaped `clients/deploy` rows + a session cookie so the app renders the
- * fleet. Proves: the fleet renders on the shared @hanzo/cd `GitopsAppList`, a
- * row opens the ArgoCD-grade detail (sync panel + resource topology), and — the
- * CTO requirement — the body never scrolls horizontally at a 390px viewport.
- * Screenshots at desktop (1440) and mobile (390).
- */
-import { test, expect, type Route, type Page, type BrowserContext } from "@playwright/test"
-import { mkdirSync } from "node:fs"
-import { join } from "node:path"
-
-const SHOTS = join(process.cwd(), "e2e-shots")
-
-const FLEET = {
-  applications: [
-    { name: "cloud", namespace: "hanzo", env: "main", repository: "ghcr.io/hanzoai/cloud", version: "v1.800.1", runningVersion: "v1.800.1", health: "healthy", sync: "synced", phase: "Running" },
-    { name: "iam", namespace: "hanzo", env: "main", repository: "ghcr.io/hanzoai/iam", version: "v1.4.11", runningVersion: "v1.4.10", health: "progressing", healthMessage: "rolling update (1/2)", sync: "out-of-sync", phase: "Running", revisions: ["v1.4.10", "v1.4.9"] },
-    { name: "gateway", namespace: "hanzo", env: "main", repository: "ghcr.io/hanzoai/gateway", version: "v2.16.4", runningVersion: "v2.16.4", health: "healthy", sync: "synced", phase: "Running" },
-    { name: "o11y", namespace: "hanzo", env: "test", repository: "ghcr.io/hanzoai/o11y", version: "v1.5.12", runningVersion: "v1.5.10", health: "degraded", healthMessage: "CrashLoopBackOff", sync: "out-of-sync", phase: "Degraded" },
-  ],
-  summary: { total: 4, healthy: 2, degraded: 1, outOfSync: 2 },
-}
-const TREE = {
-  application: FLEET.applications[1],
-  nodes: [
-    { group: "hanzo.ai", version: "v1", kind: "App", namespace: "hanzo", name: "iam", ref: "hanzo.ai:App:hanzo:iam", uid: "u1", health: "progressing", parentRefs: [] },
-    { group: "apps", version: "v1", kind: "Deployment", namespace: "hanzo", name: "iam", ref: "apps:Deployment:hanzo:iam", uid: "u2", health: "progressing", parentRefs: [{ ref: "hanzo.ai:App:hanzo:iam" }] },
-    { group: "apps", version: "v1", kind: "ReplicaSet", namespace: "hanzo", name: "iam-6d8f", ref: "apps:ReplicaSet:hanzo:iam-6d8f", uid: "u3", health: "healthy", parentRefs: [{ ref: "apps:Deployment:hanzo:iam" }] },
-    { group: "", version: "v1", kind: "Pod", namespace: "hanzo", name: "iam-6d8f-abc", ref: ":Pod:hanzo:iam-6d8f-abc", uid: "u4", health: "healthy", parentRefs: [{ ref: "apps:ReplicaSet:hanzo:iam-6d8f" }] },
-  ],
-}
-const RESOURCE = { ref: "apps:Deployment:hanzo:iam", health: "healthy", liveManifest: { apiVersion: "apps/v1", kind: "Deployment", metadata: { name: "iam" }, spec: { replicas: 2 } }, desiredSource: "last-applied", diff: { modified: false } }
-const LOGS = { application: "hanzo/iam", pod: "iam-6d8f-abc", logs: "listening on :8080\nready to serve\n" }
-
-async function mock(route: Route) {
-  const p = new URL(route.request().url()).pathname
-  const json = (b: unknown) => route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify(b) })
-  if (p === "/v1/deploy/applications") return json(FLEET)
-  if (/^\/v1\/deploy\/[^/]+\/tree$/.test(p)) return json(TREE)
-  if (/^\/v1\/deploy\/[^/]+\/resource\//.test(p)) return json(RESOURCE)
-  if (/^\/v1\/deploy\/[^/]+\/logs$/.test(p)) return json(LOGS)
-  if (p.startsWith("/v1/deploy/")) return json({ ok: true })
-  return route.continue()
-}
-
-async function open(ctx: BrowserContext): Promise<Page> {
-  // The PKCE login sets `hanzo_iam_token`; seed it so the SPA renders the dashboard.
-  await ctx.addCookies([{ name: "hanzo_iam_token", value: "e.y.j", url: "http://localhost:4173" }])
-  const page = await ctx.newPage()
-  await page.route("**/*", mock)
-  await page.goto("/", { waitUntil: "domcontentloaded" })
-  await page.locator("text=Fleet").first().waitFor({ timeout: 15_000 })
-  return page
-}
-
-test.beforeAll(() => mkdirSync(SHOTS, { recursive: true }))
-
-test("renders the fleet, opens a row → ArgoCD-grade detail (desktop)", async ({ browser }) => {
-  const ctx = await browser.newContext({ viewport: { width: 1440, height: 900 } })
-  const page = await open(ctx)
-
-  await expect(page.locator("text=Applications").first()).toBeVisible()
-  await expect(page.locator("tr", { hasText: "iam" }).first()).toBeVisible()
-  // sync fold: the hyphenated cloud verdict renders OutOfSync (not Unknown).
-  await expect(page.locator("text=OutOfSync").first()).toBeVisible()
-  await page.screenshot({ path: join(SHOTS, "cd-fleet-desktop.png"), fullPage: true })
-
-  // Tap the app's NAME cell (always visible; the row overflows on narrow tables).
-  await page.locator(".hz-gitops-row", { hasText: "iam" }).first().locator("td").first().click()
-  await expect(page.getByText("← Fleet").first()).toBeVisible({ timeout: 10_000 }) // detail-only breadcrumb
-  await expect(page.locator(".hz-gitops-tree-world").first()).toBeVisible({ timeout: 10_000 })
-  await expect(page.locator("text=Deployment").first()).toBeVisible()
-  await page.screenshot({ path: join(SHOTS, "cd-detail-desktop.png"), fullPage: true })
-  await ctx.close()
-})
-
-test("reflows with no horizontal body scroll at a narrow (mobile) viewport", async ({ browser }) => {
-  const ctx = await browser.newContext({ viewport: { width: 390, height: 844 } })
-  const page = await open(ctx)
-
-  await expect(page.locator("tr", { hasText: "iam" }).first()).toBeVisible()
-  const overflow = await page.evaluate(() => ({ sw: document.documentElement.scrollWidth, cw: document.documentElement.clientWidth }))
-  expect(overflow.sw, "no horizontal body scroll at 390px").toBeLessThanOrEqual(overflow.cw + 1)
-  await page.screenshot({ path: join(SHOTS, "cd-fleet-mobile.png"), fullPage: true })
-
-  // Tap-to-open must work on mobile: tap the name cell → the ArgoCD-grade detail.
-  await page.locator(".hz-gitops-row", { hasText: "iam" }).first().locator("td").first().click()
-  await expect(page.getByText("← Fleet").first()).toBeVisible({ timeout: 10_000 })
-  await expect(page.locator(".hz-gitops-tree-world").first()).toBeVisible({ timeout: 10_000 })
-  const overflow2 = await page.evaluate(() => ({ sw: document.documentElement.scrollWidth, cw: document.documentElement.clientWidth }))
-  expect(overflow2.sw, "no horizontal body scroll on the detail at 390px").toBeLessThanOrEqual(overflow2.cw + 1)
-  await page.screenshot({ path: join(SHOTS, "cd-detail-mobile.png"), fullPage: true })
-  await ctx.close()
-})

apps/cd/index.html

@@ -1,17 +0,0 @@
-<!doctype html>
-<html lang="en" data-theme="dark">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
-    <title>Hanzo CD</title>
-    <link
-      rel="icon"
-      type="image/svg+xml"
-      href="data:image/svg+xml,%3Csvg viewBox='0 0 64 64' xmlns='http://www.w3.org/2000/svg'%3E%3Crect width='64' height='64' rx='8' fill='%23000'/%3E%3Cg transform='translate(8,8) scale(0.716)'%3E%3Cpath d='M22.21 67V44.6369H0V67H22.21Z' fill='%23fff'/%3E%3Cpath d='M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z' fill='%23fff'/%3E%3Cpath d='M22.21 0H0V22.3184H22.21V0Z' fill='%23fff'/%3E%3Cpath d='M66.7198 0H44.5098V22.3184H66.7198V0Z' fill='%23fff'/%3E%3Cpath d='M66.7198 67V44.6369H44.5098V67H66.7198Z' fill='%23fff'/%3E%3C/g%3E%3C/svg%3E"
-    />
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.tsx"></script>
-  </body>
-</html>

apps/cd/package.json

@@ -1,26 +0,0 @@
-{
-  "name": "cd",
-  "private": true,
-  "version": "0.1.0",
-  "type": "module",
-  "description": "Hanzo CD — the dedicated deploy dashboard served at cd.hanzo.ai (a @hanzo/cd + @hanzo/canvas SPA over /v1/deploy). Replaces the ArgoCD UI fork.",
-  "scripts": {
-    "dev": "vite",
-    "build": "tsc -b && vite build",
-    "typecheck": "tsc --noEmit -p tsconfig.app.json",
-    "preview": "vite preview --port 4173"
-  },
-  "dependencies": {
-    "@hanzo/canvas": "workspace:*",
-    "@hanzo/cd": "workspace:*",
-    "react": "^19.2.4",
-    "react-dom": "^19.2.4"
-  },
-  "devDependencies": {
-    "@types/react": "^19.2.14",
-    "@types/react-dom": "^19.2.3",
-    "@vitejs/plugin-react": "^6.0.3",
-    "typescript": "~6.0.2",
-    "vite": "^8.1.4"
-  }
-}

apps/cd/playwright.config.ts

@@ -1,28 +0,0 @@
-import { defineConfig, devices } from "@playwright/test"
-
-/**
- * Hanzo CD render + responsive proof. Builds the static SPA and serves it (vite
- * preview), then the spec mocks `/v1/deploy/*` + a session cookie and asserts the
- * fleet renders, a row opens the ArgoCD-grade detail (sync panel + resource tree),
- * and the body never scrolls horizontally at 390px. Screenshots per width.
- *
- *   pnpm --filter cd exec playwright test        # builds + serves + runs
- *   BASE_URL=https://cd.hanzo.ai pnpm … test     # against a live deploy
- */
-export default defineConfig({
-  testDir: "./e2e",
-  timeout: 60_000,
-  retries: 1,
-  workers: 1,
-  reporter: "list",
-  use: { baseURL: process.env.BASE_URL ?? "http://localhost:4173", headless: true },
-  webServer: process.env.BASE_URL
-    ? undefined
-    : {
-        command: "npx vite build && npx vite preview --port 4173 --strictPort",
-        url: "http://localhost:4173",
-        reuseExistingServer: true,
-        timeout: 120_000,
-      },
-  projects: [{ name: "chromium", use: { ...devices["Desktop Chrome"] } }],
-})

apps/cd/public/CNAME

@@ -1 +0,0 @@
-cd.hanzo.ai

apps/cd/public/login.html

@@ -1,143 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>Hanzo CD — Sign in</title>
-<link rel="icon" type="image/svg+xml" href="data:image/svg+xml,%3Csvg viewBox='0 0 64 64' xmlns='http://www.w3.org/2000/svg'%3E%3Crect width='64' height='64' rx='8' fill='%23000'/%3E%3Cg transform='translate(8,8) scale(0.716)'%3E%3Cpath d='M22.21 67V44.6369H0V67H22.21Z' fill='%23fff'/%3E%3Cpath d='M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z' fill='%23fff'/%3E%3Cpath d='M22.21 0H0V22.3184H22.21V0Z' fill='%23fff'/%3E%3Cpath d='M66.7198 0H44.5098V22.3184H66.7198V0Z' fill='%23fff'/%3E%3Cpath d='M66.7198 67V44.6369H44.5098V67H66.7198Z' fill='%23fff'/%3E%3C/g%3E%3C/svg%3E">
-<style>
-  :root { color-scheme: light dark; }
-  * { box-sizing: border-box; }
-  html,body { height:100%; margin:0; }
-  body {
-    font-family: "Geist", "Geist Sans", ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
-    background:#0a0a0a; color:#e7e7e7;
-    display:grid; grid-template-columns: 1.1fr 1fr; min-height:100vh;
-  }
-  @media (max-width: 820px){ body{ grid-template-columns:1fr; } .pitch{ display:none; } }
-  .pitch { padding:64px 56px; display:flex; flex-direction:column; justify-content:center; gap:22px;
-           border-right:1px solid #1c1c1c; }
-  .brand { display:flex; align-items:center; gap:12px; font-size:22px; font-weight:700; letter-spacing:-.02em; }
-  .brand .mark { width:26px; height:26px; display:block; }
-  h1 { font-size:40px; line-height:1.08; margin:6px 0 0; letter-spacing:-.03em; font-weight:800; }
-  .sub { color:#9a9a9a; font-size:16px; max-width:38ch; line-height:1.5; }
-  ul.feat { list-style:none; padding:0; margin:8px 0 0; display:grid; gap:12px; }
-  ul.feat li { display:flex; gap:12px; align-items:flex-start; color:#cfcfcf; font-size:14.5px; }
-  ul.feat li b { color:#fff; font-weight:600; }
-  ul.feat .dot { width:6px; height:6px; border-radius:50%; background:#fff; margin-top:7px; flex:none; }
-  .auth { display:flex; align-items:center; justify-content:center; padding:40px; }
-  .card { width:100%; max-width:360px; text-align:center; }
-  .card .mark2 { width:52px; height:52px; display:block; margin:0 auto 18px; }
-  .card h2 { font-size:22px; margin:0 0 6px; font-weight:700; }
-  .card p.hint { color:#8f8f8f; font-size:14px; margin:0 0 26px; }
-  button#login {
-    width:100%; padding:14px 18px; font-size:15px; font-weight:600; cursor:pointer;
-    background:#fff; color:#000; border:0; border-radius:10px; display:flex; align-items:center;
-    justify-content:center; gap:10px; transition:opacity .15s;
-  }
-  button#login:hover { opacity:.88; }
-  button#login:disabled { opacity:.5; cursor:default; }
-  .status { margin-top:16px; font-size:13.5px; color:#9a9a9a; min-height:20px; }
-  .status.err { color:#ff7a7a; }
-  .foot { margin-top:28px; font-size:12px; color:#5c5c5c; }
-  a { color:#bdbdbd; }
-</style>
-</head>
-<body>
-  <section class="pitch">
-    <div class="brand"><svg class="mark" viewBox="0 0 67 67" xmlns="http://www.w3.org/2000/svg" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z" fill="#fff"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z" fill="#fff"/><path d="M22.21 0H0V22.3184H22.21V0Z" fill="#fff"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z" fill="#fff"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z" fill="#fff"/></svg> Hanzo CD</div>
-    <h1>Continuous delivery for your whole fleet.</h1>
-    <p class="sub">GitOps for every Hanzo App. Declarative, versioned, and auto-synced from git to your clusters — one control plane across hanzo, lux, zoo &amp; pars.</p>
-    <ul class="feat">
-      <li><span class="dot"></span><span><b>Live fleet view</b> — health &amp; sync status for every App across all namespaces.</span></li>
-      <li><span class="dot"></span><span><b>Git-to-cluster</b> — desired state lives in <code>infra/k8s/operator/crs</code>, reconciled continuously.</span></li>
-      <li><span class="dot"></span><span><b>Sync &amp; rollback</b> — one click to reconcile or roll back any application.</span></li>
-      <li><span class="dot"></span><span><b>Resource trees &amp; logs</b> — drill into any workload the operator manages.</span></li>
-    </ul>
-  </section>
-
-  <section class="auth">
-    <div class="card">
-      <svg class="mark2" viewBox="0 0 64 64" xmlns="http://www.w3.org/2000/svg" aria-hidden="true"><rect width="64" height="64" rx="14" fill="#fff"/><g transform="translate(8,8) scale(0.716)"><path d="M22.21 67V44.6369H0V67H22.21Z" fill="#000"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z" fill="#000"/><path d="M22.21 0H0V22.3184H22.21V0Z" fill="#000"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z" fill="#000"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z" fill="#000"/></g></svg>
-      <h2>Hanzo CD</h2>
-      <p class="hint">Sign in with your Hanzo account to manage the fleet.</p>
-      <button id="login">
-        <svg width="17" height="17" viewBox="0 0 67 67" xmlns="http://www.w3.org/2000/svg" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z" fill="currentColor"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z" fill="currentColor"/><path d="M22.21 0H0V22.3184H22.21V0Z" fill="currentColor"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z" fill="currentColor"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z" fill="currentColor"/></svg>
-        Sign in with Hanzo
-      </button>
-      <div class="status" id="status"></div>
-      <div class="foot">Powered by <a href="https://hanzo.id" rel="noreferrer">Hanzo IAM</a> · SuperAdmin access</div>
-    </div>
-  </section>
-
-<script>
-(function () {
-  var IAM = 'https://hanzo.id';
-  var CLIENT = 'admin-console';                 // the IAM app whose org is `admin`
-  var REDIRECT = location.origin + '/login.html'; // must be registered on admin-console
-  var COOKIE = 'hanzo_iam_token';               // the cookie hanzoai/cloud validates
-
-  var statusEl = document.getElementById('status');
-  var btn = document.getElementById('login');
-  function setStatus(m, err){ statusEl.textContent = m || ''; statusEl.className = 'status' + (err ? ' err' : ''); }
-
-  function b64url(bytes){
-    var s = btoa(String.fromCharCode.apply(null, new Uint8Array(bytes)));
-    return s.replace(/\+/g,'-').replace(/\//g,'_').replace(/=+$/,'');
-  }
-  function randB64(n){ return b64url(crypto.getRandomValues(new Uint8Array(n))); }
-  async function sha256b64(str){
-    var d = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(str));
-    return b64url(d);
-  }
-
-  async function startLogin(){
-    btn.disabled = true; setStatus('Redirecting to Hanzo…');
-    var verifier = randB64(48);
-    var state = randB64(16);
-    sessionStorage.setItem('cd_pkce_verifier', verifier);
-    sessionStorage.setItem('cd_oauth_state', state);
-    var challenge = await sha256b64(verifier);
-    var u = new URL(IAM + '/login/oauth/authorize');
-    u.search = new URLSearchParams({
-      client_id: CLIENT, response_type: 'code', redirect_uri: REDIRECT,
-      scope: 'openid profile email', state: state,
-      code_challenge: challenge, code_challenge_method: 'S256'
-    }).toString();
-    location.href = u.toString();
-  }
-
-  async function finishLogin(code, state){
-    btn.disabled = true; setStatus('Signing in…');
-    if (state !== sessionStorage.getItem('cd_oauth_state')) { setStatus('Sign-in state mismatch — please try again.', true); btn.disabled = false; return; }
-    var verifier = sessionStorage.getItem('cd_pkce_verifier');
-    if (!verifier) { setStatus('Sign-in session lost — please try again.', true); btn.disabled = false; return; }
-    try {
-      var r = await fetch(IAM + '/v1/iam/oauth/access_token', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-        body: new URLSearchParams({
-          grant_type: 'authorization_code', client_id: CLIENT, code: code,
-          redirect_uri: REDIRECT, code_verifier: verifier
-        })
-      });
-      var j = await r.json();
-      if (!j.access_token) { setStatus('Sign-in failed: ' + (j.error_description || j.error || 'no token'), true); btn.disabled = false; return; }
-      // set the session cookie cloud reads (non-httpOnly by design so the page can set it; still Secure)
-      document.cookie = COOKIE + '=' + j.access_token + '; path=/; secure; samesite=lax; max-age=86400';
-      sessionStorage.removeItem('cd_pkce_verifier'); sessionStorage.removeItem('cd_oauth_state');
-      setStatus('Signed in. Loading the dashboard…');
-      location.replace('/');
-    } catch (e) {
-      setStatus('Sign-in error: ' + (e && e.message ? e.message : e), true); btn.disabled = false;
-    }
-  }
-
-  var q = new URLSearchParams(location.search);
-  if (q.get('error')) { setStatus('Hanzo returned: ' + (q.get('error_description') || q.get('error')), true); }
-  else if (q.get('code')) { finishLogin(q.get('code'), q.get('state')); }
-  btn.onclick = startLogin;
-})();
-</script>
-</body>
-</html>

apps/cd/src/App.tsx

@@ -1,171 +0,0 @@
-/**
- * Hanzo CD — the dedicated deploy dashboard (cd.hanzo.ai). A static SPA over the
- * cloud CD plane (`/v1/deploy`): the fleet of operator App CRs with health, sync,
- * resource topology, logs, and sync/rollback, built on the shared @hanzo/cd
- * components. Auth is the first-party `hanzo_iam_token` cookie (set by the PKCE
- * login); a missing/expired session lands on the sign-in screen — never a fake row.
- */
-import { useCallback, useEffect, useMemo, useState } from "react"
-
-import { DeployApi, hasSession, isAuthError } from "./lib/deploy"
-import type { DeployApp } from "./lib/adapt"
-import { Topbar, type EnvOption } from "./shell/Topbar"
-import { FleetView } from "./views/FleetView"
-import { AppView } from "./views/AppView"
-
-const POLL_MS = 20_000
-
-type Phase = "signin" | "loading" | "error" | "ready"
-
-const parseHash = (): string => {
-  const m = /^#\/app\/(.+)$/.exec(location.hash)
-  return m ? decodeURIComponent(m[1]) : ""
-}
-
-function SignIn() {
-  return (
-    <div style={{ minHeight: "100vh", display: "grid", placeItems: "center", padding: 24 }}>
-      <div style={{ textAlign: "center", maxWidth: 360 }}>
-        <svg width={52} height={52} viewBox="0 0 64 64" style={{ marginBottom: 18 }} xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
-          <rect width="64" height="64" rx="14" fill="#fff" />
-          <g transform="translate(8,8) scale(0.716)">
-            <path d="M22.21 67V44.6369H0V67H22.21Z" fill="#000" />
-            <path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z" fill="#000" />
-            <path d="M22.21 0H0V22.3184H22.21V0Z" fill="#000" />
-            <path d="M66.7198 0H44.5098V22.3184H66.7198V0Z" fill="#000" />
-            <path d="M66.7198 67V44.6369H44.5098V67H66.7198Z" fill="#000" />
-          </g>
-        </svg>
-        <h2 style={{ fontSize: 22, margin: "0 0 6px", fontWeight: 700 }}>Hanzo CD</h2>
-        <p className="cd-muted" style={{ margin: "0 0 26px", fontSize: 14 }}>
-          Sign in with your Hanzo account to manage the fleet.
-        </p>
-        <button type="button" className="cd-btn cd-btn--primary" style={{ width: "100%", justifyContent: "center", padding: "13px 18px" }} onClick={() => (location.href = "/login.html")}>
-          Sign in with Hanzo
-        </button>
-        <div className="cd-muted" style={{ marginTop: 28, fontSize: 12 }}>
-          Powered by Hanzo IAM · SuperAdmin access
-        </div>
-      </div>
-    </div>
-  )
-}
-
-export function App() {
-  const [phase, setPhase] = useState<Phase>(hasSession() ? "loading" : "signin")
-  const [apps, setApps] = useState<DeployApp[]>([])
-  const [errMsg, setErrMsg] = useState("")
-  const [env, setEnv] = useState("")
-  const [selected, setSelected] = useState<string>(parseHash())
-  const [refreshing, setRefreshing] = useState(false)
-  const [toast, setToast] = useState<{ msg: string; err?: boolean } | null>(null)
-
-  const load = useCallback(() => {
-    if (!hasSession()) {
-      setPhase("signin")
-      return
-    }
-    setRefreshing(true)
-    DeployApi.applications()
-      .then((rows) => {
-        setApps(rows)
-        setPhase("ready")
-      })
-      .catch((e) => {
-        if (isAuthError(e)) setPhase("signin")
-        else {
-          setPhase("error")
-          setErrMsg(e instanceof Error ? e.message : "failed to load")
-        }
-      })
-      .finally(() => setRefreshing(false))
-  }, [])
-
-  useEffect(() => {
-    load()
-    const t = setInterval(load, POLL_MS)
-    const onHash = () => setSelected(parseHash())
-    window.addEventListener("hashchange", onHash)
-    return () => {
-      clearInterval(t)
-      window.removeEventListener("hashchange", onHash)
-    }
-  }, [load])
-
-  const notify = useCallback((msg: string, err?: boolean) => {
-    setToast({ msg, err })
-    setTimeout(() => setToast(null), 4000)
-  }, [])
-
-  const envs: EnvOption[] = useMemo(() => {
-    const counts = new Map<string, number>()
-    for (const a of apps) if (a.env) counts.set(a.env, (counts.get(a.env) ?? 0) + 1)
-    return Array.from(counts, ([id, count]) => ({ id, label: id, count })).sort((x, y) => x.id.localeCompare(y.id))
-  }, [apps])
-
-  const visibleApps = useMemo(() => (env ? apps.filter((a) => a.env === env) : apps), [apps, env])
-  const selectedApp = selected ? apps.find((a) => a.name === selected) ?? null : null
-
-  const openApp = (name: string) => {
-    location.hash = `#/app/${encodeURIComponent(name)}`
-  }
-  const backToFleet = () => {
-    location.hash = ""
-  }
-  const signOut = () => {
-    document.cookie = "hanzo_iam_token=; path=/; max-age=0"
-    location.href = "/login.html"
-  }
-
-  if (phase === "signin") return <SignIn />
-
-  return (
-    <div className="cd-app">
-      <Topbar envs={envs} env={env} onEnv={setEnv} onRefresh={load} refreshing={refreshing} onSignOut={signOut} />
-      <main className="cd-main">
-        {phase === "loading" ? (
-          <div className="cd-muted" style={{ padding: 40 }}>
-            Loading the fleet…
-          </div>
-        ) : phase === "error" ? (
-          <div style={{ padding: 24, border: "1px solid var(--cd-border-strong)", borderRadius: 10, background: "var(--cd-surface)" }}>
-            <div style={{ fontWeight: 700, marginBottom: 6 }}>Could not reach the deploy plane</div>
-            <div className="cd-muted" style={{ fontSize: 14, marginBottom: 14 }}>
-              {errMsg || "The CD read (GET /v1/deploy/applications) failed."}
-            </div>
-            <button type="button" className="cd-btn" onClick={load}>
-              Retry
-            </button>
-          </div>
-        ) : selectedApp ? (
-          <AppView app={selectedApp} onBack={backToFleet} onChanged={load} notify={notify} />
-        ) : (
-          <FleetView apps={visibleApps} onOpen={openApp} />
-        )}
-      </main>
-
-      {toast ? (
-        <div
-          role="status"
-          style={{
-            position: "fixed",
-            bottom: 18,
-            left: "50%",
-            transform: "translateX(-50%)",
-            zIndex: 1000,
-            maxWidth: "calc(100vw - 32px)",
-            padding: "11px 16px",
-            borderRadius: 10,
-            background: toast.err ? "#3d1418" : "var(--cd-surface-2)",
-            border: `1px solid ${toast.err ? "#E96D76" : "var(--cd-border-strong)"}`,
-            color: "var(--cd-fg-strong)",
-            fontSize: 13.5,
-            boxShadow: "0 8px 30px rgba(0,0,0,0.4)",
-          }}
-        >
-          {toast.msg}
-        </div>
-      ) : null}
-    </div>
-  )
-}

apps/cd/src/lib/adapt.fuzz.test.ts

@@ -1,261 +0,0 @@
-/**
- * RED adversarial suite — feeds hostile / malformed /v1/deploy JSON to the adapter
- * and the shared @hanzo/cd folds, asserting the view degrades honestly and
- * NEVER (a) crashes, (b) wedges the tree builder into a hang, or (c) mislabels a
- * bad state as Healthy/Synced. Written by Red; not part of Blue's suite.
- */
-import { describe, expect, it } from "vitest"
-import { buildResourceGraph, foldHealth, foldSync } from "@hanzo/cd"
-
-import {
-  manifestText,
-  normalizeDeployApp,
-  parseApplications,
-  toGitopsApp,
-  toLogLines,
-  toManagedResource,
-  toResourceTree,
-  toRollbackHistory,
-} from "./adapt"
-
-// A wall-clock guard: proves a call TERMINATES (no infinite loop) fast.
-function within<T>(ms: number, fn: () => T): T {
-  const t0 = Date.now()
-  const out = fn()
-  const dt = Date.now() - t0
-  expect(dt).toBeLessThan(ms)
-  return out
-}
-
-// ── A. Robustness: hostile top-level inputs never throw ──────────────────────
-
-describe("RED robustness — malformed payloads never crash", () => {
-  const junk: unknown[] = [null, undefined, 42, "str", true, [], {}, { applications: null }, { apps: 7 }, NaN]
-
-  it("parseApplications tolerates any junk → array, never throws", () => {
-    for (const j of junk) expect(Array.isArray(parseApplications(j))).toBe(true)
-  })
-  it("normalizeDeployApp of junk → safe defaults", () => {
-    for (const j of junk) {
-      const a = normalizeDeployApp(j)
-      expect(typeof a.name).toBe("string")
-      expect(a.namespace).toBe("hanzo") // default
-      expect(Array.isArray(a.endpoints)).toBe(true)
-    }
-  })
-  it("toResourceTree / toManagedResource / toLogLines tolerate junk", () => {
-    for (const j of junk) {
-      expect(Array.isArray(toResourceTree(j).nodes)).toBe(true)
-      expect(() => toManagedResource(j)).not.toThrow()
-      expect(Array.isArray(toLogLines(j))).toBe(true)
-    }
-  })
-  it("wrong-typed fields (health object, numeric name) degrade to empty, dropped", () => {
-    const rows = parseApplications({ applications: [{ name: 123, health: { evil: 1 }, sync: ["x"] }, { name: "ok" }] })
-    expect(rows.map((r) => r.name)).toEqual(["ok"]) // numeric-name row dropped
-    const g = toGitopsApp(normalizeDeployApp({ name: "z", health: { nested: true } }))
-    expect(g.health).toBe("Unknown") // object health → '' → Unknown, NOT guessed up
-  })
-})
-
-// ── B. CYCLE SAFETY — the headline #3 case ───────────────────────────────────
-// Adversarial parentRefs must not wedge buildResourceGraph into an infinite loop.
-
-const treeJSON = (nodes: object[]) => toResourceTree({ nodes })
-const node = (ref: string, kind: string, parents: string[] = []) => ({
-  ref,
-  kind,
-  name: ref,
-  namespace: "demo",
-  parentRefs: parents.map((p) => ({ ref: p })),
-})
-
-describe("RED cycle safety — buildResourceGraph terminates on hostile parentRefs", () => {
-  it("self-referencing parent (A→A) terminates; node survives as a root", () => {
-    const g = within(1000, () => buildResourceGraph(treeJSON([node("A", "Pod", ["A"])])))
-    expect(g.nodes.map((n) => n.id)).toContain("A")
-    expect(g.nodes.find((n) => n.id === "A")!.depth).toBe(0)
-    expect(g.edges).toHaveLength(0) // self-edge dropped
-  })
-
-  // ── HIGH-1 (FIXED): buildResourceGraph used to THROW whenever a node's parent
-  // appeared LATER in the array — `children` was seeded lazily per-node, so
-  // `children.get(pid)!.push(id)` dereferenced undefined. That is EVERY cycle AND
-  // any tree listing a child before its parent (K8s lists are not topologically
-  // sorted), and with no error boundary the whole SPA white-screened. `children`
-  // is now pre-seeded for every id, so order and cycles are both safe. These are
-  // the regression tests: each MUST build a graph, never throw. ───────────────
-  it("BENIGN acyclic tree that lists a child before its parent builds", () => {
-    // Deployment listed before the Application that owns it — a totally normal,
-    // non-adversarial ordering a backend may emit.
-    const g = within(1000, () =>
-      buildResourceGraph(treeJSON([node("dep", "Deployment", ["app"]), node("app", "Application")])),
-    )
-    expect(g.nodes.map((n) => n.id).sort()).toEqual(["app", "dep"])
-    expect(g.nodes.find((n) => n.id === "app")!.depth).toBe(0)
-    expect(g.nodes.find((n) => n.id === "dep")!.depth).toBe(1)
-  })
-
-  it("2-cycle with NO external root (A↔B) does not crash", () => {
-    const g = within(1000, () =>
-      buildResourceGraph(treeJSON([node("A", "Pod", ["B"]), node("B", "Pod", ["A"])])),
-    )
-    expect(Array.isArray(g.nodes)).toBe(true) // unreachable-from-a-root nodes may drop; must not throw
-  })
-
-  it("2-cycle WITH an external root (R→A, A↔B) renders R, A, B", () => {
-    const g = within(1000, () =>
-      buildResourceGraph(treeJSON([node("R", "App"), node("A", "Pod", ["R", "B"]), node("B", "Pod", ["A"])])),
-    )
-    expect(g.nodes.map((n) => n.id).sort()).toEqual(["A", "B", "R"])
-  })
-
-  it("3-cycle (A→B→C→A) with a root renders 4 nodes", () => {
-    const g = within(1000, () =>
-      buildResourceGraph(
-        treeJSON([node("R", "App"), node("A", "Pod", ["R", "C"]), node("B", "Pod", ["A"]), node("C", "Pod", ["B"])]),
-      ),
-    )
-    expect(g.nodes.map((n) => n.id).sort()).toEqual(["A", "B", "C", "R"])
-  })
-
-  it("dangling parent (points at a non-existent uid) → node is a root, no crash", () => {
-    const g = within(1000, () => buildResourceGraph(treeJSON([node("A", "Pod", ["ghost-does-not-exist"])])))
-    expect(g.nodes.find((n) => n.id === "A")!.depth).toBe(0)
-  })
-
-  it("large deep chain (2000 nodes) terminates quickly", () => {
-    const chain = Array.from({ length: 2000 }, (_, i) => node(`n${i}`, "Pod", i ? [`n${i - 1}`] : []))
-    const g = within(6000, () => buildResourceGraph(treeJSON(chain)))
-    expect(g.nodes.length).toBe(2000)
-  })
-
-  it("every node self-parents (all self-cycles) → all render as roots, terminates", () => {
-    const many = Array.from({ length: 500 }, (_, i) => node(`s${i}`, "Pod", [`s${i}`]))
-    const g = within(4000, () => buildResourceGraph(treeJSON(many)))
-    expect(g.nodes.length).toBe(500)
-  })
-})
-
-// ── C. MISLABEL — the fold's one dangerous direction: bad → Healthy/Synced ────
-
-describe("RED mislabel (FIXED) — a BAD state is never up-guessed to a GOOD one", () => {
-  it("health words that MEAN broken never fold to Healthy", () => {
-    // The positive substring up-guess is gone: unrecognized → honest Unknown.
-    expect(foldHealth("Broken")).toBe("Unknown") // contains 'ok'
-    expect(foldHealth("revoked")).toBe("Unknown") // cert/token revoked
-    expect(foldHealth("invoked")).toBe("Unknown")
-    expect(foldHealth("NotReady")).toBe("Unknown") // contains 'ready'
-    expect(foldHealth("unavailable")).toBe("Unknown") // contains 'available'
-    expect(foldHealth("MinimumReplicasUnavailable")).toBe("Unknown")
-    // The canonical vocabulary cloud actually emits still folds exactly:
-    expect(foldHealth("healthy")).toBe("Healthy")
-    expect(foldHealth("")).toBe("Unknown")
-    expect(foldHealth("degraded")).toBe("Degraded")
-    expect(foldHealth("CrashLoopBackOff")).toBe("Degraded") // bad-substring — safe direction
-  })
-
-  it("sync words that MEAN not-synced never fold to Synced", () => {
-    expect(foldSync("notsynced")).toBe("Unknown") // means NOT synced
-    expect(foldSync("unsynced")).toBe("Unknown")
-    expect(foldSync("NotSynced")).toBe("Unknown")
-    // Canonical + separator-normalized cases still fold exactly:
-    expect(foldSync("synced")).toBe("Synced")
-    expect(foldSync("out-of-sync")).toBe("OutOfSync") // hyphens normalized at the source
-    expect(foldSync("out-of-sync".replace(/[-_]/g, ""))).toBe("OutOfSync")
-    expect(foldSync("")).toBe("Unknown")
-  })
-
-  it("SAFE: a Degraded app is never shown Healthy through the adapter", () => {
-    const g = toGitopsApp(normalizeDeployApp({ name: "x", health: "degraded" }))
-    expect(g.health).toBe("Degraded")
-  })
-})
-
-// ── D. Honest sync derivation (no fabricated Synced) ─────────────────────────
-
-describe("RED honest sync — derived state does not fabricate Synced", () => {
-  it("missing sync + version drift → OutOfSync", () => {
-    expect(toGitopsApp(normalizeDeployApp({ name: "a", version: "v2", runningVersion: "v1" })).sync).toBe("OutOfSync")
-  })
-  it("missing sync + equal version → Synced (declared==running proxy)", () => {
-    expect(toGitopsApp(normalizeDeployApp({ name: "a", version: "v1", runningVersion: "v1" })).sync).toBe("Synced")
-  })
-  it("missing sync + BOTH versions empty → Synced (''==''), a benign over-report", () => {
-    // documents: an app the plane reports with no versions folds to Synced, not Unknown.
-    expect(toGitopsApp(normalizeDeployApp({ name: "a" })).sync).toBe("Synced")
-  })
-})
-
-// ── E. Manifest handling — object/string/circular ────────────────────────────
-
-describe("RED manifest — object/string/circular never throw", () => {
-  it("circular object manifest → '' (no throw)", () => {
-    const circular: Record<string, unknown> = { kind: "Deployment" }
-    circular.self = circular
-    expect(manifestText(circular)).toBe("")
-    const m = toManagedResource({ ref: "r", liveManifest: circular })
-    expect(m.liveState).toBe("")
-  })
-  it("object manifest → pretty JSON; string manifest → verbatim; null → ''", () => {
-    expect(toManagedResource({ ref: "r", liveManifest: { a: 1 } }).liveState).toContain('"a": 1')
-    expect(toManagedResource({ ref: "r", liveManifest: "raw yaml here" }).liveState).toBe("raw yaml here")
-    expect(toManagedResource({ ref: "r", liveManifest: null }).liveState).toBe("")
-  })
-  it("a manifest string carrying HTML is passed through as TEXT (React escapes on render)", () => {
-    const evil = "<img src=x onerror=alert(document.cookie)>"
-    // The adapter must NOT interpret it; it stays a plain string (rendered via {text}).
-    expect(toManagedResource({ ref: "r", liveManifest: evil }).liveState).toBe(evil)
-  })
-})
-
-// ── F. Logs — array gap + unbounded blob (no client cap) ─────────────────────
-
-describe("RED logs (FIXED) — fidelity + bound", () => {
-  it("logs delivered as an ARRAY yield lines (blob AND array shapes)", () => {
-    expect(toLogLines({ pod: "p", logs: ["line-1", "line-2"] })).toEqual([
-      { content: "line-1", podName: "p" },
-      { content: "line-2", podName: "p" },
-    ])
-    // the blob shape still works
-    expect(toLogLines({ pod: "p", logs: "a\nb" }).map((l) => l.content)).toEqual(["a", "b"])
-  })
-  it("a huge blob is line-capped client-side (keeps the most recent lines)", () => {
-    const blob = Array.from({ length: 50_000 }, (_, i) => `l${i}`).join("\n")
-    const out = toLogLines({ pod: "p", logs: blob })
-    expect(out.length).toBe(2000) // MAX_LOG_LINES
-    expect(out[out.length - 1].content).toBe("l49999") // tail kept, not head
-  })
-  it("a single enormous line is clamped (no one-megabyte text node)", () => {
-    const huge = "x".repeat(50_000)
-    const out = toLogLines({ pod: "p", logs: huge })
-    expect(out[0].content.length).toBeLessThanOrEqual(4001) // MAX_LOG_LINE + ellipsis
-  })
-})
-
-// ── G. Rollback semver filter — injection + hygiene ──────────────────────────
-
-describe("RED rollback — only clean semver, current excluded, no injection", () => {
-  it("drops non-semver + injection-shaped tags, excludes current, newest-first, dedupes", () => {
-    const h = toRollbackHistory("v1.800.1", [
-      "v1.800.0",
-      "latest",
-      "main",
-      "deadbeef",
-      "v1.800.1", // == current → excluded
-      "v1.799.15",
-      "v1.799.15", // dup
-      "v1.2.3; rm -rf /", // injection shape → not semver → dropped
-      "'; DROP TABLE apps;--",
-    ])
-    expect(h.map((r) => r.revision)).toEqual(["v1.800.0", "v1.799.15"])
-    expect(h[0].id).toBeGreaterThan(h[1].id)
-  })
-  it("pre-release semver IS offered as a rollback target (documents the accepted grammar)", () => {
-    const h = toRollbackHistory("v2.0.0", ["v1.9.9-rc.1", "v1.9.9"])
-    expect(h.map((r) => r.revision)).toContain("v1.9.9-rc.1")
-  })
-  it("empty history → []", () => {
-    expect(toRollbackHistory("v1.0.0", [])).toEqual([])
-  })
-})

apps/cd/src/lib/adapt.test.ts

@@ -1,149 +0,0 @@
-/**
- * The /v1/deploy → @hanzo/cd adapter — pins the console CD app against cloud's
- * REAL clients/deploy shapes (the hyphenated sync verdict, object manifests,
- * parentRefs tree edges, the logs blob, clean-semver rollback).
- */
-import { describe, expect, it } from "vitest"
-
-import {
-  normalizeDeployApp,
-  parseApplications,
-  toGitopsApp,
-  toLogLines,
-  toManagedResource,
-  toResourceTree,
-  toRollbackHistory,
-} from "./adapt"
-
-describe("toGitopsApp", () => {
-  it("folds the hyphenated cloud sync verdict (the foldSync hyphen bug)", () => {
-    const a = parseApplications({
-      applications: [
-        { name: "iam", namespace: "hanzo", env: "main", repository: "ghcr.io/hanzoai/iam", version: "v1.4.11", runningVersion: "v1.4.10", health: "progressing", healthMessage: "rolling", sync: "out-of-sync" },
-      ],
-    })[0]
-    const g = toGitopsApp(a)
-    expect(g.sync).toBe("OutOfSync") // 'out-of-sync' must NOT fall through to Unknown
-    expect(g.health).toBe("Progressing")
-    expect(g.revision).toBe("v1.4.11")
-    expect(g.source).toEqual({ repoURL: "ghcr.io/hanzoai/iam" })
-    expect(g.message).toBe("rolling")
-    expect(g.project).toBe("main")
-  })
-  it("derives sync from declared-vs-running when the plane omits it", () => {
-    const [drift, synced] = parseApplications([
-      { name: "a", repository: "r", version: "v2", runningVersion: "v1" },
-      { name: "b", repository: "r", version: "v1", runningVersion: "v1" },
-    ])
-    expect(toGitopsApp(drift).sync).toBe("OutOfSync")
-    expect(toGitopsApp(synced).sync).toBe("Synced")
-  })
-})
-
-describe("parseApplications", () => {
-  it("tolerates a bare array and drops nameless rows", () => {
-    expect(parseApplications([{ name: "cloud" }, { name: "" }]).map((a) => a.name)).toEqual(["cloud"])
-  })
-})
-
-describe("toResourceTree", () => {
-  it("maps parentRefs[].ref into linking AppTreeNodes (uid == ref token)", () => {
-    const tree = toResourceTree({
-      nodes: [
-        { group: "hanzo.ai", version: "v1", kind: "App", namespace: "hanzo", name: "iam", ref: "hanzo.ai:App:hanzo:iam", parentRefs: [] },
-        { group: "apps", version: "v1", kind: "Deployment", namespace: "hanzo", name: "iam", ref: "apps:Deployment:hanzo:iam", health: "progressing", parentRefs: [{ ref: "hanzo.ai:App:hanzo:iam" }] },
-      ],
-    })
-    expect(tree.nodes).toHaveLength(2)
-    const dep = tree.nodes.find((n) => n.kind === "Deployment")!
-    expect(dep.uid).toBe("apps:Deployment:hanzo:iam")
-    expect(dep.parentRefs?.[0].uid).toBe("hanzo.ai:App:hanzo:iam") // matches the App node's uid → the tree links
-    expect(dep.health?.status).toBe("Progressing")
-  })
-})
-
-describe("toManagedResource", () => {
-  it("stringifies object manifests + reads the nested desired manifest", () => {
-    const m = toManagedResource({
-      ref: { group: "apps", version: "v1", kind: "Deployment", namespace: "hanzo", name: "iam", ref: "apps:Deployment:hanzo:iam" },
-      liveManifest: { kind: "Deployment", spec: { replicas: 1 } },
-      diff: { modified: true, desiredManifest: { kind: "Deployment", spec: { replicas: 2 } } },
-    })
-    expect(m.uid).toBe("apps:Deployment:hanzo:iam")
-    expect(m.liveState).toContain('"replicas": 1')
-    expect(m.targetState).toContain('"replicas": 2')
-  })
-})
-
-describe("toLogLines", () => {
-  it("splits the /v1/deploy logs blob and tags the pod", () => {
-    const lines = toLogLines({ pod: "iam-abc", logs: "first\nsecond\n" })
-    expect(lines).toHaveLength(2)
-    expect(lines[0]).toEqual({ content: "first", podName: "iam-abc" })
-  })
-  it("honest empty when no logs", () => {
-    expect(toLogLines({ pod: "", logs: "" })).toEqual([])
-  })
-})
-
-describe("toRollbackHistory", () => {
-  it("offers only clean-semver releases, current excluded, newest first", () => {
-    const h = toRollbackHistory("v1.800.1", ["v1.800.0", "latest", "v1.799.15", "v1.800.1", "main"])
-    expect(h.map((r) => r.revision)).toEqual(["v1.800.0", "v1.799.15"])
-    expect(h[0].id).toBeGreaterThan(h[1].id) // monotonic ids for the dialog
-  })
-})
-
-// ── the ACTUAL argoproj shape /v1/deploy/applications serves in production ────
-// Captured live (cloud v1.801.109). The first cut read only flat keys, so the
-// fleet bound to zero rows against real data; this pins the real contract.
-describe("live argoproj-shaped application", () => {
-  const LIVE = {
-    apiVersion: "argoproj.io/v1alpha1",
-    kind: "Application",
-    metadata: {
-      name: "admin-guard",
-      namespace: "hanzo",
-      uid: "257fcb88-974d-46fc-8ac2-6f8b86a1f15f",
-      creationTimestamp: "2026-07-15T05:31:10Z",
-      labels: { "hanzo.ai/env": "main", "hanzo.ai/instance": "admin-guard" },
-    },
-    spec: {
-      source: { repoURL: "https://git.hanzo.ai/hanzoai/universe", path: "infra/k8s/operator/crs", targetRevision: "main" },
-      destination: { server: "https://kubernetes.default.svc", namespace: "hanzo" },
-      project: "default",
-    },
-    status: {
-      sync: { status: "Synced", revision: "v0.1.4" },
-      health: { status: "Healthy", message: "Running: available" },
-      resources: [],
-      summary: { images: ["ghcr.io/hanzoai/admin-guard:v0.1.4"] },
-    },
-  }
-
-  it("binds name/env/health/sync/revision/repository from the nested shape", () => {
-    const a = normalizeDeployApp(LIVE)
-    expect(a.name).toBe("admin-guard")
-    expect(a.namespace).toBe("hanzo")
-    expect(a.env).toBe("main")
-    expect(a.health).toBe("Healthy")
-    expect(a.sync).toBe("Synced")
-    expect(a.version).toBe("v0.1.4")
-    expect(a.repository).toBe("ghcr.io/hanzoai/admin-guard")
-    expect(a.runningVersion).toBe("v0.1.4")
-  })
-
-  it("folds to a Healthy/Synced gitops app (the fleet row renders)", () => {
-    const g = toGitopsApp(normalizeDeployApp(LIVE))
-    expect(g.name).toBe("admin-guard")
-    expect(g.health).toBe("Healthy")
-    expect(g.sync).toBe("Synced")
-  })
-
-  it("still reads the flat native shape (both wires supported)", () => {
-    const a = normalizeDeployApp({ name: "x", health: "degraded", sync: "out-of-sync", version: "v1.2.3" })
-    expect(a.name).toBe("x")
-    expect(a.health).toBe("degraded")
-    expect(toGitopsApp(a).sync).toBe("OutOfSync")
-  })
-})

apps/cd/src/lib/adapt.ts

@@ -1,271 +0,0 @@
-/**
- * The CD data adapter — maps cloud's `/v1/deploy` DTOs INTO the shared view-models
- * of `@hanzo/cd` (GitopsApplication / ResourceTree / ManagedResource / LogLine
- * / RevisionHistory). Reuses each package's OWN pure folds (foldHealth/foldSync) so
- * status vocabulary is one way. No React, no I/O — unit-testable.
- *
- * Contract (cloud clients/deploy):
- *   applications: [{name,namespace,env,role,repository,version,runningVersion,
- *                  health,healthMessage,sync,phase,endpoints}]
- *   {name}/tree:  {application, nodes:[{group,version,kind,namespace,name,ref,uid,
- *                  createdAt,health,healthMessage,sync,version,parentRefs:[{…,ref}]}]}
- *   {name}/resource/{ref}: {ref, health, healthMessage, liveManifest:{…},
- *                  desiredSource, diff:{modified,desiredManifest:{…}}}
- *   {name}/logs:  {application, pod, container, logs:"…", note?}
- */
-import {
-  foldHealth,
-  foldSync,
-  type AppTreeNode,
-  type GitopsApplication,
-  type LogLine,
-  type ManagedResource,
-  type ResourceRef,
-  type ResourceTree,
-  type RevisionHistory,
-} from "@hanzo/cd"
-
-// ── optional-safe helpers (snake_case + camelCase tolerant) ──────────────────
-
-const str = (v: unknown): string => (typeof v === "string" ? v : "")
-const arr = (v: unknown): unknown[] => (Array.isArray(v) ? v : [])
-const rec = (v: unknown): Record<string, unknown> =>
-  v && typeof v === "object" ? (v as Record<string, unknown>) : {}
-const pick = (r: Record<string, unknown>, ...keys: string[]): unknown => {
-  for (const k of keys) if (r[k] !== undefined && r[k] !== null) return r[k]
-  return undefined
-}
-const strList = (v: unknown): string[] => arr(v).map(str).filter(Boolean)
-const epochMs = (v: unknown): number | undefined => {
-  const s = str(v)
-  if (!s) return undefined
-  const t = Date.parse(s)
-  return Number.isNaN(t) ? undefined : t
-}
-
-// The cloud wire uses hyphenated verdicts (`out-of-sync`); @hanzo/cd's folds
-// strip whitespace but not hyphens, so normalize `[-_]` out before folding.
-const fHealth = (raw: string) => foldHealth(raw.replace(/[-_]/g, ""))
-const fSync = (raw: string) => foldSync(raw.replace(/[-_]/g, ""))
-
-/** A manifest object → pretty JSON text; a string verbatim; else ''. */
-export function manifestText(v: unknown): string {
-  if (typeof v === "string") return v
-  if (v && typeof v === "object") {
-    try {
-      return JSON.stringify(v, null, 2)
-    } catch {
-      return ""
-    }
-  }
-  return ""
-}
-
-/** repo basename of an image repository: `ghcr.io/hanzoai/iam` → `iam`. */
-export function repoBaseName(repository: string): string {
-  const s = (repository || "").trim().replace(/:.*/, "")
-  return (s.split("/").filter(Boolean).pop() ?? "").toLowerCase()
-}
-
-// ── Application ──────────────────────────────────────────────────────────────
-
-export interface DeployApp {
-  name: string
-  namespace: string
-  env: string
-  role: string
-  repository: string
-  version: string
-  runningVersion: string
-  health: string
-  healthMessage: string
-  sync: string
-  phase: string
-  endpoints: string[]
-  /** Prior release tags the plane records (forward-compat rollback source); [] today. */
-  revisions: string[]
-}
-
-/** Normalize a raw /v1/deploy application row to a stable internal shape. */
-/**
- * Normalize one application from EITHER wire shape:
- *
- *  - argoproj (what `/v1/deploy/applications` actually serves): the projection
- *    nests everything — `metadata.{name,namespace,labels}`, `spec.source.*`,
- *    `spec.project`, `status.{sync,health}.status`, `status.summary.images[]`.
- *  - flat native: `{name,namespace,env,repository,version,health,sync,…}`.
- *
- * Both are read here so the app binds regardless of which the plane returns —
- * flat keys win when present, then the nested argo fields fill in.
- */
-export function normalizeDeployApp(raw: unknown): DeployApp {
-  const r = rec(raw)
-  const meta = rec(pick(r, "metadata"))
-  const spec = rec(pick(r, "spec"))
-  const status = rec(pick(r, "status"))
-  const source = rec(pick(spec, "source"))
-  const dest = rec(pick(spec, "destination"))
-  const sync = rec(pick(status, "sync"))
-  const health = rec(pick(status, "health"))
-  const labels = rec(pick(meta, "labels"))
-  const summary = rec(pick(status, "summary"))
-  // `status.summary.images: ["ghcr.io/hanzoai/x:v1.2.3"]` → repository + tag.
-  const image = strList(pick(summary, "images"))[0] ?? ""
-  const cut = image.lastIndexOf(":")
-  const imageRepo = cut > 0 ? image.slice(0, cut) : image
-  const imageTag = cut > 0 ? image.slice(cut + 1) : ""
-
-  return {
-    name: str(pick(r, "name")) || str(pick(meta, "name")),
-    namespace:
-      str(pick(r, "namespace", "ns")) || str(pick(meta, "namespace")) || str(pick(dest, "namespace")) || "hanzo",
-    env: str(pick(r, "env", "environment")) || str(pick(labels, "hanzo.ai/env")) || str(pick(source, "targetRevision")),
-    role: str(pick(r, "role")),
-    // Prefer the deployed image repository; fall back to the manifest repo URL.
-    repository: str(pick(r, "repository", "repo")) || imageRepo || str(pick(source, "repoURL")),
-    version: str(pick(r, "version", "tag")) || str(pick(sync, "revision")) || imageTag,
-    runningVersion: str(pick(r, "runningVersion", "running_version")) || imageTag,
-    health: str(pick(r, "health")) || str(pick(health, "status")),
-    healthMessage:
-      str(pick(r, "healthMessage", "health_message", "message")) || str(pick(health, "message")),
-    sync: str(pick(r, "sync", "syncStatus", "sync_status")) || str(pick(sync, "status")),
-    phase: str(pick(r, "phase")) || str(pick(health, "status")),
-    endpoints: strList(pick(r, "endpoints", "urls")),
-    revisions: strList(pick(r, "revisions", "history", "tags")),
-  }
-}
-
-/** Parse the applications list payload (array or {applications|apps|items}). */
-export function parseApplications(data: unknown): DeployApp[] {
-  const rows = Array.isArray(data) ? data : arr(pick(rec(data), "applications", "apps", "items", "services"))
-  return rows.map(normalizeDeployApp).filter((a) => a.name)
-}
-
-/** Fold a normalized app into the @hanzo/cd application view-model. */
-export function toGitopsApp(a: DeployApp): GitopsApplication {
-  return {
-    name: a.name,
-    namespace: a.namespace,
-    project: a.env || undefined,
-    health: fHealth(a.health),
-    // desired (declared version) vs live (runningVersion): equal ⇒ Synced.
-    sync: a.sync ? fSync(a.sync) : fSync(a.version === a.runningVersion ? "synced" : "outofsync"),
-    revision: a.version || undefined,
-    source: a.repository ? { repoURL: a.repository } : undefined,
-    message: a.healthMessage || undefined,
-  }
-}
-
-// ── tree → ResourceTree (AppTreeNode with linking parentRefs) ────────────────
-
-/** Map a /v1/deploy ResourceRef DTO (carrying its `ref` token) to a linking ref.
- *  The `ref` token is the stable id shared by a node and its children's
- *  parentRefs, so it drives resourceId() — the tree links on it. */
-function toRef(raw: unknown): ResourceRef {
-  const r = rec(raw)
-  const token = str(pick(r, "ref"))
-  return {
-    uid: token || str(pick(r, "uid")),
-    group: str(pick(r, "group")),
-    version: str(pick(r, "version")),
-    kind: str(pick(r, "kind")),
-    namespace: str(pick(r, "namespace", "ns")),
-    name: str(pick(r, "name")),
-  }
-}
-
-function toTreeNode(raw: unknown): AppTreeNode {
-  const r = rec(raw)
-  const self = toRef(r)
-  const version = str(pick(r, "version"))
-  return {
-    ...self,
-    parentRefs: arr(pick(r, "parentRefs", "parent_refs")).map(toRef),
-    health: { status: fHealth(str(pick(r, "health"))), message: str(pick(r, "healthMessage")) || undefined },
-    sync: pick(r, "sync") ? fSync(str(pick(r, "sync"))) : undefined,
-    images: version ? [version] : [],
-    createdAt: epochMs(pick(r, "createdAt", "created_at", "creationTimestamp")),
-  }
-}
-
-export function toResourceTree(raw: unknown): ResourceTree {
-  const r = rec(raw)
-  const nodes = arr(pick(r, "nodes", "resources"))
-    .map(toTreeNode)
-    .filter((n) => n.name && n.kind)
-    // Defense-in-depth: never render a Secret node (its live manifest carries
-    // base64 data). Cloud already excludes Secrets from the tree; drop any that
-    // slip through so the client never surfaces one.
-    .filter((n) => n.kind !== "Secret")
-  return { nodes }
-}
-
-// ── resource → ManagedResource (live + desired for the node drawer/diff) ─────
-
-export function toManagedResource(raw: unknown): ManagedResource {
-  const r = rec(raw)
-  const refField = pick(r, "ref")
-  const self: ResourceRef =
-    typeof refField === "string"
-      ? { uid: refField, group: "", version: "", kind: "", namespace: "", name: "" }
-      : toRef(refField)
-  const diffObj = rec(pick(r, "diff"))
-  const desired = pick(r, "desiredManifest", "desired") ?? pick(diffObj, "desiredManifest", "desired")
-  return {
-    ...self,
-    liveState: manifestText(pick(r, "liveManifest", "live_manifest", "live", "manifest")),
-    targetState: manifestText(desired),
-  }
-}
-
-// ── logs (blob OR array) → LogLine[], bounded ────────────────────────────────
-
-// Client-side caps so one giant log payload can't bloat the DOM even if the
-// server's `?tail` is absent or ignored: keep the last MAX_LOG_LINES, and clamp
-// any single line (a newline-free megabyte otherwise renders as one huge node).
-const MAX_LOG_LINES = 2000
-const MAX_LOG_LINE = 4000
-
-export function toLogLines(raw: unknown): LogLine[] {
-  const r = rec(raw)
-  const pod = str(pick(r, "pod")) || undefined
-  // Tolerate both shapes: a newline blob (`logs:"…"`) and a line array
-  // (`logs:[…]` / `lines:[…]`), which the blob-only path silently dropped to [].
-  const listed = arr(pick(r, "logs", "lines", "log", "output"))
-  const lines = listed.length
-    ? listed.map(str)
-    : str(pick(r, "logs", "log", "output")).split("\n")
-  const kept = lines.filter((l) => l.length > 0).slice(-MAX_LOG_LINES)
-  return kept.map((l) => ({ content: l.length > MAX_LOG_LINE ? l.slice(0, MAX_LOG_LINE) + "…" : l, podName: pod }))
-}
-
-// ── git tags → RevisionHistory[] (rollback targets; cloud takes a clean semver) ─
-
-const SEMVER = /^v\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/
-export const isReleaseTag = (t: string): boolean => SEMVER.test(t.trim())
-
-/** Build rollback history from an app's real git tags (clean semver, newest first,
- *  current excluded). `revision` carries the tag cloud's rollback endpoint accepts. */
-export function toRollbackHistory(currentTag: string, tags: string[]): RevisionHistory[] {
-  const seen = new Set<string>([currentTag.trim()])
-  const clean: string[] = []
-  for (const raw of tags) {
-    const t = raw.trim()
-    if (!t || seen.has(t) || !isReleaseTag(t)) continue
-    seen.add(t)
-    clean.push(t)
-  }
-  clean.sort(compareSemverDesc)
-  return clean.map((revision, i) => ({ id: clean.length - i, revision }))
-}
-
-export function compareSemverDesc(a: string, b: string): number {
-  const pa = semverParts(a)
-  const pb = semverParts(b)
-  for (let i = 0; i < 3; i++) if (pa[i] !== pb[i]) return pb[i] - pa[i]
-  return b.localeCompare(a)
-}
-function semverParts(tag: string): [number, number, number] {
-  const m = /^v?(\d+)\.(\d+)\.(\d+)/.exec(tag.trim())
-  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : [-1, -1, -1]
-}

apps/cd/src/lib/deploy.ts

@@ -1,90 +0,0 @@
-/**
- * The typed client for cloud's native CD plane (`/v1/deploy`). Same-origin: the
- * cd.hanzo.ai ingress peels `/v1/deploy/*` off to the cloud binary, so the SPA
- * calls it with `credentials: 'include'` and the first-party `hanzo_iam_token`
- * cookie (set by the PKCE login) rides — cloud validates it (SuperAdmin gate). A
- * 401/403 surfaces as an `ApiError` so the app can send the user back to sign in.
- *
- * Responses are mapped INTO the shared `@hanzo/cd` view-models by `./adapt`.
- */
-import type { LogLine, ManagedResource, ResourceTree } from "@hanzo/cd"
-
-import { parseApplications, toLogLines, toManagedResource, toResourceTree, type DeployApp } from "./adapt"
-
-export class ApiError extends Error {
-  status: number
-  constructor(message: string, status: number) {
-    super(message)
-    this.name = "ApiError"
-    this.status = status
-  }
-}
-
-/** True when the error means "not signed in / not authorized" (→ sign-in screen). */
-export const isAuthError = (e: unknown): boolean => e instanceof ApiError && (e.status === 401 || e.status === 403)
-
-const url = (path: string): string => `/v1/deploy/${path.replace(/^\/+/, "")}`
-
-async function request<T>(method: "GET" | "POST", path: string, body?: unknown): Promise<T> {
-  let res: Response
-  try {
-    res = await fetch(url(path), {
-      method,
-      credentials: "include",
-      headers: body !== undefined ? { "Content-Type": "application/json" } : undefined,
-      body: body !== undefined ? JSON.stringify(body) : undefined,
-    })
-  } catch (e) {
-    throw new ApiError(e instanceof Error ? e.message : "network error", 0)
-  }
-  if (!res.ok) {
-    let msg = `${res.status} ${res.statusText}`
-    try {
-      const j = (await res.json()) as { error?: string; message?: string }
-      msg = j.error || j.message || msg
-    } catch {
-      /* non-JSON body */
-    }
-    throw new ApiError(msg, res.status)
-  }
-  if (res.status === 204) return undefined as T
-  return (await res.json()) as T
-}
-
-export const DeployApi = {
-  /** The fleet: every operator App CR (`GET /v1/deploy/applications`). */
-  applications: async (): Promise<DeployApp[]> => parseApplications(await request<unknown>("GET", "applications")),
-
-  /**
-   * One application's owned-resource tree
-   * (`GET /v1/deploy/applications/:name/resource-tree`).
-   *
-   * The wired route lives under `applications/` — the shorter `:name/tree` form
-   * belongs to an unregistered handler, so it 404s against the live plane.
-   */
-  tree: async (name: string): Promise<ResourceTree> =>
-    toResourceTree(await request<unknown>("GET", `applications/${encodeURIComponent(name)}/resource-tree`)),
-
-  /** One tree node's live manifest + desired-vs-live (`GET /v1/deploy/:name/resource/:ref`). */
-  resource: async (name: string, ref: string): Promise<ManagedResource> =>
-    toManagedResource(await request<unknown>("GET", `${encodeURIComponent(name)}/resource/${encodeURIComponent(ref)}`)),
-
-  /** The newest pod's logs (`GET /v1/deploy/:name/logs`). */
-  logs: async (name: string, tail = 300): Promise<LogLine[]> =>
-    toLogLines(await request<unknown>("GET", `${encodeURIComponent(name)}/logs?tail=${tail}`)),
-
-  /** Pin the CR image to a prior clean-semver release (`POST /v1/deploy/:name/rollback`). */
-  rollback: async (name: string, tag: string): Promise<void> => {
-    await request<unknown>("POST", `${encodeURIComponent(name)}/rollback`, { tag })
-  },
-
-  /** Request an operator reconcile now (`POST /v1/deploy/:name/sync`). */
-  sync: async (name: string): Promise<void> => {
-    await request<unknown>("POST", `${encodeURIComponent(name)}/sync`, {})
-  },
-}
-
-/** Read the `hanzo_iam_token` cookie the PKCE login sets (non-httpOnly by design). */
-export function hasSession(): boolean {
-  return document.cookie.split(";").some((c) => c.trim().startsWith("hanzo_iam_token="))
-}

apps/cd/src/main.tsx

@@ -1,14 +0,0 @@
-import { StrictMode } from "react"
-import { createRoot } from "react-dom/client"
-
-import { App } from "./App"
-import { ErrorBoundary } from "./shell/ErrorBoundary"
-import "./styles.css"
-
-createRoot(document.getElementById("root")!).render(
-  <StrictMode>
-    <ErrorBoundary>
-      <App />
-    </ErrorBoundary>
-  </StrictMode>,
-)

apps/cd/src/shell/ErrorBoundary.tsx

@@ -1,51 +0,0 @@
-import { Component, type ErrorInfo, type ReactNode } from "react"
-
-/**
- * Top-level boundary so a single component render throw can never white-screen
- * the whole dashboard. A caught error shows a recover panel (back to the fleet /
- * reload) instead of an unmounted root. Deliberately dependency-free.
- */
-export class ErrorBoundary extends Component<{ children: ReactNode }, { error: Error | null }> {
-  state = { error: null as Error | null }
-
-  static getDerivedStateFromError(error: Error) {
-    return { error }
-  }
-
-  componentDidCatch(error: Error, info: ErrorInfo) {
-    // Surface to the console for the operator; never log identity/token.
-    console.error("[cd] render error", error, info.componentStack)
-  }
-
-  private reset = () => {
-    this.setState({ error: null })
-    if (location.hash && location.hash !== "#/") location.hash = "#/"
-  }
-
-  render() {
-    if (!this.state.error) return this.props.children
-    return (
-      <div style={{ maxWidth: 520, margin: "12vh auto", padding: "0 24px", textAlign: "center", fontFamily: "'Geist', ui-sans-serif, system-ui, sans-serif" }}>
-        <h1 style={{ fontSize: 20, fontWeight: 700, margin: "0 0 8px" }}>Something went wrong</h1>
-        <p style={{ color: "#8a8a8a", fontSize: 14, margin: "0 0 20px" }}>
-          A view failed to render. Your fleet is unaffected — this is only the dashboard.
-        </p>
-        <div style={{ display: "flex", gap: 10, justifyContent: "center" }}>
-          <button onClick={this.reset} style={btn(true)}>← Back to fleet</button>
-          <button onClick={() => location.reload()} style={btn(false)}>Reload</button>
-        </div>
-      </div>
-    )
-  }
-}
-
-const btn = (primary: boolean): React.CSSProperties => ({
-  padding: "9px 16px",
-  fontSize: 14,
-  fontWeight: 600,
-  cursor: "pointer",
-  borderRadius: 8,
-  border: primary ? "0" : "1px solid #2a2a2a",
-  background: primary ? "#fff" : "transparent",
-  color: primary ? "#000" : "inherit",
-})

apps/cd/src/shell/Topbar.tsx

@@ -1,102 +0,0 @@
-/**
- * The Hanzo CD topbar — the shared shell chrome for the dedicated dashboard: the
- * small Hanzo mark + wordmark (top-left), the environment scope switcher (the CD
- * "project" dimension — main/test/dev, the operator namespaces), a refresh, and
- * sign-out. Lean + self-contained (dark, Geist) so the static SPA has no heavy
- * shell dependency; the org/project↔IAM switcher lights up when /v1/iam is routed
- * on cd.hanzo.ai (today the SuperAdmin cookie sees the whole fleet).
- */
-
-const MARK = (size: number, fill: string) => (
-  <svg width={size} height={size} viewBox="0 0 67 67" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
-    <path d="M22.21 67V44.6369H0V67H22.21Z" fill={fill} />
-    <path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z" fill={fill} />
-    <path d="M22.21 0H0V22.3184H22.21V0Z" fill={fill} />
-    <path d="M66.7198 0H44.5098V22.3184H66.7198V0Z" fill={fill} />
-    <path d="M66.7198 67V44.6369H44.5098V67H66.7198Z" fill={fill} />
-  </svg>
-)
-
-export interface EnvOption {
-  id: string
-  label: string
-  count: number
-}
-
-export function Topbar({
-  envs,
-  env,
-  onEnv,
-  onRefresh,
-  refreshing,
-  onSignOut,
-}: {
-  envs: EnvOption[]
-  env: string
-  onEnv: (id: string) => void
-  onRefresh: () => void
-  refreshing?: boolean
-  onSignOut: () => void
-}) {
-  return (
-    <header
-      style={{
-        display: "flex",
-        alignItems: "center",
-        gap: 12,
-        padding: "10px 16px",
-        borderBottom: "1px solid var(--cd-border)",
-        background: "var(--cd-surface)",
-        position: "sticky",
-        top: 0,
-        zIndex: 20,
-        flexWrap: "wrap",
-      }}
-    >
-      <a href="/" style={{ display: "flex", alignItems: "center", gap: 9, textDecoration: "none", color: "var(--cd-fg-strong)" }}>
-        <span style={{ display: "inline-flex" }}>{MARK(18, "#fff")}</span>
-        <span style={{ fontWeight: 800, letterSpacing: "-0.02em", fontSize: 15 }}>Hanzo CD</span>
-      </a>
-
-      {envs.length > 1 ? (
-        <div style={{ display: "inline-flex", gap: 2, background: "var(--cd-surface-2)", borderRadius: 8, padding: 2, border: "1px solid var(--cd-border)" }}>
-          {[{ id: "", label: "All", count: envs.reduce((n, e) => n + e.count, 0) }, ...envs].map((o) => {
-            const on = o.id === env
-            return (
-              <button
-                key={o.id || "all"}
-                type="button"
-                onClick={() => onEnv(o.id)}
-                className="cd-mono"
-                style={{
-                  border: 0,
-                  cursor: "pointer",
-                  fontSize: 12,
-                  fontWeight: 600,
-                  padding: "5px 10px",
-                  borderRadius: 6,
-                  background: on ? "var(--cd-border-strong)" : "transparent",
-                  color: on ? "var(--cd-fg-strong)" : "var(--cd-fg-muted)",
-                }}
-              >
-                {o.label}
-                <span style={{ opacity: 0.6, marginLeft: 5 }}>{o.count}</span>
-              </button>
-            )
-          })}
-        </div>
-      ) : null}
-
-      <span style={{ flex: 1 }} />
-
-      <button type="button" className="cd-btn" onClick={onRefresh} disabled={refreshing}>
-        {refreshing ? "Refreshing…" : "Refresh"}
-      </button>
-      <button type="button" className="cd-btn" onClick={onSignOut}>
-        Sign out
-      </button>
-    </header>
-  )
-}
-
-export { MARK }

apps/cd/src/styles.css

@@ -1,90 +0,0 @@
-/* Hanzo CD — app chrome. The @hanzo/gitops components bring their OWN scoped CSS
-   (GitopsStyles + THEME_VARS); this is only the shell + page shell, dark-first,
-   Geist. Mobile-first: nothing scrolls the body horizontally. */
-
-:root {
-  color-scheme: dark;
-  --cd-bg: #0a0a0a;
-  --cd-surface: #0d1117;
-  --cd-surface-2: #161b22;
-  --cd-border: #21262d;
-  --cd-border-strong: #30363d;
-  --cd-fg: #e7e7e7;
-  --cd-fg-muted: #8b949e;
-  --cd-fg-strong: #f0f6fc;
-  --cd-accent: #2f81f7;
-  --cd-sans: "Geist", "Geist Sans", ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
-  --cd-mono: "Geist Mono", ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
-}
-
-* {
-  box-sizing: border-box;
-}
-html,
-body,
-#root {
-  height: 100%;
-  margin: 0;
-}
-html {
-  overflow-x: hidden;
-}
-body {
-  font-family: var(--cd-sans);
-  background: var(--cd-bg);
-  color: var(--cd-fg);
-  -webkit-font-smoothing: antialiased;
-}
-
-.cd-app {
-  display: flex;
-  flex-direction: column;
-  min-height: 100%;
-}
-.cd-main {
-  flex: 1;
-  min-width: 0;
-  padding: 20px;
-  max-width: 1400px;
-  width: 100%;
-  margin: 0 auto;
-}
-@media (max-width: 640px) {
-  .cd-main {
-    padding: 14px;
-  }
-}
-
-.cd-btn {
-  font-family: inherit;
-  font-size: 13px;
-  font-weight: 600;
-  border: 1px solid var(--cd-border-strong);
-  background: var(--cd-surface-2);
-  color: var(--cd-fg);
-  border-radius: 8px;
-  padding: 8px 12px;
-  cursor: pointer;
-  display: inline-flex;
-  align-items: center;
-  gap: 6px;
-  min-height: 36px;
-}
-.cd-btn:hover {
-  border-color: var(--cd-fg-muted);
-}
-.cd-btn--primary {
-  background: #fff;
-  color: #000;
-  border-color: #fff;
-}
-.cd-btn:disabled {
-  opacity: 0.5;
-  cursor: default;
-}
-.cd-muted {
-  color: var(--cd-fg-muted);
-}
-.cd-mono {
-  font-family: var(--cd-mono);
-}

apps/cd/src/views/AppView.tsx

@@ -1,194 +0,0 @@
-/**
- * The application detail — the ArgoCD-grade drill-in, composed from the shared
- * @hanzo/cd components: `GitopsSyncPanel` (health/sync/revision + Sync /
- * Refresh / History), `GitopsAppTree` (the owned-resource topology), `GitopsNodeInfo`
- * (a node's manifest / desired-vs-live diff / events / logs), and `GitopsRollbackDialog`.
- *
- * Composed (not the fixed `GitopsAppDetails`) so a node's manifest + logs are
- * fetched LAZILY on selection (the plane's `/resource` + `/logs` reads) rather than
- * pre-fetched for the whole tree. Every effect is a real `/v1/deploy` call; honest
- * loading/empty/error states, never fabricated.
- */
-import { useCallback, useEffect, useState } from "react"
-import {
-  GitopsAppTree,
-  GitopsNodeInfo,
-  GitopsRollbackDialog,
-  GitopsSyncPanel,
-  type AppTreeNode,
-  type LogLine,
-  type ManagedResource,
-  type ResourceTree,
-  type SyncOptions,
-} from "@hanzo/cd"
-
-import { DeployApi } from "../lib/deploy"
-import { toGitopsApp, toRollbackHistory, type DeployApp } from "../lib/adapt"
-
-export function AppView({
-  app,
-  onBack,
-  onChanged,
-  notify,
-}: {
-  app: DeployApp
-  onBack: () => void
-  onChanged: () => void
-  notify: (msg: string, err?: boolean) => void
-}) {
-  const gitopsApp = toGitopsApp(app)
-  const [tree, setTree] = useState<ResourceTree | null | undefined>(undefined)
-  const [treeErr, setTreeErr] = useState<string>("")
-  const [logs, setLogs] = useState<LogLine[]>([])
-  const [selected, setSelected] = useState<AppTreeNode | null>(null)
-  const [resource, setResource] = useState<ManagedResource | undefined>(undefined)
-  const [rollbackOpen, setRollbackOpen] = useState(false)
-  const [busy, setBusy] = useState(false)
-
-  const history = toRollbackHistory(app.version, app.revisions)
-
-  const load = useCallback(() => {
-    let live = true
-    setTree(undefined)
-    setTreeErr("")
-    setSelected(null)
-    DeployApi.tree(app.name)
-      .then((t) => live && setTree(t))
-      .catch((e) => {
-        if (live) {
-          setTree(null)
-          setTreeErr(e instanceof Error ? e.message : "failed to load")
-        }
-      })
-    DeployApi.logs(app.name)
-      .then((l) => live && setLogs(l))
-      .catch(() => live && setLogs([]))
-    return () => {
-      live = false
-    }
-  }, [app.name])
-  useEffect(() => load(), [load])
-
-  const onSelect = useCallback(
-    (node: AppTreeNode | null) => {
-      setSelected(node)
-      setResource(undefined)
-      if (!node) return
-      DeployApi.resource(app.name, node.uid ?? "")
-        .then(setResource)
-        .catch(() => setResource(undefined))
-    },
-    [app.name],
-  )
-
-  const onSync = useCallback(
-    async (_opts: SyncOptions) => {
-      setBusy(true)
-      try {
-        await DeployApi.sync(app.name)
-        notify(`Sync requested for ${app.name}`)
-        onChanged()
-        load()
-      } catch (e) {
-        notify(`Sync failed: ${e instanceof Error ? e.message : e}`, true)
-      } finally {
-        setBusy(false)
-      }
-    },
-    [app.name, notify, onChanged, load],
-  )
-
-  const onRollback = useCallback(
-    async (revision: string) => {
-      setBusy(true)
-      try {
-        await DeployApi.rollback(app.name, revision)
-        notify(`Rolled back ${app.name} → ${revision}`)
-        onChanged()
-        load()
-      } catch (e) {
-        notify(`Rollback failed: ${e instanceof Error ? e.message : e}`, true)
-      } finally {
-        setBusy(false)
-      }
-    },
-    [app.name, notify, onChanged, load],
-  )
-
-  return (
-    <div style={{ display: "flex", flexDirection: "column", gap: 14 }}>
-      <div style={{ display: "flex", alignItems: "center", gap: 8, flexWrap: "wrap" }}>
-        <button type="button" className="cd-btn" onClick={onBack}>
-          ← Fleet
-        </button>
-        <span className="cd-muted">/</span>
-        <span className="cd-mono" style={{ color: "var(--cd-fg-strong)", fontWeight: 700 }}>
-          {app.name}
-        </span>
-        {app.env ? (
-          <span className="cd-mono cd-muted" style={{ fontSize: 12 }}>
-            · {app.env}
-          </span>
-        ) : null}
-      </div>
-
-      <GitopsSyncPanel
-        app={gitopsApp}
-        theme="dark"
-        busy={busy}
-        onSync={onSync}
-        onRefresh={load}
-        onRollback={() => setRollbackOpen(true)}
-      />
-
-      <div style={{ display: "flex", gap: 12, flexWrap: "wrap", alignItems: "flex-start" }}>
-        {tree === undefined ? (
-          <div className="cd-muted" style={{ padding: 24 }}>
-            Loading topology…
-          </div>
-        ) : tree === null ? (
-          <div className="cd-muted" style={{ padding: 24 }}>
-            Could not load the resource tree{treeErr ? `: ${treeErr}` : ""}.
-          </div>
-        ) : tree.nodes.length === 0 ? (
-          <div className="cd-muted" style={{ padding: 24 }}>
-            No owned resources reported.
-          </div>
-        ) : (
-          <>
-            <GitopsAppTree
-              tree={tree}
-              theme="dark"
-              onSelect={onSelect}
-              selectedId={selected?.uid ?? null}
-              height={400}
-              style={{ flex: 1, minWidth: 280 }}
-            />
-            {selected ? (
-              <GitopsNodeInfo
-                node={selected}
-                theme="dark"
-                resource={resource}
-                logs={logs}
-                onClose={() => onSelect(null)}
-                style={{ width: "min(440px, 100%)", height: 400, flexShrink: 0 }}
-              />
-            ) : null}
-          </>
-        )}
-      </div>
-
-      <GitopsRollbackDialog
-        open={rollbackOpen}
-        history={history}
-        theme="dark"
-        busy={busy}
-        onClose={() => setRollbackOpen(false)}
-        onRollback={(entry) => {
-          setRollbackOpen(false)
-          void onRollback(entry.revision)
-        }}
-      />
-    </div>
-  )
-}

apps/cd/src/views/FleetView.tsx

@@ -1,75 +0,0 @@
-/**
- * The fleet view — every operator App CR as a row, health + sync + revision +
- * source, with the shared @hanzo/cd `GitopsAppList` (search, health/sync
- * filters, sortable). A compact KPI band up top gives the at-a-glance fleet stats.
- * Data-prop-driven: the app fetches `/v1/deploy/applications` and hands the folded
- * rows in; nothing is fabricated.
- */
-import { useMemo } from "react"
-import { GitopsAppList } from "@hanzo/cd"
-
-import { toGitopsApp, type DeployApp } from "../lib/adapt"
-
-function Stat({ label, value, tone }: { label: string; value: number; tone?: string }) {
-  return (
-    <div
-      style={{
-        flex: 1,
-        minWidth: 104,
-        border: "1px solid var(--cd-border-strong)",
-        borderRadius: 10,
-        padding: "12px 14px",
-        background: "var(--cd-surface)",
-      }}
-    >
-      <div style={{ fontSize: 26, fontWeight: 800, color: tone && value > 0 ? tone : "var(--cd-fg-strong)" }}>{value}</div>
-      <div className="cd-muted" style={{ fontSize: 13, marginTop: 2 }}>
-        {label}
-      </div>
-    </div>
-  )
-}
-
-export function FleetView({ apps, onOpen }: { apps: DeployApp[]; onOpen: (name: string) => void }) {
-  const gitopsApps = useMemo(() => apps.map(toGitopsApp), [apps])
-
-  const kpi = useMemo(() => {
-    const s = { total: 0, healthy: 0, progressing: 0, degraded: 0, outOfSync: 0 }
-    for (const a of gitopsApps) {
-      s.total++
-      if (a.health === "Healthy") s.healthy++
-      else if (a.health === "Progressing") s.progressing++
-      else if (a.health === "Degraded" || a.health === "Missing") s.degraded++
-      if (a.sync === "OutOfSync") s.outOfSync++
-    }
-    return s
-  }, [gitopsApps])
-
-  return (
-    <div style={{ display: "flex", flexDirection: "column", gap: 16 }}>
-      <div>
-        <h1 style={{ fontSize: 22, fontWeight: 800, margin: "0 0 4px", letterSpacing: "-0.02em" }}>Fleet</h1>
-        <p className="cd-muted" style={{ margin: 0, fontSize: 14, maxWidth: "60ch" }}>
-          Every Hanzo App reconciled by the operator — declarative, versioned, auto-synced from git to your clusters. Open
-          one for its resource tree, logs, and sync/rollback.
-        </p>
-      </div>
-
-      <div style={{ display: "flex", gap: 10, flexWrap: "wrap" }}>
-        <Stat label="Applications" value={kpi.total} />
-        <Stat label="Healthy" value={kpi.healthy} tone="#18BE94" />
-        <Stat label="Progressing" value={kpi.progressing} tone="#0DADEA" />
-        <Stat label="Degraded" value={kpi.degraded} tone="#E96D76" />
-        <Stat label="Out of sync" value={kpi.outOfSync} tone="#f4c030" />
-      </div>
-
-      <GitopsAppList
-        applications={gitopsApps}
-        theme="dark"
-        view="table"
-        onOpen={(a) => onOpen(a.name)}
-        emptyLabel="No applications reported by the deploy plane yet."
-      />
-    </div>
-  )
-}

apps/cd/src/vite-env.d.ts

@@ -1 +0,0 @@
-/// <reference types="vite/client" />

apps/cd/tsconfig.app.json

@@ -1,24 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "useDefineForClassFields": true,
-    "lib": ["ES2022", "DOM", "DOM.Iterable"],
-    "module": "ESNext",
-    "skipLibCheck": true,
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "moduleDetection": "force",
-    "noEmit": true,
-    "jsx": "react-jsx",
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true,
-    "paths": {
-      "@hanzo/cd": ["../../pkgs/gitops/dist/index.d.ts"],
-      "@hanzo/canvas/pure": ["../../pkgs/canvas/src/pure.ts"]
-    }
-  },
-  "include": ["src"]
-}

apps/cd/tsconfig.json

@@ -1,4 +0,0 @@
-{
-  "files": [],
-  "references": [{ "path": "./tsconfig.app.json" }, { "path": "./tsconfig.node.json" }]
-}

apps/cd/tsconfig.node.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2023",
-    "lib": ["ES2023"],
-    "module": "ESNext",
-    "skipLibCheck": true,
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "noEmit": true,
-    "strict": true
-  },
-  "include": ["vite.config.ts"]
-}

apps/cd/vite.config.ts

@@ -1,40 +0,0 @@
-import { fileURLToPath, URL } from "node:url"
-
-import react from "@vitejs/plugin-react"
-import { defineConfig } from "vitest/config"
-
-/**
- * Hanzo CD — a static SPA served at cd.hanzo.ai from the shared static plane
- * (s3://cdn/cd, ingress staticFiles/spaMode). `/v1/deploy/*` is peeled off to the
- * cloud binary by the ingress, so in prod the SPA calls same-origin `/v1/deploy`
- * with the `hanzo_iam_token` cookie (cloud validates → SuperAdmin gate).
- *
- * The @hanzo/cd (built dist) + @hanzo/canvas/pure (pure TS source) workspace
- * packages are resolved by path alias so the app builds without a full monorepo
- * install (the shared store lacks the registry deps of the heavier packages). A
- * dev proxy forwards `/v1` to CD_API (default the live cluster) for local dev.
- */
-const r = (p: string) => fileURLToPath(new URL(p, import.meta.url))
-const CD_API = process.env.CD_API ?? "https://cd.hanzo.ai"
-
-export default defineConfig({
-  plugins: [react()],
-  resolve: {
-    dedupe: ["react", "react-dom"],
-    alias: {
-      "@hanzo/cd": r("../../pkgs/cd/dist/index.mjs"),
-      "@hanzo/canvas/pure": r("../../pkgs/canvas/src/pure.ts"),
-    },
-  },
-  // Plain CSS only — override the monorepo-root PostCSS/Tailwind config discovery
-  // (this app has no Tailwind; the @hanzo/cd components ship their own scoped CSS).
-  css: { postcss: { plugins: [] } },
-  build: { outDir: "dist", target: "es2022", sourcemap: false },
-  server: {
-    port: 4200,
-    proxy: { "/v1": { target: CD_API, changeOrigin: true, secure: false } },
-  },
-  // The e2e/ specs are Playwright's (they use test.beforeAll); vitest must not
-  // glob them, or a bare `vitest run` reports a red suite for a passing app.
-  test: { exclude: ["e2e/**", "node_modules/**", "dist/**"] },
-})

apps/v4/eslint.config.mjs

@@ -23,32 +23,8 @@ const eslintConfig = tseslint.config(
   },
   {
     rules: {
-      // React Compiler advisory rules, OFF for this app only.
-      //
-      // apps/v4 is a VENDORED upstream mirror — every file these rules flag
-      // arrives from a sync commit ("feat: sync upstream shadcn/ui"), including
-      // hooks/use-layout.tsx, components/command-menu.tsx and the whole
-      // examples/{base,radix} registry, whose copies are byte-identical to each
-      // other. eslint-config-next 16 turns the compiler rules on; upstream
-      // shadcn does not satisfy them, so linting their code under our config
-      // produced 48 errors in code we do not write.
-      //
-      // Patching them would fork every one of those files from upstream and
-      // have to be redone at the next sync — to quiet advisories in a demo app.
-      // The first two were already off for exactly this reason; the two added
-      // below are the rest of the same family:
-      //   set-state-in-effect  "Calling setState synchronously within an effect
-      //                         can trigger cascading renders"        (42 of 48)
-      //   refs                 "Cannot access refs during render"      (6 of 48)
-      //
-      // This file governs apps/v4 ONLY. Our own source — app/, pkgs/, packages/
-      // — lints under its own config and is untouched, so nothing we actually
-      // author is exempted here. If these should hold for vendored code too,
-      // the fix belongs upstream in shadcn/ui, not as a local fork.
       "react-hooks/incompatible-library": "off",
       "react-hooks/purity": "off",
-      "react-hooks/set-state-in-effect": "off",
-      "react-hooks/refs": "off",
       "@next/next/no-html-link-for-pages": "off",
       "@next/next/no-img-element": "off",
       "@typescript-eslint/no-unused-vars": "off",

apps/v4/registry/bases/base/blocks/elevenlabs.tsx

@@ -199,6 +199,7 @@ export function useAudioVolume(
 
   useEffect(() => {
     if (!mediaStream) {
+      // eslint-disable-next-line react-hooks/set-state-in-effect
       setVolume(0)
       volumeRef.current = 0
       return

apps/v4/registry/bases/radix/blocks/elevenlabs.tsx

@@ -199,6 +199,7 @@ export function useAudioVolume(
 
   useEffect(() => {
     if (!mediaStream) {
+      // eslint-disable-next-line react-hooks/set-state-in-effect
       setVolume(0)
       volumeRef.current = 0
       return

apps/v4/tsconfig.json

@@ -18,6 +18,7 @@
         "name": "next"
       }
     ],
+    "baseUrl": ".",
     "paths": {
       "@/*": ["./*"],
       "react": ["./node_modules/@types/react"]

apps/v4/tsconfig.scripts.json

@@ -4,7 +4,7 @@
   "compilerOptions": {
     "target": "ES2017",
     "module": "ESNext",
-    "moduleResolution": "bundler",
+    "moduleResolution": "node",
     "esModuleInterop": true,
     "isolatedModules": false,
     "allowImportingTsExtensions": true

hanzo.yml

@@ -1,122 +0,0 @@
-
-# This repo is BOTH a library and a container. `pkg/ui` publishes to npm from
-# .hanzo/workflows/publish.yml on a version change — still the only thing allowed
-# to reach npmjs. `app/` is ui.hanzo.ai: a Next static export served by
-# hanzoai/static as ghcr.io/hanzoai/ui, pinned live in hanzoai/universe.
-#
-# The `images:` block below is what makes the second half true here. This file
-# carried a `test:` block and nothing else, and said "a library, not a container"
-# — accurate about pkg/ui and wrong about the site, which has been live on
-# ghcr.io/hanzoai/ui since before any workflow could build it.
-#
-# The gate is pkg/ui — the package this repo actually publishes — and it is
-# the same three commands publish.yml already proves on this runner, moved
-# EARLIER. That ordering is the whole point: publish.yml is the LAST place a
-# defect costs nothing, because the version it ships is immutable. Here it
-# costs a re-push.
-#
-# The trailing `...` on the build filter is load-bearing: it builds @hanzo/ui's
-# WORKSPACE DEPENDENCIES first, in topological order. Without it the siblings
-# have no dist/, tsc reads them through their own `"types": "dist/index.d.ts"`,
-# and they come back as missing modules — `Cannot find module '@hanzo/tokens'`,
-# `'@hanzo/products'`, `'@hanzo/cd'` — plus a wave of implicit-any in every file
-# that imported them. Those errors name @hanzo/ui and are not its fault.
-#
-# `pnpm install` without --frozen-lockfile is deliberate and is the literal
-# command measured green here: pnpm already defaults frozen-lockfile to true
-# under CI, so the flag adds nothing but a second way to spell the same thing.
-#
-# WHAT THIS DOES NOT GATE, and why the ci.yml it replaces was red on every run
-# for months. That workflow had four jobs and three of them could not pass:
-#
-#   Build   `cd pkgs/ui && pnpm run build:full`
-#   Test    `cd pkgs/ui && pnpm test:coverage`
-#           → both: `cd: pkgs/ui: No such file or directory`. The package moved
-#             to pkg/ (singular) — the same split publish.yml documents at
-#             length — and these two steps were never followed across.
-#   Type    `cd app && pnpm run typecheck`
-#           → ~10x `error TS7016: Could not find a declaration file for module
-#             '@hanzo/ui/animation/*'`. app/ is the shadcn registry this repo
-#             grew from, and its package.json aliases
-#             `"@hanzo/ui": "npm:@hanzo/ui-shadcn@^5"`, so those imports resolve
-#             to a PUBLISHED package that ships no declarations. Nothing in this
-#             tree can fix it, and the app is stale anyway.
-#
-# A gate that cannot go green teaches nobody anything — it is read once, filed
-# as "CI is just red here", and from then on it hides real breakage. Gating
-# pkg/ui is not a smaller gate than that one. It is the first real one.
-
-# ui.hanzo.ai. The recipe is the root Dockerfile and lives nowhere else; this
-# block only declares WHAT is built and what it needs to be valid.
-#
-# THE BUILD SECRET IS WHY THIS BLOCK EXISTS. hanzoai/ci (which
-# .hanzo/workflows/cicd.yml already imports) is the ONLY lane that implements
-# `build_secrets`: it reads each name from KMS `deploy/<NAME>?env=prod` and passes
-# it as `--build-arg NAME=value`, refusing the run when the value is empty. The
-# hand-rolled image job in .hanzo/workflows/deploy.yml ran a bare `docker build`
-# with no build-arg and no KMS hop, so no lane in this repo could put a key in the
-# bundle. The one key that ever reached production got there on somebody's laptop,
-# and it has since gone dead — api.hanzo.ai 401s it — which is what a credential
-# with no automated source always does eventually. That job is now
-# workflow_dispatch-only; this is the lane.
-#
-# The KMS name IS the build-arg name IS the Dockerfile ARG. One name, one place.
-# Supply it or the Dockerfile's gate refuses the build — the two halves either
-# both hold or both fail loudly.
-#
-# No `version:` — imgver derives it, and deriving is correct here. The root
-# package.json is a 0.0.1 workspace stub and pkg/ui's 8.0.58 is the NPM package's
-# number, not the site's; neither describes the image. imgver takes
-# max(declared, published)+1 patch, so the series continues from what is already
-# in the registry (5.7.6 live) instead of restarting or colliding with npm.
-images:
-  - name: ui
-    context: .
-    dockerfile: Dockerfile
-    repo: ghcr.io/hanzoai/ui
-    platforms: [linux/amd64]
-    build_secrets: [PUBLISHABLE_KEY]
-
-# No `deploy:` — ON PURPOSE. hanzoai/universe names what is live, in
-# charts/app/values/hanzo/ui.yaml, and the in-cluster reconcile restores it — so a
-# CI-side patch does not stick. It would also LOOK like it worked: the patch
-# applies, the pod rolls, and the declared tag comes back a minute later. A build
-# emits an image; git declares desired state; CD applies it.
-#
-# That file pins `tag:` AND `digest:` together, and the digest is what is actually
-# pulled: moving the tag alone changes nothing. Read the tag off the build you
-# fired — this lane publishes `sha-<sha7>-amd64`, `latest` and the imgver semver,
-# none of which is the `v5.7.6` shape pinned there today.
-
-# Two jobs, not one, and the split is not cosmetic. `pnpm run test` is now
-# vitest + the Vite consumer + the WEBPACK consumer, and the two consumer
-# suites need a browser and a real npm install that unit tests do not. Running
-# them as one step means a playwright download sits in front of every unit
-# failure.
-#
-# The `...` on the build filter stays and is load-bearing: it builds @hanzo/ui's
-# WORKSPACE DEPENDENCIES first, in topological order. @hanzo/cd is still one of
-# them. Without it the sibling has no dist/, tsc reads it through its own
-# `"types": "dist/index.d.ts"`, and it comes back as a missing module — an error
-# that names @hanzo/ui and is not its fault.
-test:
-  - name: ui-unit
-    run: |
-      set -e
-      corepack enable
-      pnpm install
-      pnpm --filter @hanzo/ui... build
-      pnpm --filter @hanzo/ui run test:unit
-  - name: ui-consumer
-    run: |
-      set -e
-      corepack enable
-      pnpm install
-      pnpm --filter @hanzo/ui... build
-      cd pkg/ui
-      pnpm exec playwright install --with-deps chromium
-      # Both bundlers. They disagree about css url() asset resolution, and a
-      # Vite-only gate is how 8.0.46 shipped a stylesheet pointing at a font
-      # file the package does not pack.
-      pnpm run test:consumer
-      pnpm run test:consumer:webpack

package.json

@@ -11,7 +11,6 @@
   "workspaces": [
     "app",
     "apps/*",
-    "pkg/*",
     "pkgs/*"
   ],
   "scripts": {
@@ -52,6 +51,7 @@
     "format:check": "turbo run format:check",
     "sync:templates": "./scripts/sync-templates.sh \"templates/*\"",
     "check": "bash scripts/check-no-brand-pkg.sh && turbo lint typecheck format:check",
+    "release": "changeset version",
     "pub:beta": "cd pkgs/hanzo && pnpm pub:beta",
     "pub:release": "cd pkgs/hanzo && pnpm pub:release",
     "test:dev": "turbo run test --filter=!hanzo-ui --force",
@@ -71,6 +71,8 @@
   "packageManager": "pnpm@9.0.6",
   "dependencies": {
     "@babel/core": "^7.29.7",
+    "@changesets/changelog-github": "^0.7.0",
+    "@changesets/cli": "^2.31.0",
     "@commitlint/cli": "^21.0.2",
     "@commitlint/config-conventional": "^21.0.2",
     "@dnd-kit/core": "^6.3.1",
@@ -126,7 +128,7 @@
     "tailwindcss": "4.3.0",
     "tsup": "^8.5.1",
     "turbo": "^2.9.16",
-    "typescript": "^5.9.3",
+    "typescript": "^6.0.3",
     "vite": "^8.0.16",
     "vitest": "^4.1.8",
     "vitest-axe": "^0.1.0"

pkg/data/README.md

@@ -66,4 +66,4 @@ import { applyView, sortRecords, filterRecords, boardColumns } from '@hanzo/data
 - **Logic** — `applyView`, `sortRecords`, `filterRecords`, `searchRecords`, `paginate`, `boardColumns`, `movePatch`, `operatorsForType`, `emptyView`, `describeView`, …
 - **Theme** — `tokens`, `TAG_TONES`, `tagTone`
 
-MIT · Hanzo AI — see [LICENSE.md](../../LICENSE.md). HIP-0137 (`hanzoai/hips`).
+BSD-3-Clause · Hanzo AI

pkg/data/package.json

@@ -1,50 +1,41 @@
 {
   "name": "@hanzo/data",
-  "version": "1.2.3",
+  "version": "1.2.1",
   "type": "module",
   "description": "Hanzo Data — cross-platform, metadata-driven data-app components (typed fields, record table, kanban board, record detail, saved views) on @hanzo/gui. The universal object/field/record/view layer that powers any Base-backed CRM, CMS, or commerce app on web, native (iOS), and desktop. Airtable/Twenty-class polish, clean-room.",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "default": "./dist/index.js"
+      "types": "./types/index.d.ts",
+      "default": "./src/index.ts"
     },
     "./table/logic": {
-      "types": "./dist/table/logic.d.ts",
-      "import": "./dist/table/logic.js",
-      "require": "./dist/table/logic.cjs",
-      "default": "./dist/table/logic.js"
+      "types": "./types/table/logic.d.ts",
+      "default": "./src/table/logic.ts"
     },
     "./board/logic": {
-      "types": "./dist/board/logic.d.ts",
-      "import": "./dist/board/logic.js",
-      "require": "./dist/board/logic.cjs",
-      "default": "./dist/board/logic.js"
+      "types": "./types/board/logic.d.ts",
+      "default": "./src/board/logic.ts"
     },
     "./view/logic": {
-      "types": "./dist/view/logic.d.ts",
-      "import": "./dist/view/logic.js",
-      "require": "./dist/view/logic.cjs",
-      "default": "./dist/view/logic.js"
+      "types": "./types/view/logic.d.ts",
+      "default": "./src/view/logic.ts"
     },
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "types": "./types/index.d.ts",
   "sideEffects": [
-    "**/registerDefaults.js",
-    "**/registerDefaults.cjs",
-    "**/index.js",
-    "**/index.cjs"
+    "**/registerDefaults.ts",
+    "**/index.ts"
   ],
   "files": [
-    "dist"
+    "src",
+    "types"
   ],
   "scripts": {
-    "build": "rm -rf dist dist-cjs types && tsc -p tsconfig.build.json && tsc -p tsconfig.cjs.json --noCheck && node ../ui/scripts/postbuild.mjs . theme,table/logic,board/logic,view/logic,view/types,field/types,field/registry",
-    "clean": "rm -rf dist dist-cjs types",
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "rm -rf types",
     "prepack": "pnpm run build",
     "tc": "tsc --noEmit",
     "typecheck": "tsc --noEmit",
@@ -69,6 +60,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "license": "MIT",
+  "license": "BSD-3-Clause",
   "author": "Hanzo AI <dev@hanzo.ai>"
 }

pkg/data/tsconfig.build.json

@@ -4,10 +4,10 @@
     "noEmit": false,
     "declaration": true,
     "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "./dist",
+    "emitDeclarationOnly": true,
+    "outDir": "./types",
     "rootDir": "./src"
   },
   "include": ["src"],
-  "exclude": ["node_modules", "dist", "dist-cjs", "types", "**/*.test.ts", "**/*.test.tsx"]
+  "exclude": ["node_modules", "types", "**/*.test.ts", "**/*.test.tsx"]
 }

pkg/data/tsconfig.cjs.json

@@ -1,15 +0,0 @@
-{
-  "extends": "./tsconfig.build.json",
-  "compilerOptions": {
-    // `moduleResolution` is stated here rather than inherited, for the same
-    // reason it is stated in @hanzo/ui's copy: under TypeScript 5 a `bundler`
-    // resolution inherited into a `commonjs` module target is a hard TS5095
-    // error and the build emits nothing at all.
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "outDir": "./dist-cjs",
-    "declaration": false,
-    "declarationMap": false,
-    "sourceMap": false
-  }
-}

pkg/ui/.gitignore

@@ -4,5 +4,3 @@ types/
 # Standalone install (this package is not in the root pnpm workspace).
 node_modules/
 pnpm-lock.yaml
-# Transient CJS emit — folded into dist/ as .cjs by scripts/postbuild.mjs.
-dist-cjs/

pkg/ui/README.md

@@ -2,7 +2,7 @@
 
 The **one** Hanzo component library, built on [`@hanzo/gui`](https://github.com/hanzoai/gui) (Tamagui) so every component runs on **web, native (iOS), and desktop**. It unifies what used to be three fragmented homes — `@hanzo/data`, the console's in-app `components/ui/*`, and ad-hoc duplicates — into one canonical, presentational, host-agnostic, clean-room library.
 
-> **v8+** is one substrate: every component renders through `@hanzo/gui`, so one import works on web, native and desktop. The v5.x Radix + Tailwind line is a different architecture and is retired — see `CONSOLIDATION.md` at the repo root.
+> This is the gui-based line (**v8+**). The legacy shadcn/Radix `@hanzo/ui` (v5.x) is a different architecture; it is being retired to `@hanzo/ui-shadcn` so the `@hanzo/ui` name carries the unified gui-based library forward — see `CONSOLIDATION.md` at the repo root.
 
 ## Install
 
@@ -26,11 +26,7 @@ import { RecordsView, DataTable, BoardView, RecordDetail, registerField } from '
   - **Charts** (dependency-free inline SVG): `Sparkline`, `LineChart`, `BarChart`, `Donut`, `BarRows` — hover tooltips, axis ticks, honest `null` under two real points.
   - **Metric** tiles/panels: `MetricCard`, `MiniBars`, `UtilBar`, `LegendDot`, `Panel`, `HintButton` (+ `MetricSparkline`).
   - **Chrome**: `PageHeader`, `StatusTag`, `EmptyState` (DO/Vercel-class first-run), `PrimaryButton`, `HanzoMark`, `ProductIcon`, `ProviderLogo`.
-  - **The identity trio** — one row of chrome, three switchers: `OrgSwitcher` (which workspace, `direction` up or down, `footer` for a surface's own rows), the app switcher inside `AppHeader`, and `UserMenu` (who I am). `AppHeader` composes all three; each is importable alone, so a surface that wants an account menu without the whole header does not write a sixth one.
-  - **Settings**: `Fieldset` — the titled, optionally destructive group the `Field*` rows sit in. Not `Panel`: that is a dashboard metric tile.
-  - **Interaction**: `ComboBox` (typeable, ReDoS-safe filter), `SelectMenu`, `SlideOver` (a11y drawer), `Toast` (`useToast`), `Reorder` (pointer DnD), `Field*` rows, `CopyButton`, `SecretInput` (mask · reveal · copy), `Pagination` (+ the pure `pages` rule), `FadeIn`, `ThemeToggle`, generic `DataTable<T>`.
-
-> **Masking needs both spellings.** `secureTextEntry` is React Native's and gui **drops it on web**, so an input carrying only that prop renders the secret in plain text; `type="password"` is the web one and native ignores it. `masked(on)` sets both and is what `SecretInput` and `<FieldText secure>` use. Never pass `secureTextEntry` alone.
+  - **Interaction**: `ComboBox` (typeable, ReDoS-safe filter), `SelectMenu`, `SlideOver` (a11y drawer), `Toast` (`useToast`), `Reorder` (pointer DnD), `Field*` rows, `FadeIn`, `ThemeToggle`, generic `DataTable<T>`.
   - **Tokens**: `tokens`, `TAG_TONES`, `tagTone` — the calm, dark-first, zinc-on-black identity.
 - **`@hanzo/ui/data`** — the metadata-driven record layer (source of truth: `@hanzo/data`): `RecordsView` (table ⇆ board, filter/sort/search/group, inline edit, saved views), the record-grid `DataTable`, `BoardView`, `RecordDetail`/`RecordForm`, every typed field editor, the field registry, and the pure view/sort/filter logic.
 
@@ -38,65 +34,6 @@ Both layers are **presentational + data-injected**: the host supplies rows and p
 
 > Each layer owns a `DataTable` — the product one is a generic typed `<T>` list; the data one is the field-driven record grid. Keeping the record layer on the `./data` subpath keeps each name unambiguous.
 
-## The DocType renderer — one UI for every business app
-
-`@hanzo/ui/framework` renders the **Hanzo Framework** DocType engine (`hanzoai/cloud
-clients/framework`, live at `/v1/framework/*`; also published as
-[`hanzoai/framework`](https://github.com/hanzoai/framework) over
-[`hanzoai/doctype`](https://github.com/hanzoai/doctype)). The engine is
-metadata-driven: a CMS Page, an ERP Sales Order, a Helpdesk Ticket and a CRM
-Company are the same kind of thing — a DocType with typed fields. So they get the
-same renderer. An **app lane is a `module` filter** over the DocType registry plus
-its own copy; there is no per-lane list, form, detail or builder to drift.
-
-```tsx
-import { createFrameworkClient } from '@hanzo/ui/framework/core'      // transport only
-import { CollectionsBrowser, DocTypeRecords, DocTypeDetail } from '@hanzo/ui/framework'
-
-// The HOST owns transport: paths are relative to the framework root, so the app
-// decides the origin + the credential. Nothing in the library picks a URL.
-const client = createFrameworkClient({
-  get: (p) => api.get(`/v1/framework/${p}`),
-  post: (p, b) => api.post(`/v1/framework/${p}`, b),
-  put: (p, b) => api.put(`/v1/framework/${p}`, b),
-  del: (p) => api.del(`/v1/framework/${p}`),
-})
-
-<CollectionsBrowser client={client} module="erp" label="ERP" … onOpen={openCollection} />
-<DocTypeRecords client={client} doctype="erp-sales" onOpen={…} onCreate={…} />
-<DocTypeDetail  client={client} doctype="erp-sales" name={name} onBack={…} onView={…} />
-```
-
-**Mobile first — a rule, not a fallback.** The layout is decided from the
-CONTAINER's measured width (`onLayout`, so a narrow pane on a wide screen is still
-a phone), and the answer to "not measured yet" is PHONE. So the first paint —
-SSR included — is a stacked **card** per record; the `@hanzo/data` table is the
-enhancement applied once the box proves it can hold one. Every control meets the
-44px tap floor (WCAG 2.5.5) at phone width, and the table honors the DocType's own
-`inListView` projection so a twelve-field document does not become a horizontal
-scroll wall.
-
-**Two entries, because they are two different things.** `./framework/core` is the
-contract — wire types, the client, the metadata↔render mapping, the builder
-projection, the media model. It imports no React and no `@hanzo/gui`, so a data
-layer, a server route or a plain node test can bind the engine without loading a
-component tree. `./framework` re-exports all of it plus the views.
-
-**Ports, not bindings.** The client takes a `FrameworkTransport`; the DAM takes a
-`MediaStore` (ensure-bucket / presign / put / delete) and a **bucket parameter**,
-so ERP attachments never land in a bucket named after the CMS. Routing is
-`onOpen`/`onCreate`/`onBack`/`onView` callbacks — no router import anywhere.
-
-**One entry, not two.** 8.0.24 shipped a first `./framework` lift with the same
-`createFrameworkClient(Transport)` shape but no builder, no DAM and no mobile
-layout, injecting `renderBuilder`/`renderMedia` instead. 8.0.25 is the convergence:
-the same entry, a superset implementation, and every 8.0.24 name still resolves —
-`Transport` aliases `FrameworkTransport`, `Loader` aliases the in-flow `Loading`,
-`setupDescription`/`setupBullets` stay optional (they now fall back to copy DERIVED
-FROM THE LANE, which is the actual fix — the old default was one lane's words), and
-`renderBuilder`/`renderMedia` still win when supplied. A host that passes neither
-now gets the real built-in `CollectionBuilder`/`MediaGrid` instead of nothing.
-
 ## Motion
 
 The calm motion vocabulary (`FadeIn`, drawer/backdrop transitions, skeleton shimmer, live pulse) ships as one stylesheet. Import it once at the app root:
@@ -114,98 +51,6 @@ import { registerField } from '@hanzo/ui/data'
 registerField('rating', { Display: MyStars, Input: MyStarPicker })
 ```
 
-## Analytics — one flag, and the components report themselves
-
-```tsx
-import { Hanzo } from '@hanzo/ui'
-
-<Hanzo analytics={{ product: 'console', ingestKey: process.env.NEXT_PUBLIC_PUBLISHABLE_KEY }}>
-  <App />
-</Hanzo>
-```
-
-That is the entire wiring. Every click, form change, submit and route change
-inside the tree arrives on the ONE front door (`POST /v1/event`) annotated with
-the component it happened on — no `onClick` handler anywhere reports anything,
-and no call site changes:
-
-```jsonc
-{
-  "event": "$click",
-  "$el": "card/button[Save]",      // the significant-node trail, root→leaf
-  "$role": "button",
-  "$component": "button",          // from the data-slot every primitive carries
-  "$name": "Save"
-}
-```
-
-Component names are real **in production**. Every primitive here stamps a
-`data-slot` through one helper (`slot()`), and the capture engine reads it — so
-attribution does not depend on React fiber owners, which a production build
-minifies away. A component that wants a better name than its slot says so once,
-on itself: `data-hz-name="SaveButton"` outranks everything.
-
-### What it is made of — one of each
-
-| Concern | Package | There is exactly one |
-|---|---|---|
-| Client + wire | [`@hanzo/event`](../../pkgs/event) | endpoint `POST /v1/event`, batched, beacon-on-unload |
-| Capture engine | [`@hanzo/observe`](../../pkgs/observe) | delegated listeners, semantic annotation, redaction |
-| Provider + consent | `@hanzogui/telemetry` | `<TelemetryProvider/>`, which `analytics` renders |
-
-`analytics` is a **prop, not a default**. Mounting a component library must
-never start a network conversation the app did not ask for: without it `<Hanzo>`
-renders no provider, installs no listener and sends nothing.
-
-### It cannot double-count
-
-An app that already mounts `<TelemetryProvider/>` itself leaves `analytics`
-off — but if both are mounted, the events still do not double. The capture
-engine installs *delegated* listeners on a root, so two engines on one root
-would report every interaction twice; a page-wide claim (`Symbol.for`, so
-duplicate copies of the package in one bundle still see each other) gives the
-root to the first engine and leaves any later one inert. Both providers also
-resolve the same client, so there is one session and one stream either way.
-
-### Privacy
-
-Consent decides whether any of it runs: Global Privacy Control, Do Not Track,
-and a stored choice a consent banner records — which outranks the browser signal
-in **both** directions, because that is what explicit means. Beyond that:
-
-- **Input values are withheld.** `$input`/`$change` carry the field's kind and
-  value length, never the typed text.
-- **Sensitive fields are never captured at all** — password, email, card, cvv,
-  token, ssn — not even a length.
-- **`data-hz-private`** on any element excludes its whole subtree.
-
-### One ingest key
-
-`ingestKey` is a publishable `pk-…` — write-only, safe in a bundle, minted per
-org with `POST /v1/keys {"type":"publishable"}`. Omit it and the client reads
-`NEXT_PUBLIC_PUBLISHABLE_KEY` from the build env, which is the spelling the
-fleet already carries end to end (KMS holds `deploy/PUBLISHABLE_KEY`; the
-Dockerfile takes it as a build-arg and re-exports it with the `NEXT_PUBLIC_`
-prefix Next needs to inline it). A surface with no key reports only for whoever
-is signed in and silently drops every logged-out visitor — the door refuses an
-unattributable write rather than filing it where its owner cannot read it.
-
-For a page with no build step at all, the same client ships as a script tag:
-`@hanzo/event/hz.js`, with `data-ingest-key="pk-…"`.
-
-### Naming a moment the components cannot see
-
-Autocapture reports what was clicked; it cannot know that a click *was* a
-checkout. Curated events live on `@hanzo/ui/product`, one closed verb set over
-one event name, on the same client and the same stream:
-
-```tsx
-import { useEmit, InstrumentSurface } from '@hanzo/ui/product'
-
-const emit = useEmit()
-emit({ component: 'PlanCard', action: 'select', id: 'pro' })
-```
-
 ## Design principles
 
 - **One home, no duplication** — components are extracted, never copied. The record layer's source of truth stays in `@hanzo/data`; `@hanzo/ui` composes it.
@@ -213,4 +58,4 @@ emit({ component: 'PlanCard', action: 'select', id: 'pro' })
 - **Clean-room** — original implementation, no GPL / Twenty code. Airtable/Twenty-*class* polish, our own code.
 - **Cross-platform** — web + native + desktop, because it's only `@hanzo/gui`.
 
-MIT · Hanzo AI — see [LICENSE.md](../../LICENSE.md). HIP-0137 (`hanzoai/hips`).
+BSD-3-Clause · Hanzo AI

pkg/ui/package.json

@@ -1,278 +1,72 @@
 {
   "name": "@hanzo/ui",
-  "version": "8.0.64",
+  "version": "8.0.12",
   "type": "module",
-  "description": "Hanzo UI \u2014 the one canonical Hanzo component library, on @hanzo/gui + @hanzo/design. ONE substrate: every component renders through @hanzo/gui primitives, so the same import works on web, native (expo) and desktop (Tauri). Self-contained (theme.css), presentational, host-agnostic, clean-room.",
+  "description": "Hanzo UI — the one cross-platform component library on @hanzo/gui. The product/app layer (charts, metrics, page headers, status tags, rich empty states, combobox, slide-over, toasts, drag-reorder, labeled field rows, provider/product marks) + the metadata-driven record layer (@hanzo/data: RecordsView, DataTable, board, typed field editors) + the calm dark-first tokens and motion. Presentational, host-agnostic (data/effects injected), clean-room. Web + native (iOS) + desktop.",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "default": "./dist/index.js"
-    },
-    "./gallery": {
-      "types": "./dist/gallery.d.ts",
-      "import": "./dist/gallery.js",
-      "require": "./dist/gallery.cjs",
-      "default": "./dist/gallery.js"
-    },
-    "./styles.css": "./dist/styles.css",
-    "./models": {
-      "types": "./dist/models/index.d.ts",
-      "import": "./dist/models/index.js",
-      "require": "./dist/models/index.cjs",
-      "default": "./dist/models/index.js"
-    },
-    "./chat": {
-      "types": "./dist/chat/index.d.ts",
-      "import": "./dist/chat/index.js",
-      "require": "./dist/chat/index.cjs",
-      "default": "./dist/chat/index.js"
-    },
-    "./core": {
-      "types": "./dist/core/index.d.ts",
-      "import": "./dist/core/index.js"
-    },
-    "./tokens": {
-      "types": "./dist/core/tokens.d.ts",
-      "import": "./dist/core/tokens.js"
-    },
-    "./css": {
-      "types": "./dist/core/css.d.ts",
-      "import": "./dist/core/css.js",
-      "require": "./dist/core/css.cjs",
-      "default": "./dist/core/css.js"
-    },
-    "./theme.css": "./dist/theme.css",
-    "./glass.css": "./dist/glass.css",
-    "./glass": {
-      "types": "./dist/glass.d.ts",
-      "import": "./dist/glass.js",
-      "require": "./dist/glass.cjs",
-      "default": "./dist/glass.js"
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
     },
     "./product": {
-      "types": "./dist/product/index.d.ts",
-      "import": "./dist/product/index.js",
-      "require": "./dist/product/index.cjs",
-      "default": "./dist/product/index.js"
-    },
-    "./gui-config": {
-      "types": "./dist/gui-config.d.ts",
-      "import": "./dist/gui-config.js",
-      "require": "./dist/gui-config.cjs",
-      "default": "./dist/gui-config.js"
-    },
-    "./product/pure": {
-      "types": "./dist/product/pure.d.ts",
-      "import": "./dist/product/pure.js",
-      "require": "./dist/product/pure.cjs",
-      "default": "./dist/product/pure.js"
-    },
-    "./product/theme-toggle-next": {
-      "types": "./dist/product/ThemeToggleNext.d.ts",
-      "import": "./dist/product/ThemeToggleNext.js",
-      "require": "./dist/product/ThemeToggleNext.cjs",
-      "default": "./dist/product/ThemeToggleNext.js"
-    },
-    "./product/social": {
-      "types": "./dist/product/social/index.d.ts",
-      "import": "./dist/product/social/index.js",
-      "require": "./dist/product/social/index.cjs",
-      "default": "./dist/product/social/index.js"
-    },
-    "./product/social/api": {
-      "types": "./dist/product/social/api.d.ts",
-      "import": "./dist/product/social/api.js",
-      "require": "./dist/product/social/api.cjs",
-      "default": "./dist/product/social/api.js"
-    },
-    "./product/*": {
-      "types": "./dist/product/*.d.ts",
-      "import": "./dist/product/*.js",
-      "require": "./dist/product/*.cjs",
-      "default": "./dist/product/*.js"
+      "types": "./src/product/index.ts",
+      "default": "./src/product/index.ts"
     },
     "./data": {
-      "types": "./dist/data.d.ts",
-      "import": "./dist/data.js",
-      "require": "./dist/data.cjs",
-      "default": "./dist/data.js"
-    },
-    "./framework": {
-      "types": "./dist/framework/index.d.ts",
-      "import": "./dist/framework/index.js",
-      "require": "./dist/framework/index.cjs",
-      "default": "./dist/framework/index.js"
-    },
-    "./framework/core": {
-      "types": "./dist/framework/core.d.ts",
-      "import": "./dist/framework/core.js",
-      "require": "./dist/framework/core.cjs",
-      "default": "./dist/framework/core.js"
-    },
-    "./dropdown-menu": {
-      "types": "./dist/backends/gui/dropdown-menu.d.ts",
-      "import": "./dist/backends/gui/dropdown-menu.js",
-      "require": "./dist/backends/gui/dropdown-menu.cjs"
-    },
-    "./primitives": {
-      "types": "./dist/primitives/index.d.ts",
-      "import": "./dist/primitives/index.js",
-      "require": "./dist/primitives/index.cjs",
-      "default": "./dist/primitives/index.js"
+      "types": "./src/data.ts",
+      "default": "./src/data.ts"
     },
     "./primitives/bases/data": {
-      "types": "./dist/primitives/bases/data/index.d.ts",
-      "import": "./dist/primitives/bases/data/index.js",
-      "require": "./dist/primitives/bases/data/index.cjs",
-      "default": "./dist/primitives/bases/data/index.js"
+      "types": "./src/primitives/bases/data/index.ts",
+      "default": "./src/primitives/bases/data/index.ts"
     },
-    "./primitives/*": {
-      "types": "./dist/primitives/*.d.ts",
-      "import": "./dist/primitives/*.js",
-      "require": "./dist/primitives/*.cjs",
-      "default": "./dist/primitives/*.js"
-    },
-    "./gitops": {
-      "types": "./dist/gitops.d.ts",
-      "import": "./dist/gitops.js",
-      "require": "./dist/gitops.cjs",
-      "default": "./dist/gitops.js"
-    },
-    "./canvas": {
-      "types": "./dist/canvas.d.ts",
-      "import": "./dist/canvas.js",
-      "require": "./dist/canvas.cjs",
-      "default": "./dist/canvas.js"
-    },
-    "./dashboard": {
-      "types": "./dist/dashboard.d.ts",
-      "import": "./dist/dashboard.js",
-      "require": "./dist/dashboard.cjs",
-      "default": "./dist/dashboard.js"
-    },
-    "./usage": {
-      "types": "./dist/usage.d.ts",
-      "import": "./dist/usage.js",
-      "require": "./dist/usage.cjs",
-      "default": "./dist/usage.js"
-    },
-    "./oss": {
-      "types": "./dist/oss.d.ts",
-      "import": "./dist/oss.js",
-      "require": "./dist/oss.cjs",
-      "default": "./dist/oss.js"
-    },
-    "./telemetry": {
-      "types": "./dist/telemetry.d.ts",
-      "import": "./dist/telemetry.js",
-      "require": "./dist/telemetry.cjs",
-      "default": "./dist/telemetry.js"
-    },
-    "./styles/motion.css": "./dist/styles/motion.css",
+    "./styles/motion.css": "./src/styles/hanzo-motion.css",
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "types": "./src/index.ts",
   "sideEffects": [
-    "**/*.css",
-    "./dist/gui-config.js",
-    "./dist/core/tokens.js",
-    "./dist/framework/core.js",
-    "./dist/product/social/api.js"
+    "**/*.css"
   ],
   "files": [
-    "dist"
+    "src"
   ],
   "scripts": {
-    "build": "rm -rf dist dist-cjs && tsc -p tsconfig.build.json && tsc -p tsconfig.cjs.json --noCheck && mkdir -p dist/styles && node scripts/compose-theme.mjs && cp src/styles/motion.css dist/styles/motion.css && node scripts/postbuild.mjs && node scripts/gen-css.mjs",
-    "clean": "rm -rf dist dist-cjs types",
-    "gen:primitives": "node scripts/gen-primitives.mjs",
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "rm -rf types",
     "prepack": "pnpm run build",
     "tc": "tsc --noEmit",
     "typecheck": "tsc --noEmit",
-    "typecheck:ui": "tsc -p tsconfig.check.json",
-    "test": "pnpm run test:unit",
-    "test:watch": "vitest",
-    "prepublishOnly": "node -e \"if(!process.env.npm_config_user_agent||!/pnpm/.test(process.env.npm_config_user_agent))throw new Error('publish with pnpm, not npm: only pnpm rewrites workspace:* deps (8.0.17/8.0.19 shipped broken)')\"",
-    "test:consumer": "node scripts/consumer-test.mjs",
-    "test:unit": "vitest run",
-    "test:consumer:webpack": "node scripts/consumer-webpack.mjs"
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
-    "@hanzo/design": "^0.4.7",
-    "@hanzo/logo": "^1.0.13",
-    "@hanzo/products": "^0.2.0",
-    "@hanzogui/lucide-icons-2": "^8.1.0",
-    "@hanzogui/telemetry": "^8.1.0",
-    "@hanzogui/toast": "^8.1.0",
-    "clsx": "^2.1.1"
+    "@hanzo/products": "^0.2.0"
   },
   "peerDependencies": {
-    "@hanzo/canvas": ">=0.1.0",
-    "@hanzo/cd": ">=0.1.0",
-    "@hanzo/dashboard": ">=0.1.0",
-    "@hanzo/data": ">=1.2.3",
-    "@hanzo/gui": ">=8.1.0",
-    "@hanzo/usage": ">=0.1.0",
-    "@hanzogui/config": ">=8.1.0",
-    "@hanzogui/next-theme": ">=8.1.0",
-    "next": ">=14",
-    "next-themes": ">=0.2.1",
-    "react": ">=19",
-    "react-dom": ">=19",
-    "react-native-web": ">=0.21"
-  },
-  "peerDependenciesMeta": {
-    "@hanzo/canvas": {
-      "optional": true
-    },
-    "@hanzo/dashboard": {
-      "optional": true
-    },
-    "@hanzo/cd": {
-      "optional": true
-    },
-    "@hanzo/usage": {
-      "optional": true
-    },
-    "@hanzogui/next-theme": {
-      "optional": true
-    },
-    "next": {
-      "optional": true
-    },
-    "next-themes": {
-      "optional": true
-    },
-    "react-native-web": {
-      "optional": true
-    }
+    "@hanzo/data": ">=1.2.0",
+    "@hanzo/gui": ">=7.2.2",
+    "react": ">=19"
   },
   "devDependencies": {
-    "@hanzo/cd": "workspace:*",
-    "@hanzo/data": "1.2.3",
-    "@hanzo/gui": "8.1.0",
-    "@hanzogui/config": "8.1.0",
-    "@hanzogui/core": "8.1.0",
-    "@hanzogui/lucide-icons-2": "8.1.0",
-    "@hanzogui/next-theme": "8.1.0",
-    "@hanzogui/web": "8.1.0",
-    "@playwright/test": "^1.61.0",
+    "@hanzo/data": "1.2.1",
+    "@hanzo/gui": "7.3.0",
+    "@hanzogui/config": "7.3.0",
+    "@hanzogui/core": "7.3.0",
+    "@hanzogui/lucide-icons-2": "7.3.0",
+    "@hanzogui/next-theme": "7.3.0",
+    "@hanzogui/web": "7.3.0",
     "@types/react": "^19.1.10",
     "@types/react-dom": "^19.1.0",
-    "next-themes": "^0.4.6",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
-    "react-native-web": "^0.21.2",
-    "typescript": "^5.9.3",
-    "vitest": "^4.1.8"
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.9"
   },
   "publishConfig": {
     "access": "public"
   },
-  "license": "MIT",
+  "license": "BSD-3-Clause",
   "author": "Hanzo AI <dev@hanzo.ai>"
 }

pkg/ui/playwright.config.ts

@@ -1,39 +0,0 @@
-import { defineConfig, devices } from '@playwright/test'
-
-/**
- * The browser half of the suite. It never starts a dev server of its own: the
- * app under test is built and served by `scripts/consumer-test.mjs`, from a
- * directory outside this repo that installed the packed tarball.
- *
- * Screenshot baselines are only worth having if they are reproducible, so
- * everything that moves on its own is stopped here rather than per test:
- * animations and transitions are frozen by playwright's `animations: 'disabled'`,
- * the caret is hidden, and the device pixel ratio is pinned so a different
- * display cannot rewrite every baseline. `load()` in the spec awaits
- * `document.fonts.ready` — text metrics shift when a face swaps in, and that is
- * the one source of flake the config cannot cover.
- */
-export default defineConfig({
-  testDir: './test',
-  testMatch: '**/*.spec.ts',
-  fullyParallel: true,
-  forbidOnly: !!process.env.CI,
-  retries: 0,
-  reporter: process.env.CI ? 'line' : 'list',
-  use: {
-    baseURL: process.env.CONSUMER_URL ?? 'http://127.0.0.1:4390',
-    deviceScaleFactor: 1,
-  },
-  expect: {
-    toHaveScreenshot: {
-      animations: 'disabled',
-      caret: 'hide',
-      scale: 'css',
-      // Anti-aliasing differs by a hair between runs of the same renderer. Zero
-      // tolerance produces a suite that fails on its own output, and a suite
-      // that fails on its own output gets ignored and then deleted.
-      maxDiffPixelRatio: 0.002,
-    },
-  },
-  projects: [{ name: 'chromium', use: { ...devices['Desktop Chrome'] } }],
-})

pkg/ui/scripts/alias.mjs

@@ -1,19 +0,0 @@
-// The two resolutions @hanzo/gui needs on a non-browser target, in one place.
-// vitest.config.ts and scripts/gen-css.mjs both read it, because a rule that
-// differs between the suite and the generator is a rule that lies.
-export const alias = [
-  // The gui icon set pulls react-native-svg, whose CommonJS build re-requires
-  // ESM and crashes under Node. Markup is what these renders produce.
-  {
-    find: /^react-native-svg(\/.*)?$/,
-    replacement: new URL('../test/react-native-svg.stub.ts', import.meta.url).pathname,
-  },
-  { find: /^react-native$/, replacement: 'react-native-web' },
-  // `root.tsx` imports the sheet `scripts/gen-css.mjs` writes into `dist` at
-  // publish time. It resolves for a consumer and not from `src`, so anything
-  // that imports the root off source — the suite, the generator — needs this.
-  {
-    find: /^\.\/styles\.css$/,
-    replacement: new URL('../test/styles.stub.ts', import.meta.url).pathname,
-  },
-]

pkg/ui/scripts/compose-theme.mjs

@@ -1,138 +0,0 @@
-// dist/theme.css = @hanzo/design's token layer + this package's own remainder.
-//
-// @hanzo/design is THE token source. It is composed here, at build time, from
-// the installed package — never copy-pasted into src/theme.css, because a copy
-// is how one fact ends up with two homes and the two drift. @hanzo/ui used to
-// declare its own `--background`/`--primary`/`--border` palette, which is
-// exactly that fork: 19 declarations restating values design already publishes.
-// They are gone; what remains in src/theme.css is only what design does NOT
-// ship (the chart ramp, the sidebar set, the Geist bindings) plus this package's
-// own rules.
-//
-// Order matters and is deliberate: design first, ours second, so a remaining
-// declaration here can still override a token when it genuinely has to.
-//
-// Flattened rather than `@import '@hanzo/design/styles.css'` for the reason
-// design's own entry point gives: a bare specifier is not resolvable by a
-// browser, and a nested @import must precede all other rules or it is dropped
-// silently. Inlining is the only form that survives every consumer's bundler.
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { createRequire } from 'node:module'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const require = createRequire(import.meta.url)
-const UI = dirname(dirname(fileURLToPath(import.meta.url)))
-
-const designRaw = readFileSync(require.resolve('@hanzo/design/styles.css'), 'utf8')
-const ours = readFileSync(join(UI, 'src/theme.css'), 'utf8')
-
-// The chrome material — its own entry point AND part of this sheet. A host that
-// already has the token layer (or wants only the material) imports
-// `@hanzo/ui/glass.css`; a host that wants everything imports theme.css and
-// gets it inlined. Two entry points, ONE source file, so they cannot say
-// different things about what glass is.
-const glass = readFileSync(join(UI, 'src/glass.css'), 'utf8')
-
-/**
- * Drop design's @font-face blocks. FONT DELIVERY HAS ONE OWNER AND IT IS NOT US.
- *
- * design self-hosts Geist and its sheet says "the url()s are relative to THIS
- * file, so they resolve wherever the package is" — true of design's file, false
- * the instant it is inlined into ours. Composed here, `url(./assets/fonts/…)`
- * resolves against @hanzo/ui/dist, which has no assets, and webpack's css-loader
- * hard-fails the build:
- *
- *   HookWebpackError: Cannot find module './assets/fonts/Geist-Variable.woff2'
- *
- * That shipped in 8.0.46. Vite tolerates the missing asset, webpack does not,
- * and the consumer test was Vite-only — so the whole class was invisible. There
- * is now a Next/webpack consumer beside it.
- *
- * Copying the .woff2 files into this package would fix the build and create the
- * real problem: two packages shipping the same font, which is one fact in two
- * homes and the exact thing retiring @hanzo/tokens was about. So the rule is
- * dropped instead. This package NAMES the families — it always has; gui-config
- * says "the host self-hosts both faces (its own fonts.css) — this only names
- * them" — and a consumer that wants them self-hosted imports
- * `@hanzo/design/styles.css`, whose url()s resolve against design, where the
- * files actually are.
- */
-const designNoFonts = designRaw.replace(/@font-face\s*\{[^}]*\}/g, '')
-
-/**
- * Teach design's light block gui's spelling of "light".
- *
- * The two systems name the same idea differently: design is `:root` (dark) with
- * `.light` to opt out; gui's provider emits `t_dark` / `t_light`. They never had
- * to agree while gui was declaring its own --background — it simply won. Now
- * that design owns those names, an app in light mode carrying only gui's
- * `t_light` would get design's DARK palette, because nothing matches `.light`.
- *
- * So design's light selector also answers to `:root.t_light`. The VALUES are
- * still declared exactly once, by design, in design's own block — this adds a
- * selector, never a second copy, which is the whole difference between an alias
- * and a fork. `:root.t_light` is (0,2,0) and beats design's `:root` dark, which
- * is the intent.
- *
- * And to a bare `.t_light`, which is the same bug one scope down. gui emits
- * `t_light` on a SPAN for a nested `<Theme name="light">` — PrimaryButton's
- * white pill inside a dark app is exactly that — and `:root.t_light` cannot
- * match a span. Design's tokens therefore stayed dark inside a light island,
- * which is invisible until something in that island reads one: a `--foreground`
- * label on a white pill came out white on white. A directly-matching
- * declaration beats an inherited one whatever the specificity, so the bare
- * class settles the subtree; the `:root` form stays for the whole-page case,
- * where it beats design's dark `:root` on specificity rather than on order.
- *
- * Pure CSS, so it works under SSR. Doing it in <Hanzo> with an effect would
- * leave the first paint dark in a light app.
- */
-const design = designNoFonts.replace(
-  /(^|})([^{}]*?)\.light(\s*)\{/g,
-  (m, brace, before, ws) => `${brace}${before}.light, :root.t_light, .t_light${ws}{`,
-)
-
-// The trap from store's decision doc, checked rather than remembered: design
-// publishes FINISHED colors (`#000000`, `rgb(255 255 255 / .10)`). Wrapping one
-// in `hsl(...)` — the shadcn-era idiom, where tokens were bare `H S% L%` triples
-// — is invalid at computed-value time, and the browser drops the WHOLE
-// declaration without a word. One grep is cheaper than finding it on a page.
-const composed = `${design}\n${ours}\n${glass}`
-const bad = [...composed.matchAll(/\b(hsl|rgb|oklch)a?\(\s*var\(/g)].map((m) => m[0])
-if (bad.length) {
-  throw new Error(
-    `theme.css wraps a design token in a colour function: ${[...new Set(bad)].join(', ')}\n` +
-      `  @hanzo/design publishes finished colours, so hsl(var(--x)) is invalid and the\n` +
-      `  browser drops the declaration silently. Use var(--x) directly.`,
-  )
-}
-
-// No url() may survive, at all. This package ships `dist` and nothing else, so
-// ANY relative asset reference in this sheet points at a file that is not there
-// — and the bundler that says so is webpack, not Vite, which is how 8.0.46 went
-// out green. A grep costs nothing and does not depend on remembering.
-const urls = [...composed.matchAll(/url\(\s*['"]?([^'")]+)['"]?\s*\)/g)]
-  .map((m) => m[1].trim())
-  .filter((u) => u && !u.startsWith('data:') && !u.startsWith('#'))
-if (urls.length) {
-  throw new Error(
-    `theme.css references ${urls.length} external asset(s): ${[...new Set(urls)].join(', ')}\n` +
-      `  This package ships only "dist", so a relative url() here resolves to nothing and\n` +
-      `  webpack's css-loader fails the consumer's build. Font delivery belongs to\n` +
-      `  @hanzo/design, which self-hosts the files; this sheet only names the families.`,
-  )
-}
-
-mkdirSync(join(UI, 'dist'), { recursive: true })
-writeFileSync(join(UI, 'dist/theme.css'), composed)
-writeFileSync(join(UI, 'dist/glass.css'), glass)
-
-// design's exports map does not expose ./package.json, so the version is read
-// off the resolved stylesheet's own directory rather than by specifier.
-const version = JSON.parse(
-  readFileSync(join(dirname(require.resolve('@hanzo/design/styles.css')), 'package.json'), 'utf8'),
-).version
-console.log(
-  `dist/theme.css — ${composed.length.toLocaleString()} bytes (@hanzo/design ${version} + this package)`,
-)

pkg/ui/scripts/consumer-test.mjs

@@ -1,145 +0,0 @@
-// Install @hanzo/ui the way a stranger would, render it, and look at the result.
-//
-// `pnpm pack` -> a temp directory OUTSIDE this repo -> `npm i ./hanzo-ui-*.tgz`
-// -> `vite build` -> serve -> playwright. Not a workspace link: a link resolves
-// through src/ and hides every packaging defect there is — a file missing from
-// `files`, a subpath missing from `exports`, a `workspace:*` that npm never
-// rewrote (8.0.17 and 8.0.19 shipped exactly that), a stylesheet that is
-// generated and never packed.
-//
-// `pnpm pack` runs `prepack`, which builds — so the tarball is always the
-// current tree and there is no way to test a stale one by accident.
-import { execFileSync, spawn } from 'node:child_process'
-import { cpSync, mkdtempSync, readdirSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const UI = dirname(dirname(fileURLToPath(import.meta.url)))
-const PORT = Number(process.env.CONSUMER_PORT ?? 4390)
-// The address is STATED, not inferred — see the `--host 127.0.0.1` below, which
-// is the whole reason this gate can go green. Keep the three literals (here, the
-// spawn, and playwright.config.ts's baseURL) equal.
-const URL_ = `http://127.0.0.1:${PORT}`
-
-const run = (cmd, args, cwd) =>
-  execFileSync(cmd, args, { cwd, stdio: 'inherit', env: { ...process.env, npm_config_yes: 'true' } })
-
-const app = mkdtempSync(join(tmpdir(), 'hanzo-ui-consumer-'))
-let server
-try {
-  console.log(`\n· packing @hanzo/ui`)
-  run('pnpm', ['pack', '--pack-destination', app], UI)
-  const tgz = readdirSync(app).find((f) => f.endsWith('.tgz'))
-  if (!tgz) throw new Error('pnpm pack produced no tarball')
-
-  console.log(`· installing ${tgz} into ${app}`)
-  cpSync(join(UI, 'test/consumer'), app, { recursive: true })
-  run('npm', ['i', '--no-audit', '--no-fund', '--silent'], app)
-  run('npm', ['i', '--no-audit', '--no-fund', '--silent', `./${tgz}`], app)
-
-  // ONE COPY of the gui runtime, or nothing below means anything.
-  //
-  // @hanzogui packages pin each other EXACTLY (toast@8.0.0 -> core@8.0.0, no
-  // caret), so a single stale range in this package's dependencies drags a whole
-  // second generation of the train in beside the consumer's. Both typecheck.
-  // Both build. Then the config singleton lives in one copy and the components
-  // read the other, and the app dies on prerender with `Missing theme.` —
-  // hanzo.ai hit exactly that and had to state the invariant by hand in a
-  // pnpm.overrides block.
-  //
-  // The invariant belongs HERE, in the package that caused it. `npm ls` prints
-  // one line per resolved copy; more than one distinct version is the defect.
-  {
-    const out = execFileSync('npm', ['ls', '@hanzogui/web', '--all', '--json'], {
-      cwd: app,
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    })
-    const found = new Set()
-    const walk = (node) => {
-      if (!node || typeof node !== 'object') return
-      if (node.version && node._name === '@hanzogui/web') found.add(node.version)
-      for (const [name, child] of Object.entries(node.dependencies ?? {})) {
-        if (name === '@hanzogui/web' && child.version) found.add(child.version)
-        walk(child)
-      }
-    }
-    walk(JSON.parse(out))
-    console.log(`· @hanzogui/web copies: ${[...found].join(', ') || 'none'}`)
-    if (found.size > 1)
-      throw new Error(
-        `${found.size} copies of @hanzogui/web resolved in the consumer: ${[...found].join(', ')}.\n` +
-          `  The gui runtime must resolve to ONE copy. Two generations means the config\n` +
-          `  singleton and the components live in different modules, which typechecks,\n` +
-          `  builds, and then dies on prerender with "Missing theme.".\n` +
-          `  Fix the @hanzogui/* ranges in this package rather than overriding downstream.`,
-      )
-  }
-
-  console.log(`· building the consumer app`)
-  run('npx', ['vite', 'build'], app)
-
-  // Someone else on this port answers every request and the suite passes against
-  // THEIR app — which is how a run once reported stale failures from a preview
-  // server left over from the previous run. `--strictPort` refuses to bind, but
-  // nothing downstream would have noticed.
-  const taken = await fetch(URL_).then(
-    () => true,
-    () => false,
-  )
-  if (taken) throw new Error(`${URL_} is already serving something. Free it, or set CONSUMER_PORT.`)
-
-  // `--host 127.0.0.1` STATES the interface instead of leaving it to be
-  // inferred, and the inference is what kept this gate red. Vite picks its own
-  // default and resolves `localhost` through the platform's resolver, so the
-  // address it listens on differs by machine: on macOS it bound [::1] only and
-  // 127.0.0.1 refused; on the Linux runner it did the opposite and `localhost`
-  // was the one that never answered. Either way the poll below counted to 60
-  // and reported the app as broken, after the pack, the install and the build
-  // had all succeeded.
-  //
-  // Named here, both ends agree by construction — this, the poll, and
-  // playwright.config.ts's baseURL are the same literal on every platform.
-  server = spawn(
-    'npx',
-    ['vite', 'preview', '--host', '127.0.0.1', '--port', String(PORT), '--strictPort'],
-    { cwd: app, stdio: ['ignore', 'pipe', 'pipe'], detached: true },
-  )
-
-  // The server's own account of itself, kept rather than discarded.
-  //
-  // This was `stdio: 'ignore'`, so a preview that died on startup and one that
-  // was merely slow produced the identical message 30 seconds apart — on a CI
-  // runner nobody can attach to. Three runs were spent guessing at a cause vite
-  // had printed on the first one. Whatever it says, the failure says it too.
-  let said = ''
-  const keep = (d) => (said += d)
-  server.stdout.on('data', keep)
-  server.stderr.on('data', keep)
-
-  // A process that has already exited is never going to answer, so waiting the
-  // full 30s for it teaches nothing.
-  let dead = null
-  server.on('exit', (code, signal) => (dead = signal ?? `exit ${code}`))
-
-  const withLog = (msg) => new Error(`${msg}\n--- vite preview said ---\n${said.trim() || '(nothing)'}`)
-  for (let i = 0; ; i++) {
-    try {
-      await fetch(URL_)
-      break
-    } catch {
-      if (dead) throw withLog(`vite preview died (${dead}) before serving ${URL_}`)
-      if (i > 60) throw withLog(`consumer app never came up on ${URL_}`)
-      await new Promise((r) => setTimeout(r, 500))
-    }
-  }
-
-  console.log(`· asserting computed styles in a browser\n`)
-  run('npx', ['playwright', 'test', ...process.argv.slice(2)], UI)
-  console.log(`\nconsumer test passed against ${app}`)
-} finally {
-  if (server?.pid) try { process.kill(-server.pid) } catch {}
-  if (!process.env.KEEP_CONSUMER_APP) rmSync(app, { recursive: true, force: true })
-  else console.log(`kept ${app}`)
-}

pkg/ui/scripts/consumer-webpack.mjs

@@ -1,48 +0,0 @@
-// The webpack half of the consumer test. Same install-a-stranger's-tarball
-// discipline as consumer-test.mjs, different bundler — because the two disagree
-// about a whole class of defect and only one of them was ever asked.
-//
-// 8.0.46 shipped a stylesheet whose @font-face pointed at
-// `./assets/fonts/Geist-Variable.woff2`, a file @hanzo/ui does not pack. Vite
-// leaves an unresolvable url() alone and the Vite consumer went green; webpack's
-// css-loader resolves it against the declaring file and fails the build:
-//
-//   HookWebpackError: Cannot find module './assets/fonts/Geist-Variable.woff2'
-//
-// hanzo.app found that, not this suite. So the suite now runs both.
-//
-// The assertion is the build itself. This defect is a BUILD failure, never a
-// render failure — there is nothing to measure in a browser, and a passing
-// `webpack --mode production` is the whole proof.
-import { execFileSync } from 'node:child_process'
-import { cpSync, mkdtempSync, readdirSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const UI = dirname(dirname(fileURLToPath(import.meta.url)))
-const run = (cmd, args, cwd) =>
-  execFileSync(cmd, args, { cwd, stdio: 'inherit', env: { ...process.env, npm_config_yes: 'true' } })
-
-const app = mkdtempSync(join(tmpdir(), 'hanzo-ui-webpack-'))
-try {
-  console.log(`\n· packing @hanzo/ui`)
-  run('pnpm', ['pack', '--pack-destination', app], UI)
-  const tgz = readdirSync(app).find((f) => f.endsWith('.tgz'))
-  if (!tgz) throw new Error('pnpm pack produced no tarball')
-
-  console.log(`· installing ${tgz} into ${app}`)
-  cpSync(join(UI, 'test/consumer-webpack'), app, { recursive: true })
-  run('npm', ['i', '--no-audit', '--no-fund', '--silent'], app)
-  run('npm', ['i', '--no-audit', '--no-fund', '--silent', `./${tgz}`], app)
-
-  console.log(`· building with webpack + css-loader`)
-  run('npx', ['webpack', '--mode', 'production'], app)
-  console.log(`\nwebpack consumer test passed against ${app}`)
-  rmSync(app, { recursive: true, force: true })
-} catch (err) {
-  // Kept on disk on failure: the tarball and the resolved node_modules are the
-  // evidence, and deleting them is how a packaging bug becomes unreproducible.
-  console.error(`\nwebpack consumer test FAILED. App kept for inspection: ${app}`)
-  throw err
-}

pkg/ui/scripts/gen-css.mjs

@@ -1,163 +0,0 @@
-// Write dist/styles.css — every rule @hanzo/ui's own components need, extracted
-// at OUR publish time instead of at each app's.
-//
-// @hanzo/gui compiles a style prop to an atomic class the first time something
-// RENDERS it, so the sheet does not exist until a render has happened. Every app
-// therefore had to run a generator of its own and import the output. hanzo.app
-// did not, and shipped 103 `_bg-` classes and 26 `_dsp-` classes against a
-// stylesheet containing zero of either — every gui-styled element unstyled in
-// production, with a green build for the whole life of the bug.
-//
-// The render happens here instead. src/gallery.tsx is the list of what to render
-// and it is the same list the unit test mounts and the consumer test asserts
-// against, so a component cannot be styled by one and missed by another.
-//
-// `config.getCSS()` returns gui's design-system rules, the token and font custom
-// properties, the theme rule sets, and `getAllRules()` — the atomic rules this
-// process accumulated. Accumulation happens during `getSplitStyles`, which is
-// why a plain `renderToStaticMarkup` is enough and no DOM is involved.
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { createElement } from 'react'
-import { renderToStaticMarkup } from 'react-dom/server'
-import { createServer } from 'vite'
-
-import { alias } from './alias.mjs'
-
-const UI = dirname(dirname(fileURLToPath(import.meta.url)))
-
-// Rendering must not be told the CSS was already emitted — that flag makes
-// getCSS() and getAllRules() return empty and there is nothing to write.
-delete process.env.GUI_DID_OUTPUT_CSS
-
-const server = await createServer({
-  root: UI,
-  configFile: false,
-  logLevel: 'error',
-  css: { postcss: { plugins: [] } },
-  resolve: { alias },
-  // The aliases only reach source vite transforms, and the icon set's
-  // `react-native-svg` import is inside @hanzogui — so gui has to be inlined for
-  // the stub to apply. react-native-web stays external: it is Node-loadable, and
-  // inlining it drags in CommonJS (`@react-native/normalize-color`) that vite's
-  // SSR runner evaluates as ESM and dies on.
-  ssr: { noExternal: [/@hanzogui\//, /@hanzo\/gui/] },
-})
-
-
-/**
- * Stop gui's ROOT theme from shadowing @hanzo/design's token names.
- *
- * design declares `--background`, `--black`, `--white` on `:root` and `.light`
- * — specificity (0,1,0). gui's generated theme classes redeclare the same three
- * on `:root.t_dark` / `:root.t_light` — (0,2,0). Specificity beats source order,
- * so gui wins in every app that wires GuiProvider's theme class onto <html>, and
- * design's palette is silently replaced by gui's default grey.
- *
- * That also means the obvious workaround does not work: re-importing design's
- * colors.css LAST cannot win against a higher specificity. It only appears to
- * work where the theme classes never reach <html>, and reverts the day someone
- * wires themes correctly — a fix that expires on being fixed.
- *
- * One fact, one home, at the CSS layer too: these three names belong to design,
- * so the ROOT theme blocks stop declaring them and `var(--background)` resolves
- * through design.
- *
- * SUB-THEMES ARE LEFT ALONE, and that distinction is the whole reason this is a
- * parser and not a regex. `.t_accent`, `.t_blue_Button` and ~248 others
- * legitimately scope their own background — that is what a nested theme IS.
- * Only a selector that is exactly `:root`, `:root.t_dark` or `:root.t_light` is
- * the root theme; anything with a further `.t_*` is a nested one and keeps its
- * override.
- *
- * Bare `:root` is in that list because gui shadows TWICE, by two different
- * mechanisms, and fixing only the loud one leaves the page just as wrong:
- *   · `:root.t_dark` / `:root.t_light` — (0,2,0), beats design on SPECIFICITY.
- *   · plain `:root { --background: var(--t1) }` — (0,1,0), TIES design and wins
- *     on SOURCE ORDER, because gui's block is appended after design's here.
- * The second one is why the acceptance test still read gui's grey after the
- * first fix.
- */
-const SHADOWED = ['background', 'black', 'white']
-const ROOT_THEME = /^:root(\.t_(dark|light))?$/
-
-function unshadowDesignTokens(css) {
-  let out = ''
-  let i = 0
-  let stripped = 0
-  while (i < css.length) {
-    const open = css.indexOf('{', i)
-    if (open === -1) {
-      out += css.slice(i)
-      break
-    }
-    const close = css.indexOf('}', open)
-    if (close === -1) {
-      out += css.slice(i)
-      break
-    }
-    const selector = css.slice(i, open)
-    let body = css.slice(open + 1, close)
-    const isRootTheme = selector
-      .split(',')
-      .some((sel) => ROOT_THEME.test(sel.trim()))
-    if (isRootTheme) {
-      for (const name of SHADOWED) {
-        const before = body
-        body = body.replace(new RegExp(`(^|;)\\s*--${name}\\s*:[^;}]*;?`, 'g'), '$1')
-        if (body !== before) stripped++
-      }
-    }
-    out += selector + '{' + body + '}'
-    i = close + 1
-  }
-  console.log(`  unshadowed ${stripped} design token declaration(s) from gui's root themes`)
-  return out
-}
-
-try {
-  const { GuiProvider } = await server.ssrLoadModule('@hanzo/gui')
-  const { config } = await server.ssrLoadModule(join(UI, 'src/gui-config.ts'))
-  const { Gallery } = await server.ssrLoadModule(join(UI, 'src/gallery.tsx'))
-
-  // Both themes: a theme is a set of custom-property values, but the styles that
-  // READ them are per-theme classes, and a component only renders the ones its
-  // theme resolves. Rendering dark alone leaves the light sheet incomplete.
-  for (const theme of ['dark', 'light'])
-    renderToStaticMarkup(
-      createElement(GuiProvider, { config, defaultTheme: theme }, createElement(Gallery)),
-    )
-
-  const gui = unshadowDesignTokens(config.getCSS())
-  // dist/theme.css, not src: the token layer is @hanzo/design's, composed in
-  // by scripts/compose-theme.mjs. Reading src here would ship a stylesheet whose
-  // components reference tokens the sheet never declares.
-  const tokens = readFileSync(join(UI, 'dist/theme.css'), 'utf8')
-  const motion = readFileSync(join(UI, 'src/styles/motion.css'), 'utf8')
-
-  // `--hanzo-ui-styles` is what <Hanzo> looks up to tell a consumer, in
-  // development, that this file never reached the document.
-  const css = [
-    '/* @hanzo/ui — generated by scripts/gen-css.mjs. Do not edit. */',
-    ':root { --hanzo-ui-styles: 1; }',
-    tokens,
-    motion,
-    gui,
-  ].join('\n')
-
-  mkdirSync(join(UI, 'dist'), { recursive: true })
-  writeFileSync(join(UI, 'dist/styles.css'), css)
-
-  const atomic = (gui.match(/\._[\w-]+/g) ?? []).length
-  console.log(
-    `dist/styles.css — ${css.length.toLocaleString()} bytes, ${atomic.toLocaleString()} atomic selectors`,
-  )
-} finally {
-  await server.close()
-}
-
-// Vite's module runner leaves handles open that `close()` does not reap, and a
-// build step that writes its output and then never exits hangs `prepack`, which
-// hangs `pnpm pack`, which hangs `pnpm publish`. The work is done; leave.
-process.exit(0)

pkg/ui/scripts/gen-primitives.mjs

@@ -1,79 +0,0 @@
-#!/usr/bin/env node
-/**
- * Emit one re-export entrypoint per component-surface member into `src/primitives/`.
- *
- * A host may modularize `@hanzo/ui` imports into per-member subpaths — e.g.
- * hanzo.app's `next.config.ts`:
- *   modularizeImports: { '@hanzo/ui': { transform: '@hanzo/ui/primitives/{{member}}' } }
- * rewrites `import { Button } from '@hanzo/ui'` into
- * `import { Button } from '@hanzo/ui/primitives/Button'`. For that to resolve,
- * `@hanzo/ui/primitives/<Member>` must be a module exporting exactly `<Member>`.
- *
- * The gui backend barrel (`src/backends/gui/index.ts`) is the SINGLE source of
- * truth for the surface; this script derives the member list from it, so the
- * per-member files never drift. Re-run after changing the surface:
- *   node scripts/gen-primitives.mjs
- */
-import { readFileSync, writeFileSync, readdirSync, unlinkSync, mkdirSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const here = dirname(fileURLToPath(import.meta.url))
-const root = join(here, '..')
-const barrelPath = join(root, 'src/backends/gui/index.ts')
-const outDir = join(root, 'src/primitives')
-
-const src = readFileSync(barrelPath, 'utf8')
-
-// Collect VALUE member names from every `export { ... } from './module'` block,
-// KEEPING the module each one came from. Type-only members (`type Foo`) are
-// skipped: they are not values, cannot be re-exported without `export type` under
-// isolatedModules, and a host only modularizes value imports.
-//
-// The module matters as much as the name. A per-member file that re-exports from
-// the BARREL puts every component in one bundler chunk, so `import { Button }`
-// drags Select, Dialog, Popover, Tooltip and the whole floating stack with it
-// (measured: 201KB instead of 75KB). Re-exporting from the member's own module
-// keeps one component per chunk and lets the shake actually work.
-const members = new Map()
-for (const m of src.matchAll(/export\s*\{([^}]*)\}\s*from\s*'(\.\/[\w.-]+)'/g)) {
-  const from = m[2]
-  for (const raw of m[1].split(',')) {
-    const name = raw.trim()
-    if (!name || name.startsWith('type ')) continue
-    // `X as Y` → the exported name is Y.
-    const exported = name.includes(' as ') ? name.split(/\s+as\s+/)[1].trim() : name
-    if (/^[A-Za-z_$][\w$]*$/.test(exported)) members.set(exported, from)
-  }
-}
-
-mkdirSync(outDir, { recursive: true })
-
-const BANNER =
-  '// GENERATED by scripts/gen-primitives.mjs — do not edit. Per-member entrypoint\n' +
-  '// for hosts that modularize `@hanzo/ui` imports. Source of truth:\n' +
-  '// src/backends/gui/index.ts. Re-run: node scripts/gen-primitives.mjs\n'
-
-// Clear previously generated member files (keep hand-authored index.ts + bases/).
-for (const f of readdirSync(outDir, { withFileTypes: true })) {
-  if (f.isFile() && f.name.endsWith('.tsx') && f.name !== 'index.ts') {
-    const p = join(outDir, f.name)
-    if (readFileSync(p, 'utf8').startsWith('// GENERATED')) unlinkSync(p)
-  }
-}
-
-const sorted = [...members.keys()].sort()
-for (const name of sorted) {
-  writeFileSync(
-    join(outDir, `${name}.tsx`),
-    `${BANNER}export { ${name} } from '../backends/gui/${members.get(name).slice(2)}'\n`,
-  )
-}
-
-// A `./primitives` root and `./primitives/index` that mirror the full surface.
-writeFileSync(
-  join(outDir, 'index.ts'),
-  `${BANNER}export * from '../backends/gui'\n`,
-)
-
-console.log(`gen-primitives: wrote ${sorted.length} member entrypoints + index.ts`)

pkg/ui/scripts/postbuild.mjs

@@ -1,134 +0,0 @@
-// Make tsc's per-file emit shippable. Two orthogonal passes, one walk each.
-//
-//   1. specifiers — tsc copies relative import specifiers through verbatim, so
-//      `./button` stays extensionless. Node ESM and strict bundlers demand a
-//      fully-specified path, so every relative specifier is resolved against
-//      what was actually emitted: `./button` -> `./button.js` or `./x/index.js`.
-//   2. 'use client' — the component layer is client-side @hanzo/gui UI, and Next's
-//      flight-client loader needs the directive as the FIRST statement of every
-//      such module. Prepended without a newline so source-map line numbers hold.
-//      DATA modules are excluded (see DATA below): a token scale or a gui config
-//      is data, not a component, and stamping it means React's SERVER layer can
-//      only hold a client REFERENCE to it — so `createGui()` never runs in a
-//      prerender, `configureMedia()` never sets its state, and the first
-//      `useMedia()` proxies `undefined`. Data has to stay executable everywhere.
-//
-// The CJS half is compiled to dist-cjs (tsc cannot emit two module formats to
-// one outDir) and folded into dist as `.cjs` here.
-//
-// TWO packages run this, and that is deliberate — @hanzo/data emits the same
-// two formats with the same two problems, and a second copy of this file is a
-// second place for the barrel rule below to be got wrong. The package root and
-// its data modules are arguments:
-//
-//   node ../ui/scripts/postbuild.mjs <package-root> [data,modules,by,path]
-//
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
-import { dirname, join, relative, resolve as abs } from 'node:path'
-
-const UI = process.argv[2] ? abs(process.argv[2]) : new URL('..', import.meta.url).pathname
-const DIST = join(UI, 'dist')
-const CJS = join(UI, 'dist-cjs')
-const DIRECTIVE = "'use client';"
-
-/**
- * Emitted modules that are data, not components — never stamped.
- *
- * Everything `product/pure` re-exports is on this list, and has to be: the point
- * of that subpath is that a rule loads anywhere a value loads, and a stamped
- * module is a client REFERENCE on React's server layer, not a function. Calling
- * `pages()` in a server component through a stamped module does not page — it
- * throws. `product/pure` names its own constituents, so this list is that list.
- */
-const DATA = new Set(
-  process.argv[3]
-    ? process.argv[3].split(',').filter(Boolean)
-    : [
-        'gui-config',
-        'core/tokens',
-        'core/css',
-        'framework/core',
-        'glass',
-        'product/social/api',
-        'product/pure',
-        'product/pages',
-        'backends/gui/mask',
-        'product/name',
-        'product/tone',
-        'product/scope',
-        'product/brand',
-        'product/animatedLogo.logic',
-        'product/combobox/filter',
-      ],
-)
-
-const files = (dir, out = []) => {
-  for (const name of readdirSync(dir)) {
-    const p = join(dir, name)
-    statSync(p).isDirectory() ? files(p, out) : out.push(p)
-  }
-  return out
-}
-
-// `from './x'`, `import './x'`, `import('./x')`, `require('./x')`
-const SPECIFIER = /(\bfrom\s*|\bimport\s*\(?\s*|\brequire\s*\(\s*)(['"])(\.[^'"]*)\2/g
-
-/** Resolve `spec` (relative, extensionless) against what tsc emitted next to `file`. */
-const resolve = (file, spec, ext, probe) => {
-  const base = join(dirname(file), spec)
-  if (existsSync(base + probe)) return spec + ext
-  if (existsSync(join(base, 'index' + probe))) return `${spec}/index${ext}`
-  return null
-}
-
-const specifiers = (file, ext, probe) => {
-  const src = readFileSync(file, 'utf8')
-  const out = src.replace(SPECIFIER, (m, head, q, spec) => {
-    if (/\.(js|cjs|mjs|json|css)$/.test(spec)) return m
-    const fixed = resolve(file, spec, ext, probe)
-    if (!fixed) throw new Error(`unresolved specifier ${spec} in ${relative(UI, file)}`)
-    return `${head}${q}${fixed}${q}`
-  })
-  if (out !== src) writeFileSync(file, out)
-}
-
-// A module whose statements are ONLY import/export is a barrel: the client
-// boundary belongs to the leaves it re-exports, which carry their own
-// directive. Stamping the barrel itself makes it a client module, and Next's
-// flight loader hard-errors on `export *` inside a client boundary — which is
-// exactly how 8.0.32 broke every Next 16 consumer at `dist/index.js`.
-const reexportOnly = (src) =>
-  src
-    .replace(/\/\*[\s\S]*?\*\//g, '')
-    .replace(/\/\/[^\n]*/g, '')
-    .replace(/(?:import|export)[^;'"]*from\s*['"][^'"]*['"];?/g, '')
-    .replace(/import\s*['"][^'"]*['"];?/g, '')
-    .replace(/export\s*\{[\s\S]*?\};?/g, '')
-    .trim() === ''
-
-const useClient = (file) => {
-  if (DATA.has(relative(DIST, file).replace(/\.(js|cjs)$/, ''))) return
-  const src = readFileSync(file, 'utf8')
-  if (reexportOnly(src)) return
-  if (!/^['"]use client['"]/.test(src)) writeFileSync(file, DIRECTIVE + src)
-}
-
-// ESM + declarations.
-for (const f of files(DIST)) {
-  if (f.endsWith('.d.ts')) specifiers(f, '.js', '.d.ts')
-  else if (f.endsWith('.js')) specifiers(f, '.js', '.js')
-}
-
-// CJS: rewrite in place, then fold into dist as `.cjs`.
-if (existsSync(CJS)) {
-  for (const f of files(CJS)) if (f.endsWith('.js')) specifiers(f, '.cjs', '.js')
-  for (const f of files(CJS)) {
-    if (!f.endsWith('.js')) continue
-    const dest = join(DIST, relative(CJS, f)).replace(/\.js$/, '.cjs')
-    mkdirSync(dirname(dest), { recursive: true })
-    cpSync(f, dest)
-  }
-  rmSync(CJS, { recursive: true, force: true })
-}
-
-for (const f of files(DIST)) if (/\.(js|cjs)$/.test(f)) useClient(f)

pkg/ui/src/backends/README.md

@@ -1,38 +0,0 @@
-# @hanzo/ui — the component surface
-
-There is ONE substrate. `gui/` implements every component on @hanzo/gui
-(Tamagui) primitives, so the same import renders on web, native (expo) and
-desktop (Tauri). The Radix + Tailwind surface that used to live beside it has
-moved out to its own package; nothing here depends on it.
-
-```
-src/
-  core/                design core, runtime-free
-    cn.ts              class-name composer (clsx)
-    tokens.ts          re-export of @hanzo/design (the token source of truth)
-    fonts.ts           Geist Sans / Geist Mono family variables
-  theme.css            self-contained token vars + Geist (the identity)
-  backends/gui/        the component surface — index.ts is its manifest
-  product/             the product/app layer, same substrate (@hanzo/ui/product)
-  primitives/          GENERATED per-member entrypoints (see below)
-```
-
-## Rules a component follows
-
-- Style through gui props and theme tokens (`$background`, `$color12`,
-  `$borderColor`) — never a utility class string, never a hard-coded font
-  family. Typography inherits Geist through the token config.
-- Touch targets meet the 44px floor via `hitSlop`, never via padding: visual
-  density and hit area are two concerns.
-- Behaviour (focus management, portalling, keyboard, a11y) comes from the
-  matching `@hanzogui/*` primitive. Nothing here reimplements it.
-- Free-form text children go through `ink()` so a bare string renders on native.
-- `data-slot` markers go through `slot()`. One helper each, one place.
-
-## The manifest
-
-`gui/index.ts` is the SINGLE source of truth for the surface. `scripts/gen-primitives.mjs`
-reads it and emits `src/primitives/<Member>.tsx`, one per exported value, for hosts
-that modularize `@hanzo/ui` imports. Change the barrel, then re-run:
-
-    node scripts/gen-primitives.mjs

pkg/ui/src/backends/gui/aspect-ratio.tsx

@@ -1,47 +0,0 @@
-'use client'
-
-/**
- * AspectRatio — a box that holds a width-to-height ratio.
- *
- * `aspectRatio` is a first-class layout property of the gui/Yoga box model, so
- * there is nothing to compute and no padding-bottom trick: the ratio is the
- * style. That is why this is the whole component on web, native and desktop.
- *
- * The reason to reach for it is that the box has an intrinsic height BEFORE its
- * content loads. An `<img>` with no ratio is 0px tall until the bytes arrive,
- * which is both the "media box rendered at zero height" defect and the layout
- * shift when it finally does. Ratio first, content second — the box is never
- * zero-height, so nothing below it ever moves.
- *
- * `overflow: hidden` is not decoration: the child is sized to FILL this box (see
- * the `[data-slot='aspect-ratio'] > img` rule in styles/motion.css), and a
- * cover-fitted image is by definition larger than its frame on one axis.
- * `position: relative` makes this the containing block, so an absolutely
- * positioned overlay — a play button, a scrim, a badge — lands on the media
- * instead of on the page.
- */
-import { YStack, type YStackProps } from '@hanzo/gui'
-
-export interface AspectRatioProps extends YStackProps {
-  /** Width divided by height. Square by default. */
-  ratio?: number
-}
-
-const AspectRatio = ({ ratio = 1, ...props }: AspectRatioProps) => (
-  <YStack
-    data-slot="aspect-ratio"
-    width="100%"
-    aspectRatio={ratio}
-    overflow="hidden"
-    position="relative"
-    {...props}
-    // AFTER the spread, deliberately. `data-slot` is the caller-facing name and
-    // a wrapper may rename it — CardMedia does — but the fill rule in
-    // styles/motion.css keys off THIS attribute, so the contract survives being
-    // wrapped. Targeting data-slot instead is how the rule silently stopped
-    // matching the moment Card.Media renamed the slot.
-    data-ratio=""
-  />
-)
-
-export { AspectRatio }

pkg/ui/src/backends/gui/avatar.tsx

@@ -1,45 +0,0 @@
-'use client'
-
-/**
- * Avatar — circular image with a text fallback.
- *
- * @hanzogui/avatar owns the load/error state machine and the fallback delay, so
- * this only names the three parts and dresses them in tokens.
- */
-import { Avatar as GuiAvatar, SizableText } from '@hanzo/gui'
-import type { ComponentProps } from 'react'
-
-const SIZE = 32
-
-export type AvatarProps = ComponentProps<typeof GuiAvatar>
-export type AvatarImageProps = ComponentProps<typeof GuiAvatar.Image>
-export type AvatarFallbackProps = ComponentProps<typeof GuiAvatar.Fallback>
-
-const Avatar = (props: AvatarProps) => (
-  <GuiAvatar data-slot="avatar" circular size={SIZE} shrink={0} overflow="hidden" {...props} />
-)
-
-const AvatarImage = (props: AvatarImageProps) => (
-  <GuiAvatar.Image data-slot="avatar-image" width="100%" height="100%" {...props} />
-)
-
-/** Bare text needs a Text host to render on native; elements pass through. */
-const AvatarFallback = ({ children, ...props }: AvatarFallbackProps) => (
-  <GuiAvatar.Fallback
-    data-slot="avatar-fallback"
-    bg="$color4"
-    items="center"
-    justify="center"
-    {...props}
-  >
-    {typeof children === 'string' || typeof children === 'number' ? (
-      <SizableText size="$2" color="$color11">
-        {children}
-      </SizableText>
-    ) : (
-      children
-    )}
-  </GuiAvatar.Fallback>
-)
-
-export { Avatar, AvatarImage, AvatarFallback }

pkg/ui/src/backends/gui/badge.tsx

@@ -1,131 +0,0 @@
-'use client'
-
-/**
- * Badge — the gui-backend original.
- *
- * `Badge`, `badgeVariants`, `data-slot`/`data-variant`, `asChild`. The substrate
- * is @hanzo/gui: `styled()` variants and theme tokens, so it renders on web,
- * native (expo) and Tauri.
- *
- * Surface and ink are two concerns, so they are two styled parts sharing one
- * `variant` through a styled context — the frame owns background/border, the
- * text owns color/weight/case. Nothing reads `variant` twice by hand.
- */
-import { SizableText, XStack, createStyledContext, styled } from '@hanzo/gui'
-import * as React from 'react'
-import { ink } from './ink'
-import { touch } from './gesture'
-
-export type BadgeVariant =
-  | 'default'
-  | 'secondary'
-  | 'destructive'
-  | 'outline'
-  | 'ghost'
-  | 'link'
-  | 'inputAdornment'
-  | 'tags'
-
-/** A badge is a 24px pill; the slop makes its press area meet the 44px floor. */
-const MIN_TOUCH = 44
-const HEIGHT = 24
-
-const BadgeContext = /* @__PURE__ */ createStyledContext<{ variant: BadgeVariant }>({ variant: 'default' })
-
-const BadgeFrame = styled(XStack, {
-  name: 'Badge',
-  context: BadgeContext,
-  // A badge shrink-wraps its label, always. `self: 'flex-start'` alone only
-  // achieves that inside a FLEX parent — alignSelf is inert in a block one, so
-  // an XStack (display: flex) placed in a plain <div> becomes a block-level flex
-  // container and stretches the full width. Both are kept: inline-flex handles
-  // the block parent, alignSelf still governs when the parent is flex.
-  display: 'inline-flex',
-  self: 'flex-start',
-  items: 'center',
-  justify: 'center',
-  shrink: 0,
-  minH: HEIGHT,
-  px: '$2.5',
-  py: '$1',
-  gap: '$1.5',
-  rounded: '$2',
-  borderWidth: 1,
-  borderColor: 'transparent',
-  overflow: 'hidden',
-
-  variants: {
-    variant: {
-      default: { bg: '$color12' },
-      secondary: { bg: '$color4' },
-      destructive: { bg: '$red9' },
-      outline: { bg: '$background', borderColor: '$borderColor' },
-      ghost: { bg: 'transparent', hoverStyle: { bg: '$color3' } },
-      link: { bg: 'transparent' },
-      inputAdornment: { bg: '$color3', px: '$2' },
-      tags: { bg: '$color3', borderColor: '$borderColor', rounded: '$3' },
-    },
-  } as const,
-
-  defaultVariants: { variant: 'default' },
-})
-
-const BadgeText = styled(SizableText, {
-  name: 'BadgeText',
-  context: BadgeContext,
-  size: '$1',
-  fontWeight: '600',
-
-  variants: {
-    variant: {
-      default: { color: '$color1' },
-      secondary: { color: '$color12' },
-      destructive: { color: '$white1' },
-      outline: { color: '$color12' },
-      ghost: { color: '$color12' },
-      link: { color: '$color12', textDecorationLine: 'underline' },
-      inputAdornment: { color: '$color12', fontWeight: '500' },
-      tags: { color: '$color11', fontWeight: '400', textTransform: 'capitalize' },
-    },
-  } as const,
-})
-
-/**
- * A stable class handle for hosts that hook badges from CSS. Styling lives in
- * the tokens; this only names the variant.
- */
-export const badgeVariants = ({ variant }: { variant?: BadgeVariant | null } = {}) =>
-  `badge badge-${variant ?? 'default'}`
-
-/**
- * Typed as span props because that is the contract every existing call site was
- * written against; the leftovers are handed to gui, which forwards unknown props
- * to the host element on web and drops them on native.
- */
-export type BadgeProps = React.ComponentProps<'span'> & {
-  variant?: BadgeVariant | null
-  asChild?: boolean
-}
-
-export function Badge({
-  className,
-  variant = 'default',
-  asChild = false,
-  children,
-  ...props
-}: BadgeProps) {
-  return (
-    <BadgeFrame
-      data-slot="badge"
-      data-variant={variant}
-      variant={variant ?? 'default'}
-      asChild={asChild}
-      render={asChild ? undefined : 'span'}
-      {...touch(HEIGHT, MIN_TOUCH, 'y')}
-      className={[badgeVariants({ variant }), className].filter(Boolean).join(' ')}
-      {...(props as React.ComponentProps<typeof BadgeFrame>)}
-    >
-      {asChild ? children : ink(children, BadgeText)}
-    </BadgeFrame>
-  )
-}

pkg/ui/src/backends/gui/button.tsx

@@ -1,231 +0,0 @@
-'use client'
-
-/**
- * Button — the gui-backend original.
- *
- * `variant`, `size`, `asChild`, `isLoading`, `buttonVariants`, and the
- * `data-slot`/`data-variant`/`data-size` markers.
- *
- * The substrate is @hanzo/gui's Button FRAME (`Button.Frame`), not the compound
- * `Button`. The compound is `Frame.styleable(...)`, i.e. an HOC — `styled()` over
- * it does not compile style props to classes, so under `asChild` every variant
- * style leaked onto the child as an invalid lowercase HTML attribute
- * (`backgroundcolor="var(--background)"`) and nothing was styled. Extending the
- * frame keeps one component with one API and makes `asChild` a first-class
- * pattern; the frame already renders a real `<button>` on web and provides the
- * styled context that `Button.Text` reads.
- *
- * Type size rides on that Text, never on the frame: `fontSize` is not a frame
- * style prop, so setting it there leaked a `font-size="var(--f-size-3)"`
- * attribute and every size rendered at the same 16px.
- *
- * The 44px touch floor comes from `touch()`, which is platform-correct on web
- * as well as native — visual density stays at 36/32/40px.
- */
-import { Button as GuiButton, Spinner, styled } from '@hanzo/gui'
-import { createElement, isValidElement, type ComponentProps, type ReactNode } from 'react'
-
-import { ink } from './ink'
-import { touch } from './gesture'
-
-export type ButtonVariant =
-  | 'default'
-  | 'destructive'
-  | 'outline'
-  | 'secondary'
-  | 'ghost'
-  | 'link'
-  | 'primary'
-  | 'linkFG'
-  | 'linkMuted'
-
-export type ButtonSize = 'default' | 'sm' | 'lg' | 'icon' | 'icon-sm' | 'icon-lg'
-
-const HEIGHT: Record<ButtonSize, number> = {
-  default: 36,
-  sm: 32,
-  lg: 40,
-  icon: 36,
-  'icon-sm': 32,
-  'icon-lg': 40,
-}
-
-/** Type scale per size — applied to the Text host, which is what renders it. */
-const TYPE: Record<ButtonSize, string> = {
-  default: '$3',
-  sm: '$2',
-  lg: '$3',
-  icon: '$3',
-  'icon-sm': '$2',
-  'icon-lg': '$3',
-}
-
-const Frame = styled(GuiButton.Frame, {
-  name: 'Button',
-  items: 'center',
-  justify: 'center',
-  gap: '$2',
-  shrink: 0,
-  rounded: '$3',
-  borderWidth: 1,
-  borderColor: 'transparent',
-  cursor: 'pointer',
-
-  variants: {
-    variant: {
-      // The unmarked case is QUIET: a control on the surface ladder, hairline
-      // border, hover brightens border more than fill. `default` used to be the
-      // same value as `primary` (white filled), so every unstyled <Button> in
-      // every app shouted — the loudest treatment must be asked for by name.
-      default: {
-        bg: '$color2',
-        color: '$color12',
-        borderColor: '$borderColor',
-        hoverStyle: { bg: '$color3', borderColor: '$color6' },
-      },
-      // The strongest control WITHOUT a white slab — the macOS dark pushbutton:
-      // an elevated gray fill, white text, hairline. On an otherwise quiet page
-      // this IS the loudest thing; a $color12 fill read as a glare, not a CTA.
-      primary: {
-        bg: '$color5',
-        color: '$color12',
-        borderColor: '$color6',
-        hoverStyle: { bg: '$color6', borderColor: '$color7' },
-      },
-      destructive: { bg: '$red9', color: '$white1', hoverStyle: { opacity: 0.9 } },
-      outline: {
-        bg: '$background',
-        color: '$color12',
-        borderColor: '$borderColor',
-        hoverStyle: { bg: '$color3' },
-      },
-      secondary: { bg: '$color4', color: '$color12', hoverStyle: { opacity: 0.8 } },
-      ghost: { bg: 'transparent', color: '$color12', hoverStyle: { bg: '$color3' } },
-      link: { bg: 'transparent', color: '$color12', hoverStyle: { textDecorationLine: 'underline' } },
-      linkFG: { bg: 'transparent', color: '$color12', hoverStyle: { textDecorationLine: 'underline' } },
-      linkMuted: {
-        bg: 'transparent',
-        color: '$color11',
-        hoverStyle: { color: '$color12', textDecorationLine: 'underline' },
-      },
-    },
-    size: {
-      // minHeight, NOT height. A control has to be a predictable size, and it
-      // still is: text at this type scale is shorter than the box, so every
-      // ordinary Button renders at exactly these numbers. What changes is the
-      // failure: a pinned `height` CLIPS anything taller, which is how a 119px
-      // thumbnail shipped rendered as a 30px sliver with a green build. A floor
-      // cannot clip — the button grows and the mistake is visible immediately
-      // instead of silently cropping content.
-      //
-      // Same for the icon sizes' width: a floor keeps them square without
-      // truncating a child that is wider than the box.
-      // `height: 'auto'` + `minHeight`, and BOTH halves are load-bearing.
-      //
-      // minHeight alone is not enough: dropping `height` lets GuiButton.Frame's
-      // own size variant supply one (measured: 44px), which re-pins the box and
-      // ALSO makes every ordinary button 8px taller. `height: 'auto'` is what
-      // turns that off, and minHeight is what keeps the control its designed
-      // size once it is off.
-      //
-      // Together: text is shorter than the floor, so an ordinary Button still
-      // measures exactly these numbers. Anything taller GROWS instead of being
-      // cropped — a pinned height is how a 119px thumbnail shipped rendered as
-      // a 36px sliver with a green build. Both directions are asserted in
-      // consumer.spec.ts, because getting one right and the other wrong is
-      // exactly what happened on the first attempt.
-      default: { height: 'auto', minHeight: HEIGHT.default, px: '$4' },
-      sm: { height: 'auto', minHeight: HEIGHT.sm, px: '$3', gap: '$1.5' },
-      lg: { height: 'auto', minHeight: HEIGHT.lg, px: '$6' },
-      icon: { height: 'auto', minHeight: HEIGHT.icon, width: 'auto', minWidth: HEIGHT.icon, px: 0 },
-      'icon-sm': { height: 'auto', minHeight: HEIGHT['icon-sm'], width: 'auto', minWidth: HEIGHT['icon-sm'], px: 0 },
-      'icon-lg': { height: 'auto', minHeight: HEIGHT['icon-lg'], width: 'auto', minWidth: HEIGHT['icon-lg'], px: 0 },
-    },
-    disabled: {
-      true: { opacity: 0.5, pointerEvents: 'none', cursor: 'default' },
-    },
-  } as const,
-
-  defaultVariants: { variant: 'default', size: 'default' },
-})
-
-/**
- * A stable class handle for hosts that hook buttons from CSS. Styling lives in
- * the tokens; this only names the variant and size.
- */
-export const buttonVariants = ({
-  variant,
-  size,
-  className,
-}: { variant?: ButtonVariant | null; size?: ButtonSize | null; className?: string } = {}) =>
-  // Variant and size share the `btn-` namespace, so the two defaults collide on
-  // `btn-default`. A Set emits it once; no name is used by both a variant and a
-  // size, so nothing else can merge.
-  [...new Set([`btn`, `btn-${variant ?? 'default'}`, `btn-${size ?? 'default'}`, className].filter(Boolean))]
-    .join(' ')
-
-export type ButtonProps = Omit<ComponentProps<typeof Frame>, 'variant' | 'size' | 'children'> & {
-  variant?: ButtonVariant | null
-  size?: ButtonSize | null
-  isLoading?: boolean
-  children?: ReactNode
-  /**
-   * The DOM tooltip. Already reached the element -- every unrecognised prop is
-   * spread onto Frame, which forwards it -- but the Frame's props come from the
-   * cross-platform stack and name no DOM attribute, so passing it did not type.
-   * Callers either dropped the tooltip or re-declared the whole component as
-   * `any`, and the second hides every real error in the file.
-   *
-   * Declared here because it is true on web and harmless elsewhere: native
-   * ignores an attribute it does not know. Widening the type to match the
-   * behaviour beats asking ~60 call sites to work around it.
-   */
-  title?: string
-  /**
-   * The DOM button type. Not cosmetic: inside a form the default is "submit",
-   * so a control meant to do something else submits the form instead. Callers
-   * write type="button" to stop that, and dropping it would be a real bug
-   * rather than a lost attribute. Reaches the element the same way title does.
-   */
-  type?: 'button' | 'submit' | 'reset'
-}
-
-function Button({
-  className,
-  variant = 'default',
-  size = 'default',
-  asChild = false,
-  isLoading = false,
-  disabled,
-  children,
-  ...props
-}: ButtonProps) {
-  const resolved = size ?? 'default'
-  // gui's own `asChild` cannot merge into the child here: the Button frame bakes
-  // a `render: <button>`, so asChild WRAPS the child in a button and drops every
-  // compiled style (measured: `<button class="is_View "><a>…</a></button>`).
-  // `render` is the mechanism that merges — it emits the child's own tag carrying
-  // the full compiled class list. So asChild is expressed through render, and
-  // Button-as-link comes out as a styled <a> with valid markup.
-  const host = asChild && isValidElement(children) ? children : null
-  const body = host ? (host.props as { children?: ReactNode }).children : children
-  return (
-    <Frame
-      data-slot="button"
-      data-variant={variant ?? 'default'}
-      data-size={resolved}
-      variant={variant ?? 'default'}
-      size={resolved}
-      render={host ? createElement(host.type, { ...(host.props as object), children: undefined }) : undefined}
-      disabled={disabled || isLoading}
-      {...touch(HEIGHT[resolved], 44, 'y')}
-      className={buttonVariants({ variant, size, className })}
-      {...props}
-    >
-      {isLoading && <Spinner size="small" />}
-      {ink(body, GuiButton.Text as never, { fontSize: TYPE[resolved] })}
-    </Frame>
-  )
-}
-
-export { Button }