Skip to content
Vulpine
Esc
↑↓navigate↵open⌘Jpreview
On this page

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):

  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.

Was this page helpful?