---
title: "The Vulpine site"
description: "Vulpine's landing page: a static Astro page whose three numbers are rebuilt from receipts, its build and naming-lint recipes, the Vercel config, and whether Blume 2.0.3 can deploy the docs to Vercel. The docs' Vercel preview is built by `just docs::docs-site-build-vercel`; both projects are previews only and the orchestrator deploys them."
type: "living"
source: "apps/site/README.md"
verified: "2026-11-14"
group: "Adapters and integrations"
---

> **Living doc**, checked against the code 2026-11-14

Vulpine's public face: one static Astro page beside the docs, a specification sheet in ink, paper and orange. The
page has a light and a dark theme from `prefers-color-scheme`. It uses the system font stack, plus one self-hosted OFL
face (Oxanium) for the sheet's labels, the page's small caps and its numerals. It has no analytics, no third-party
fonts and no third-party scripts. Its only script is Astro's island runtime and its React islands (section
"Motion"). It is not a Blume page: Blume is the docs' shape.


## The page

In order (`src/pages/index.astro`):

1. **The hero.** The promise, two actions, five status lines, and Vulpi as a screen of dots. A ripple, one ring of
   swollen dots, leaves the fox's ear when the pointer comes over it, on a tap, and by itself every few seconds.
2. **01 / The turn: two ways to answer.** The page's center. A spoken turn has two ways, and both wait for the
   commit. A turn the gateway matches to one of its own verbs starts no brain turn and is answered as soon as the
   voice starts. Every other turn falls back to the brain and pays its first token. The section has one focal point:
   a fork whose one filled block asks "Is it a verb?", with the two ways out drawn to one scale from the commit on
   and a cursor crossing each in real time. Under it is what a verb is, in things you can say
   (`src/turn/says.json`; every phrase is one `docs/voice-commands.md` lists on that side). One caveat stays in the
   open under the fork: no verb turn has been timed whole. The legs' receipts, the other caveats and the decision
   model are three disclosures. The model is asked while you speak, the turn never waits for it, and it routes one
   thing (the drop gate, ADR 0062).
3. **02 / One hub** (`src/hex/HexHub.astro`): the gateway in a hexagon with a lane on each corner, its clients on one
   side and the house on the other. It plays four kinds of event one after another, each by its own route
   (`src/hex/lanes.ts`, `EVENTS`): a verb turn (never Think), a brain turn, a camera event that starts in the house,
   and a fleet task where the fleet expands under its port. An event is a radio button, and everything it draws is
   CSS under that radio, so with no script a pick plays once. The island `src/hex/HubLoop.tsx` presses the next
   radio and adds Pause. It stops off screen, on a hidden tab and under reduced motion, which shows the picked
   event's finished route, still. The lanes and their hardpoints are a disclosure under it.
4. **03 / Within reach** (`src/hex/HexHouse.astro`): the house as a honeycomb floor, with four stories: the lights
   (a verb, nothing leaves), a question (the one dashed line out to the brain), the door camera, the fleet.
5. **04 / Hardpoints**: first what a minimal install is (a Mac and the agent you already run; Vulpine downloads its
   own speech recognition and voice, sizes from `docs/install.md`), then the socket board
   (`src/tape/hardpoints.json`, the slots of ADR 0059). Each slot says what is **included** and what you may
   **swap in**. Only `stt` and `tts` take a swap, and each swap named is one the contract's built transports allow.
   The decision model is optional and off by default; the brain is not included.
6. **05 / Surfaces** (`src/surfaces.json`), **06 / Not included**, **07 / Install**, **08 / Questions**
   (`src/faq.json`), and the footer: the wordmark in outline, filled with a screen of dots.

The hexagon pieces use the page's own tokens (`src/hex/hex.css` reads `--paper`, `--ink`, `--orange`).
`src/hex/lanes.ts` holds the lanes, the two routes and the clients.


### Names

Things are named by platform and role, never by a look's or a crate's name. The two looks are "names inside settings
... never app names" (`CONTEXT.md`, "Vulpine.app / Vulpine Gateway.app"):

| on the page | what it is | the name's source |
|---|---|---|
| Vulpine.app, the desktop app | the Mac client | `apps/glyph/src-tauri/tauri.conf.json` `productName`; `docs/naming.md` |
| Vulpine in a browser, the web app | the browser client | `CONTEXT.md` (a look is not an app name) |
| Vulpine Gateway.app, the host | the app that holds the gateway and draws the operator's window | `apps/admin-shadow/bundle.json` `name` |
| a room speaker (a puck) | the room satellite | `apps/satellite-esphome/README.md` |
| Vulpine on iPhone, in development | the phone app | `apps/phone/Info.plist`; `docs/design/phone-ios-mvp-2026-11-09.md` |
| Pi | the supported agent runtime | capitalised in everything a reader sees; `pi` stays the command's and the code's spelling |

`tests/test_site_names.py` refuses an internal name, and a lower-case `pi`, in the landing's sources and the built
page's text. A docs URL may still carry one: the docs site's routes are the repo's paths.

## The other pages wear the landing's sheet

`/talk`, `/fun`, `/privacy` and the not-found page share the landing's ink, paper and orange. `src/styles/theme.css` carries
the landing's tokens and the frame's rules (labels in Oxanium, the dashed section edges, the plate's registration
corners, the dotted wordmark footer). `src/components/SiteTop.astro` and `SiteFoot.astro` are their header and footer.
The landing writes the same tokens in its own page; `tests/test_site_sheet.py` holds the two equal in both themes.

- `/privacy` is one ledger: six numbered rows, each with its paragraph and the docs page behind it, and a summary
  that repeats only what the rows say.
- The not-found page answers in the landing's fork: "Is it a page? No." beside four ways out. No script.


- The labels are set in Oxanium (SIL Open Font License 1.1, no Reserved Font Name): a byte-identical copy of
  `apps/glyph/src/fonts/oxanium/` in `public/fonts/oxanium/`, beside its `OFL.txt`. Page text stays on the system
  stack.

## Fun: the orb's faces, live

`/fun` shows the orb the desktop app draws, in the styles its picker offers before Labs is on, and draws the picked
one live. Nothing on it is a mock or a recording:

- **The faces come from the crate.** `src/orb/orb_web.wasm` is `apps/orb-styles` built for the browser (its `web`
  feature, a C-ABI in `apps/orb-styles/src/web.rs`, no binding generator). `src/orb/registry.ts` runs that module in
  node at build time and reads the registry, so every name and note on the page is the crate's own text.
- **The shader is the crate's.** `src/orb/engine.ts` asks the module for a style's whole WGSL and draws it with the
  browser's WebGPU: one triangle, the uniform block, the noise field, as `apps/orb-styles/src/render.rs` does
  natively. Each frame's uniform block comes from the crate's `OrbFace`, running in the module.
- **Without WebGPU, or without script, the page shows stills.** Two radio groups pick a face and a state; one CSS
  rule a pair shows that pair's picture from `public/media/orbs/` (32 pictures, drawn by the crate's own headless
  example on a build host, plus 8 thumbnails). The island (`src/orb/OrbLive.tsx`) puts a canvas in their place; live,
  no still is fetched.
- **No microphone.** Left alone the island plays a made-up turn by pressing the state buttons in order; the two
  levels are a speech-shaped curve (the crate's example draws its pictures from the same one). A person's pick stops
  the turn. An idle face settles and then asks for no frame, as in the app; the counter under the face says so.
  Under reduced motion no turn plays and the crate draws its own still face.

The module is committed because the Vercel build has no cargo. When `apps/orb-styles` or `apps/motion-core` changes,
build it again with `tools/apps/orb_web_build.py`:

- `build` on a build host: the pinned GPUI toolchain, `wasm32-unknown-unknown`, the copy's path remapped so no home
  folder is in the bytes;
- `adopt` copies the module in and writes `src/orb/orb_web.json` (its sha256 and a hash of the sources it was built
  from);
- `stills` encodes the pictures and writes their `media.json` rows;
- `check` (no cargo) refuses a module that is not the stamp's, a crate that changed since the build, another
  toolchain or a home path. `check --built <dir>` compares a fresh build byte for byte.

On 2026-11-14 the module was 315,308 bytes (112,019 gzip). In headless Chrome (WebGPU on Metal, a 1030 px canvas at a
2x display) each of the eight faces held 60 frames a second while speaking, with no frame over 20 ms in 4 s; an idle
face drew none. Six of the eight faces are ports of orbkit's MIT originals. Its notice is served at
`/licenses/orbkit.txt`, a byte copy of `apps/orb-styles/LICENSE-orbkit`.

Under the roster, "Make your own orb look" links the docs guide `docs/make-your-own-orb-look.md`: the style contract
in plain words, and the `make-orb-look` skill an agent can follow.

`media.json` binds the brand icon exports' privacy review to their exact file hashes.


## Talk: the conversation panel and the reply cards, live

`/talk` shows the conversation window Vulpine.app opens and the cards a reply can show, drawn by the app's own
interface code. Nothing on it is a mock or a
recording:

- **The screen is GPUI.** `src/panel/panel_web_bg.wasm` is `apps/panel-web`: the
  conversation panel (`apps/convo-panel`, the component the Mac window and the phone share) and the reply cards
  (`apps/native-cards`, card.v1) linked by path and built for the browser on the fork's web platform, one module
  on one canvas (WebGPU where the browser has it, else WebGL2).
- **It replays a written conversation.** `src/panel/script.json`: three made-up turns (a spoken question with a
  tool call and a card, a spoken verb the gateway runs by itself, a typed question with a card). The module
  compiles that file in, and the page writes its transcript from the same file (`src/panel/replay.ts`), so the
  words beside the canvas are the words in it. A canvas says nothing to a screen reader; the transcript is the
  accessible form, and the canvas is `aria-hidden`.
- **Two stories on the one canvas.** The conversation, with the card each reply shows landing in a rail beside the
  panel on a screen 56rem or wider (the panel alone below that); and All the cards, the app's card gallery
  (`src/panel/cards.json`, a byte copy of the file the native gate draws) a page at a time, in the cards' three
  looks.
- **The module is never in the page.** The island (`src/panel/PanelLive.tsx`, `client:visible`) imports
  wasm-bindgen's glue and fetches the module only when the screen is at least a quarter in view, or on Play it
  live. Until then, with no script and under Reduce Motion (where nothing loads by itself), the screen is a still:
  the module's own last frame at the page's two boxes (`public/media/panel/`, captured from the built page by
  `tools/apps/panel_web_stills.mjs`, each a `media.json` row that names the module it is a frame of). The replay
  holds off screen and on a hidden tab; a stage at rest asks for no frame. No other page references the module.
- **The page scrolls over it.** GPUI's web platform puts its canvas, a hidden text field and four probes on
  `<body>`; the island moves the canvas into the screen as it appears and takes all of them out of the tab order
  and the accessibility tree. The canvas takes no pointer: it is a replay, and a canvas that swallowed the wheel
  would trap the page.
- **No microphone, no request.** The module asks for no device and opens no connection; the page fetches its own
  module and nothing else.
- **The page never moves under the screen.** The bar under the screen keeps one height in every state: the live
  controls are always laid out (hidden and inert until the screen is live), Play shares their place, and the
  status line keeps two lines. The canvas comes up over the still. Play is drawn only once the island runs, so a
  reader without script sees no button that does nothing. A browser that reports a data saver loads nothing by
  itself. If the module does not arrive or cannot draw, the still stays and the line says so. On 2026-11-14 the
  bar measured 139.4 px at 390 px wide and 85.8 px at 1280 px in all six states (no script, loading, refused,
  live, Reduce Motion, data saver); before, it grew 79 px on a phone when the screen went live.

The module is committed because the Vercel build has no cargo. `tools/apps/panel_web_build.py` is the recipe
(`build` on a build host, `adopt`, `stills`, `check`); `tests/test_panel_web_build.py` runs the check and its
refusals, and `tests/test_site_talk.py` holds the transcript to the script, the stills to the manifest and the
island to its rules. When `apps/convo-panel`, `apps/native-cards`, `apps/panel-web`, the script or the fork pin
changes, build the module again and recapture the stills.

On 2026-11-14 the module was 9,988,367 bytes: 3,335,020 at gzip level 9 (the size the page states) and 2,377,521
at brotli -q 11; the faces inside it are 226,752 bytes, cut from 1,799,676. The figures after this are of the day's
earlier build (9,957,036 bytes, which the preview host's own brotli sent as 3,155,836). On a laptop (an M3) the replay held the display's 60 frames a second in WebKit (Playwright's, headless) and in Chrome 157 (a real window at scale 2), on WebGPU and on WebGL2 alike, with no frame gap over 63 ms in 6 s; the first frame came 52 to 432 ms after the module started. The
receipt is `benchmarks/results/talk-page-panel-web-2026-11-14.md`.

The text in the canvas is Inter and JetBrains Mono (SIL Open Font License 1.1, no Reserved Font Name); their
licenses are served at `/licenses/inter-ofl.txt` and `/licenses/jetbrains-mono-ofl.txt`, byte copies of
`apps/native-cards/fonts/`.

## Motion

The site's scripts are React islands. Each island hydrates `client:visible` (never `client:load` or `client:only`),
so a page reads whole before any script runs:

| where | island | what it does | under reduced motion |
|---|---|---|---|
| the landing's hero plate | `src/tape/Halftone.tsx` | Vulpi resampled as a dot screen on a canvas; a ring leaves the ear when the pointer comes over the fox, on a tap and every few seconds, and the dots under the pointer swell; nothing is drawn between rings; original code, no library; the plain `vulpi.svg` image is in the HTML first | one still frame, no ring |
| the landing's hub | `src/hex/HubLoop.tsx` | presses the hub's next event radio when one ends, and adds Pause; one timer per event, nothing per frame; stops off screen and on a hidden tab; original code | no loop; the picked event's finished route |
| the stage on `/fun` | `src/orb/OrbLive.tsx` | the picked orb face drawn live on a WebGPU canvas by the crate's shader and driver (wasm); plays a made-up turn; a face at rest draws no frame; stops off screen and on a hidden tab; the stills stay where there is no WebGPU; original code | the crate's own still face, no turn |
| the screen on `/talk` | `src/panel/PanelLive.tsx` | swaps the still for GPUI's canvas (the conversation panel and the reply cards, one wasm module) and replays the written conversation; fetches the module only when the screen is in view or on Play; holds off screen and on a hidden tab; a stage at rest draws no frame; original code | nothing loads by itself: the still stays, and Play is the reader's choice |

Everything else that moves on the landing is CSS inside `@media (prefers-reduced-motion: no-preference)`: the fork's
two cursors, the hub's events and the house's stories (radio buttons and `:has()`). The cursors' keyframes are written
at build time from the claims, so each crosses in its way's own time.

`src/motion/` is a byte-for-byte copy of `packages/vulpine-motion/` (React Bits components, MIT + Commons Clause,
`src/motion/LICENSE.react-bits.txt`): `Tilt`, `Counter`, `Spotlight` and `Threads`. No page uses them, so no bundle
carries them. The copy stays because the Vercel deploy copies `apps/site` alone. Change the package, then copy the
file; `tests/test_site_motion.py` refuses a copy that differs.

The same test pins the build: every inline script is one of Astro's own prebuilt island scripts, no `<script src>`,
island bundles only from `/_astro/`, no inline event handler, no inline style that hides content, and the JavaScript
per page under its budget. On 2026-11-14 the landing had 2 islands, 199,633 bytes (64,208 gzip), of which React 19 is
about 187 KB; `/fun` had 1 island; `/talk` 1 island; the 404 and privacy pages none.

What a first visit fetches before any scroll, at gzip level 9, on 2026-11-14: the landing 56,557 bytes at 390 px
wide (the page, the label face and the fox) and 119,966 at 1280 px (the hero's island and React with it); `/fun`
76,811 and 141,903; `/privacy` 29,113; the not-found page 28,062; `/talk` about 3,498,000 at 390 px, of which the panel
module is 3,335,032 and everything else about 163,000. The first contentful paint came 24 to 52 ms after navigation from
a local server in headless Chromium, which measures the page's own work and no network.

## The numbers come from receipts

`src/claims.json` is written by `python3 tools/docs/site_claims.py` from named receipts under `benchmarks/results/`:
a JSON pointer, a Markdown table row and column (and which number in the cell), or a pattern over a receipt's
prose. The page renders that file and nothing else. `just apps::site-build` runs `site_claims.py --check` first, so a
number typed into the JSON fails the build. A claim in a time unit also carries `ms`, its unrounded length, which the
rulers are drawn from. When a receipt moves, change the claim's entry in `CLAIMS` and rerun the tool. On 2026-11-14:

| claim | number | receipt |
|---|---|---|
| `commit`: speech end to commit, median of 218 live turns | 978 ms | `brain-ttft-cloud-vs-local-2026-11-06.json` |
| `verb-match`: the phrase match at the commit, per call (an unoptimized build) | 8.6 µs | `page-verb-cost-20261107.md` |
| `voice`: the voice worker's first audio after 5 s to 1 min of quiet, median of 457 | 140 ms | `tts-idle-ttfa-2026-11-07.json` |
| `brain-first-token`, `brain-first-token-p90`: commit to a hosted brain's first token, 218 live turns | 1.4 s, 3.8 s | `brain-ttft-cloud-vs-local-2026-11-06.json` |
| `brain-to-audio`: first token to first audio, the same turns | 441 ms | the same |
| `brain-turn`: speech end to audible, traced whole, 209 live turns | 3.0 s | the same |
| `decision`: the decision model's answer on the home Mac's Neural Engine, median of 213 live asks | 682 ms | `decision-route-order-2026-11-05.md` |
| `verb-turns`, `brain-turns`: one week of live turn outcomes | 14, 216 | `decision-weekly-scorecard-2026-11-07.md` |
| `early-starts`, `commits`: brain turns dispatched before the commit | 117 of 229 | `brain-ttft-cloud-vs-local-2026-11-06.json` |


## Build and check

- `just apps::site-build`: checks the claims, installs from the site's own `bun.lock` if `node_modules` is missing,
  typechecks (`tsc` over `src/*.ts`), builds into `dist/` (gitignored) and runs the naming lint.
- `just apps::site-check`: the naming lint alone (`tools/docs/site_check.py`). It refuses the retired compatibility
  name, the private repo and private tree names, the voice corpus, the archive volume, fleet hosts, `.local` names,
  private, CGNAT and tailnet addresses, home-folder paths, and the household names in the private list
  (`$VULPINE_PRIVATE_ROOT/site/denylist.txt`, one per line, never in git). It scans `apps/site`, `dist/` included.
  It skips `node_modules/` and this README, because the README describes the repo and is not served. The same
  command runs the media guard (next section).
- `VULPINE_SITE_SOURCE_URL` (build flag, optional): the public source URL for the install section's source link,
  read once by `src/pages/index.astro` at build time. Unset or empty, the page says the source is not public yet.
  Anything but an `https://` URL fails the build. It is a site build input, not a runtime variable, so
  `vulpine-env.toml` does not declare it.
- The site is outside the root Bun workspace (`"!apps/site"` in the root `package.json`), so its Astro install (about
  150 MB) does not land in every checkout's root install.
- The site's `bun.lock` is written by the repo's mise-pinned Bun (`mise.toml`), so the frozen install works in a fresh
  checkout and in CI. Regenerate it with `mise exec -- bun install` in `apps/site`, never with a newer Bun: the pinned
  Bun cannot read a newer lock format.


## Wayfinding and keyboard access

The hero has two actions: **Install it** (the orange button, to the install heading) and **See how fast it
answers** (to the turn's heading).
The page works at 320 to 1920 px in both themes, with no sideways scroll. Section headings accept native fragment
focus (`tabindex="-1"`). The first keyboard stop is **Skip to content**: it shows on focus and moves focus to `main`.
Header navigation is named **Main** and the footer's **Footer**. Their links have a `--target` minimum of 2.75rem
(44px at the default type size). The receipts and the questions are native disclosures. The hub's events and the
house's stories are native radio buttons, and Pause is a button.

To check it, serve `dist/` locally and run `node tests/site_readability.browser.cjs` from the repository root with
`playwright-core` available. `SITE_URL` overrides its default `http://127.0.0.1:4319/`; `BROWSER` picks `webkit` (the
default) or `chromium`; `BROWSER_EXECUTABLE` selects an installed runner; `RECEIPT_DIR` saves the JSON result and
full-page screenshots. It is not a screen-reader audit or a deployed-host check.


## How a demo lands

A clip, a still or a poster goes in `public/media/` and lands only with its row in `media.json`. The lint cannot read
pixels, so a person must look at every frame before the row is committed. A row has five fields:

| field | what it holds |
|---|---|
| `file` | the path under `public/`: `media/<name>` for demos, or one of the seven canonical root web-app icons |
| `sha256` | the file's sha256 in lowercase hex (`shasum -a 256 public/media/<name>`) |
| `source_recipe` | the command that made the file from the repo, or an honest committed-export reference when the original command is unavailable |
| `reviewed_by` | who watched every frame for household names, private text, hosts or addresses, and when; never empty |
| `poster` | `null`, or the `file` of another row (the still a `<video>` shows before it plays) |

`just apps::site-check` (and so `just apps::site-build`) refuses each of these:

- a media file anywhere under `public/` without a row;
- a row whose `sha256` does not match the bytes, so a re-encode needs a new review;
- an empty `reviewed_by` or `source_recipe`;
- a row without its file, a duplicate row, an unknown root filename, an absolute/traversing path, a symlink escape from `public/`, or a poster with no row of its own;
- any file under `public/` over 4 MB.

The root icon set is explicit: `android-chrome-192x192.png`, `android-chrome-512x512.png`, `apple-touch-icon.png`,
`favicon-16x16.png`, `favicon-32x32.png`, `favicon-48x48.png` and `favicon.ico`. These icons still need review, a
hash, the privacy check and the size check. No other root image is admitted.

The order for a demo:

1. Record it silently from a showcase (no gateway, no household data) with the recording recipe.
2. Encode it to mp4 and webm, with a poster, each under 4 MB.
3. Have the operator review every frame.
4. Add the rows with that `reviewed_by`, run `just apps::site-check`, and commit the files and the rows together.

A file that fails review is deleted and never committed. The `.svg` mark is text, so the naming lint reads it and it
needs no row. No page shows a clip or a still now.


## Page meta

Every page puts `<Meta title="…" description="…" />` (`src/components/Meta.astro`) in its `<head>`. It writes the
title, the description, the canonical URL on the configured `site` host, the Open Graph and Twitter tags, the icon and
the sitemap link. A page in `UNLISTED` (`src/seo.ts`, the 404) gets a robots noindex instead of a canonical URL.

The label face never swaps. `Meta.astro` preloads Oxanium and its `@font-face` is `font-display: optional`: a page
is drawn once, in whichever face is ready, so no label moves after the first paint. On 2026-11-14 every page
measured a layout shift of 0 at load in Chromium at 390, 768, 1280 and 1920 px, in both themes (it was 0.0001 to
0.0017 while the face swapped). On a first visit over a slow link the labels can stay in the fallback monospace
for that one page view.

The build makes these files from code, so none is committed:

- `/og.png`, the 1200 x 630 social card in the sheet's colors: the name and one line in a 5 x 7 dot matrix on
  paper, and the mark as a screen of dots on an orange plate. `src/pages/og.png.ts` calls `src/og.ts`, which
  measures the mark's path (`src/mark.ts`, the same outline as `public/favicon.svg`) with a scanline rasterizer,
  paints discs and writes the PNG with `node:zlib`. No image library and no new package. The same source gives the same bytes. It exists only in `dist/`,
  so it needs no media row.
- `/og/talk.png`, `/og/fun.png` and `/og/privacy.png`, the same card with that page's label and line
  (`PAGE_CARDS` in `src/seo.ts`; `src/pages/og/[card].png.ts`). A page without a row shows `/og.png`.
- `/sitemap.xml`, every `src/pages/*.astro` but the unlisted ones. A new page joins it by existing.
- `/robots.txt`, which allows everything and names the sitemap.

`public/site.webmanifest` names the two Android icons and wears the sheet's paper.

`src/pages/404.astro` builds `dist/404.html`, which Vercel serves for any missing path. `just apps::site-check`
reads the build when there is one (`check_meta`). It refuses a page without the set, an image tag that is not an
absolute https URL to a file in the build, a canonical URL that names another route, a missing 404, and a sitemap
that leaves out an indexed page or lists anything else.

## Deploying

`vercel.json` describes a static deploy. Vercel runs `bun install --frozen-lockfile`, then
`bun run typecheck && bun run build`, and serves `dist/` at `/`. Two rewrites send `/docs` and `/docs/:path*` to the
docs project, so every docs link and the MCP route under `/docs/mcp` keep their paths. Every response carries
`nosniff`, a referrer policy, a `Permissions-Policy` that refuses the camera, the microphone and location (the pages
say they open none), and `frame-ancestors 'none'`. Files under `/_astro/` are cached for a year as immutable, the
fonts and licenses for 30 days, and the cards, icons and stills for a day. `vercel.json` cannot
read environment variables, so the docs host is the placeholder `VULPINE_DOCS_HOST`. The deploy's copy carries the
host, never git: `VULPINE_DOCS_HOST=<name>.vercel.app python3 tools/docs/docs_site_vercel.py landing <new folder>`
copies the page without its build folders and fills the host in. `"git": {"deploymentEnabled": false}` keeps a push
from deploying either project.

Both projects are previews only: `vercel deploy` without `--prod`, no domain, and the landing's first production
deployment is removed. The docs project, `vulpine-docs`, deploys prebuilt: `just
docs::docs-site-build-vercel <folder>` stages, builds with `DOCS_DEPLOY=vercel` and checks the output, then
`vercel deploy --prebuilt --cwd <folder>`. Its `site/vercel.json` refuses a remote build, because Vercel has no staged
docs to build from. Vercel Authentication must be on for `vulpine-docs`: Project, Settings, Deployment Protection,
Vercel Authentication enabled, Standard Protection. With no production deployment, that protects every URL. While it
is on, the landing's `/docs` rewrite reaches the docs project's login wall, so read the docs preview on its own host.


One command per preview: `just docs::docs-site-deploy-vercel <folder>` builds the docs into the folder
and deploys them; `just apps::site-deploy-vercel <new folder>` copies the landing with `/docs` pointed at the newest
docs preview and deploys it. Both run `tools/docs/vercel_deploy.py`, which reads the team and the project names from
`site/vercel-projects.toml` and prints the whole sequence with `--dry-run`. When Vercel makes a project's first
deployment production, the tool deploys once more. It smoke-fetches the new preview (the docs at `/docs` with 200 and
`/docs/mcp` with 405, the landing at `/` with 200), and only then removes every other deployment of the project by
its id. The login gate hides the pages, so the smoke reads them only when `VERCEL_AUTOMATION_BYPASS_SECRET` holds the
project's "Protection Bypass for Automation" secret, sent as a header from inside the process. Without it, a 401 from
the gate passes as "gated": the deployment exists, and the page is unread. `vercel curl` is not used, because it puts
the secret on curl's command line and creates one when the project has none. A failed smoke removes nothing.

## Blume 2.0.3 and Vercel

Blume builds the docs as a static `dist/` for any host. `/docs` on Vercel needs Blume's server build,
`deployment: vercel({ site, base: "/docs" })`, only if the MCP route moves with the docs, since the MCP server and the
assistant need server output.

