The Vulpine site
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.
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):
- 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.
- 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 onedocs/voice-commands.mdlists 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). - 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 islandsrc/hex/HubLoop.tsxpresses 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. - 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. - 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. Onlysttandttstake 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. - 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.
-
/privacyis 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/inpublic/fonts/oxanium/, beside itsOFL.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.wasmisapps/orb-stylesbuilt for the browser (itswebfeature, a C-ABI inapps/orb-styles/src/web.rs, no binding generator).src/orb/registry.tsruns 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.tsasks the module for a style’s whole WGSL and draws it with the browser’s WebGPU: one triangle, the uniform block, the noise field, asapps/orb-styles/src/render.rsdoes natively. Each frame’s uniform block comes from the crate’sOrbFace, 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:
buildon a build host: the pinned GPUI toolchain,wasm32-unknown-unknown, the copy’s path remapped so no home folder is in the bytes;adoptcopies the module in and writessrc/orb/orb_web.json(its sha256 and a hash of the sources it was built from);stillsencodes the pictures and writes theirmedia.jsonrows;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.wasmisapps/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 isaria-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 bytools/apps/panel_web_stills.mjs, each amedia.jsonrow 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 ownbun.lockifnode_modulesis missing, typechecks (tscoversrc/*.ts), builds intodist/(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,.localnames, 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 scansapps/site,dist/included. It skipsnode_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 bysrc/pages/index.astroat build time. Unset or empty, the page says the source is not public yet. Anything but anhttps://URL fails the build. It is a site build input, not a runtime variable, sovulpine-env.tomldoes not declare it.- The site is outside the root Bun workspace (
"!apps/site"in the rootpackage.json), so its Astro install (about 150 MB) does not land in every checkout’s root install. - The site’s
bun.lockis written by the repo’s mise-pinned Bun (mise.toml), so the frozen install works in a fresh checkout and in CI. Regenerate it withmise exec -- bun installinapps/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
sha256does not match the bytes, so a re-encode needs a new review; - an empty
reviewed_byorsource_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:
- Record it silently from a showcase (no gateway, no household data) with the recording recipe.
- Encode it to mp4 and webm, with a poster, each under 4 MB.
- Have the operator review every frame.
- Add the rows with that
reviewed_by, runjust 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.tscallssrc/og.ts, which measures the mark’s path (src/mark.ts, the same outline aspublic/favicon.svg) with a scanline rasterizer, paints discs and writes the PNG withnode:zlib. No image library and no new package. The same source gives the same bytes. It exists only indist/, so it needs no media row./og/talk.png,/og/fun.pngand/og/privacy.png, the same card with that page’s label and line (PAGE_CARDSinsrc/seo.ts;src/pages/og/[card].png.ts). A page without a row shows/og.png./sitemap.xml, everysrc/pages/*.astrobut 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.