Booking specialist care, where the visual interface, a keyboard command palette, voice, and your AI agent are all callers of the same WebMCP tool registry.
Live app · Repo · Verify it yourself · Evals · Implementation · Devpost
Open the live app in Chrome 149+ with
chrome://flags/#enable-webmcp-testingenabled, or in the ChatGPT desktop app's built-in browser. Without WebMCP the site still works — the palette falls back to the local registry.
Verified end to end in Chrome (latest) with WebMCP enabled: tools register, the agent and the palette read the same registry, the full booking completes by keyboard alone, and the consent gate holds.
385 unit tests · 36 assertions against real Chrome over the DevTools Protocol · 7 adversarial evals against the live deployment
- The thesis
- The problem
- The second contribution
- How WebMCP is implemented
- The four surfaces
- Designed against the open spec issues
- Adversarial evals
- Verify it yourself
- Accessibility
- Run locally
- Architecture
- What we found in the browser
- Deliberate non-choices
- Scope
- Where this goes next · extraction plan · engineering practices
- License
Building your website for agents is how you finally make it usable by the humans your interface locked out. It is the same work, not two projects.
The web has spent twenty years bolting accessibility on after the fact, and it drifts the moment anyone ships. WebMCP changes the incentive: to serve an agent, a site must declare its capabilities as typed, described, machine-readable tools. That declaration is a semantic layer that cannot drift, because the application depends on it.
Parity takes that to its conclusion. The human command surface is not a parallel implementation of the app's features. It calls document.modelContext.getTools() — the same discovery API the agent uses — and executes through document.modelContext.executeTool(). One registry, two callers. The product name describes the call graph, not a slogan.
Not a mock-up. The browser's getTools() beside the palette's — the same list, because it is the same call.
Booking specialist care is a constraint-satisfaction problem across dimensions no booking site lets you express at once:
- a provider who takes your insurance and speaks your language
- a building that is actually wheelchair accessible, not "accessible" in the marketing copy
- an ASL interpreter booked in parallel, with lead time respected
- a slot inside your paratransit pickup window — one you can leave as well as reach
- a slot a caregiver can also attend
- extended appointment length, because fifteen minutes is not enough
- a low-sensory waiting environment
Today that is forty minutes of phone calls, or an abandoned booking.
And the people with the most constraints are disproportionately the people blocked by the interface itself — calendar grids with no keyboard path, custom dropdowns with no roles, sessions that expire mid-form. Chrome's own WebMCP documentation names date_pick as the canonical example of a control built for humans that agents cannot understand. Calendar grids are simultaneously among the most notorious accessibility failures on the web. That overlap is the entire product.
One tab stop, not 160. Arrows move, Home and End jump along the row, Enter holds, Escape leaves. The focused cell is announced.
When an agent fills a form, a screen-reader user is told nothing. The DOM mutates silently. A sighted user watches it happen; a blind user has no idea their intake form was just completed by something other than themselves.
Parity fixes this inside the standard's own primitives. Every tool execution — agent- or human-initiated — emits an aria-live announcement derived from the tool's own definition, naming the actor:
"Agent selected Dr. Amara Okafor, Neurology." "You held Tuesday 14 October, 10:30, held for 10 minutes." "Confirm booking is no longer available: the hold on the slot expired."
The wording always comes from the tool's own announce(), never from a call site, so it cannot drift from what actually happened. The same lines are rendered on screen, so a sighted user can also see that the agent changed something.
The actor is inferred, not known. executeTool() carries no caller identity: when the palette invokes a tool through the browser, the browser calls the same closure the agent's calls reach. The page marks the call it is about to make, immediately before making it, and treats anything unmarked as the agent — which errs toward overstating agent involvement rather than hiding it. That is a heuristic, and on #277 the issue author confirms caller attribution cannot be made reliable from today's executeTool() surface; it would need a provenance signal in the API or user-agent bookkeeping. We keep the announcement because knowing something other than me acted is the information a screen-reader user is currently denied entirely — but the claim is "inferred", not "known".
There is no server. No backend, no database, no MCP endpoint — a static SPA. The browser is the MCP client; the page is the server, made of JavaScript closures in a tab. Tools register with the browser on load and appear under Site tools in the address bar.
defineTool({
name: "hold_slot",
humanLabel: "Hold a slot",
group: "schedule",
description: "Place a 10-minute hold on one appointment slot …",
schema: z.object({
slot_id: z.string().describe("Slot id from get_availability"),
}),
voiceAliases: ["hold it", "reserve that slot"],
reversible: true,
available: (s) => s.stage === "provider_selected" && s.hasFetchedAvailability,
unavailableReason: (s) => ({ reason_code: "no_availability", … }),
announce: (i, r) => `held ${r.human_summary}`,
execute: ({ slot_id }, { now }) => { … },
});That single object produces: the WebMCP registration (inputSchema via Zod 4's native z.toJSONSchema()), the command palette entry (a form generated from the same schema), the voice grammar, runtime validation, the screen-reader announcement, and the audit entry. Six consumers, one definition.
Chrome's best practices warn that overlapping tools make agents choose badly. So the design is a large total surface with a small live surface: each tool carries an available(state) predicate, and the registry re-derives allTools.filter(t => t.available(state)) on every store change, registering and unregistering via AbortController.
Both surfaces observe this simultaneously. When intake completes and confirm_booking becomes legal, the agent receives a toolchange event and the human palette gains a row — from the same diff. Illegal operations are prevented by absence of registration, not by a runtime error.
| Stage | Live tools |
|---|---|
browsing, no search yet |
5 |
browsing, with results |
6 |
provider_selected, before availability |
7 |
provider_selected, availability fetched |
6 |
slot_held |
7 |
intake_complete |
7 |
booked |
5 |
Fitting nineteen tools under that cap forces every predicate into a narrow home, which is the point rather than a workaround. A test walks every reachable stage and fails if the cap is ever exceeded; the registry also throws in dev.
browsing ──select_provider──► provider_selected ──hold_slot──► slot_held
▲ ▲ │
│ └──────release_slot──────────┘
│ │ set_intake
│ ▼
└──────cancel_booking────── booked ◄──confirm_booking── intake_complete
│ ▲
└────reschedule_booking───────────┘
Three tools mutate irreversible state — confirm_booking, cancel_booking, reschedule_booking — and all three go through one gate. A bespoke gate per tool would be three places for the invariants to rot.
- No tool approves a grant. Approval exists only as page UI. There is no
approve_granttool and never will be. Two tests enforce it, one grepping the source tree. - Bound to the action — keyed to a SHA-256 of the canonicalised arguments. Change any argument and the grant is void, not reusable.
reschedule_booking's grant is bound to both ids, so an approval to move to slot B cannot be redirected to slot C. - Enforced at execution — the commit path re-validates from grant state and never trusts an earlier decision, or the tool's own annotations.
- Expiring — 120 s, then
grant_expired. No silent retry. - Consumed once — a grant that has committed cannot commit again.
readOnlyHint and untrustedContentHint are set honestly on every tool, but they are signals to the agent, never enforcement. The MCP specification warns that clients must treat tool annotations as untrusted; OpenAI's Site tools documentation states that a tool's claim it only reads data is not proof of what it does. Parity annotates truthfully and enforces independently.
The same honesty applies to the human. Provider-written prose reaches exactly one tool, and that tool returns it under a key that names its provenance — unverified_provider_description. The palette fences any unverified_* value above the verified fields rather than listing it among them, because prose the site does not vouch for should not be met in the same visual register as a fact the site asserts. The fixture's planted instruction is right there on screen, attributed, where a person can judge it:
What the page cannot do alone. Spec issue #288 records ChatGPT's browser calling a proposal-only tool on another site and then clicking that site's own Approve button. A host that is both the tool caller and a computer-use agent can complete the page's human step, and the page cannot tell that click from yours. We reproduced this against Parity — see the evals. So the gate is necessary, not sufficient. What we add: gated tools describe themselves as consequential so the host's own confirmation fires as a second layer; approval routes through requestUserInteraction() where a host provides it; every approval records delta_ms, isTrusted and input modality, with sub-second approvals flagged on-page. What we refuse to add: CAPTCHAs, hidden challenges, timing puzzles. Every anti-automation trick that would defeat #288 is an accessibility failure for the exact people this product serves. The durable fix belongs in the user agent.
| Surface | Driven by | Who it is for |
|---|---|---|
| Visual UI | React + Zustand store | sighted mouse/touch users |
Command palette (⌘K / Ctrl+K) |
getTools() → schema-generated form → executeTool() |
keyboard-only and screen-reader users |
| Voice | Web Speech API → alias + enum match → pre-filled palette | motor-impairment users |
| Agent | browser Site tools | anyone with a WebMCP browser |
The palette must be able to complete a full booking with keyboard only, no agent, no mouse. That is a definition-of-done item, and there is a test that walks it end to end with no pointer events at all.
Voice never executes. A recognised phrase opens the palette pre-filled and waits for you to press Run, showing what it heard. Speech recognition mishears; an interface that acted on a mishearing would be worse than no voice. The win is reaching the right form without typing — the part that is hard with a motor impairment — not skipping the confirmation. The grammar is assembled from what each tool already declares: its aliases, its label, its name, and the enum values in its own schema. So "find a doctor for physiotherapy who is wheelchair accessible" pre-fills both fields with no bespoke parsing, and a vocabulary can never drift from the schema that validates it.
Parity is built as a set of concrete answers to questions on the WebMCP spec repo, with the issue numbers in the code. Several have since been closed — the dates below are a snapshot of 2026-10-12, and a closure is usually a scope decision rather than a verdict on the finding:
| Issue | What Parity does |
|---|---|
| #262 unregistering destroys context | get_booking_state.unavailable[] returns reason_code + unlock_by for every non-live tool; the live region announces why a command disappeared. Enforcement by absence, context by explanation. |
| #282 no structured refusal signal | Every tool returns a typed ToolResult; refusals fulfil with ok: false, kind, only bugs throw. |
| #255 progressive disclosure | 19 defined, ≤8 live via state-driven registration; every tool carries a group; palette and state tool present them grouped. Built from existing primitives. |
| #286 accessible name ↔ parameter description | Palette labels are generated from each Zod field's .describe(). The accessible name is the parameter description; they cannot disagree. |
| #277 / #272 a11y requirements for agent UI | Actor-named live-region announcements, screen-reader-usable command surface, keyboard-complete flows, focus management on grant cards. Offered as an implementation datapoint. |
#278 executeTool encoding |
src/lib/webmcpInterop.ts handles the string-encoded inputSchema, string-encoded results, and JSON-string arguments observed in Chrome. |
| #196 tool execution progress | watch_earlier_slot has no progress channel to use, so it writes progress to the on-page audit trail. An honest workaround, not a claim the issue is solved. |
| #165 elicitation | requestUserInteraction() is feature-detected every time. Measured absent in Chrome 152 — see findings. |
| #239 grammar-level injection mitigation | Vocabularies are z.enum, so the constraint on the agent is structural rather than a sentence asking it to behave. |
| #288 agent completes its own approval | Reproduced, recorded, and named as the reason the gate is called necessary, not sufficient. |
| #300 unregistration must not fail in-flight calls (closed — no spec ambiguity) | Independently reproduced in Chrome 152. State-driven registration means a tool can unregister itself mid-execute; the caller was then rejected with "The operation failed for an unknown transient reason" after the action had already succeeded. Re-registration is now deferred whenever a sync would cut a running tool. Details. |
| #299 results on caller abort (closed) | Measured on both sides of the fix. Chrome 152 threads no signal, so a write loop runs to completion while the caller is told it aborted; Chromium 153 stops it at 3 of 5. The spec question survives either way: the tool's partial result is discarded, AbortError.cause is undefined, and the caller's abort reason never reaches the tool at all. |
| #298 page-enforced write boundaries | Offered enforcement by absence as a shape alongside the proposed in-tool preconditions: a tool that is not legal now is not registered, so there is no call to refuse — paired with unavailable[] (#262) so absence does not destroy context. Plus grants hashed over canonical arguments, so an approval binds to this call rather than to the tool. |
| #306 tool namespaces / groups (closed as duplicate) | Every tool already carries a group, and the live set is derived from page state rather than accumulated — the page-side answer to tool explosion, offered as a datapoint for the filtering mechanism being debated. |
Recorded runs in evals/adversarial.md, executed
against the live deployment in Chrome 152 with real WebMCP by
scripts/run-evals.mjs. Re-run them yourself:
node scripts/run-evals.mjs https://parity-webmcp.vercel.app/| Case | Tests | Result |
|---|---|---|
| 1 | Where an injected provider bio can reach the agent | held — reachable by exactly one tool, and that tool is the one annotated untrustedContentHint |
| 2 | Approval for slot A cannot commit slot B | held |
| 3 | Consumed grant cannot book twice | held — same booking reference, no second booking |
| 4 | Unregistered tool is not callable | held — absent from getTools(); unavailable[] explains why |
| 5 | Grant expires at 120 s | held — grant_expired, no silent retry, control gone |
| 6 | Can injected input complete the page's approval? | |
| 7 | unavailable[] after the hold really expires |
held — waited out the real 10-minute timer |
Case 6 reproduced #288. Three approval attempts were made against the live page:
- a click inside the 1.5 s dwell → blocked, control disabled
- a JS-synthesised click, control force-enabled by script first → rejected,
isTrusted: false - a click injected through Chrome's own input pipeline → approved, logged as
via page card, pointer, trusted event
Automated input completed the human approval step and the page could not tell. That is precisely the gap #288 describes, reproduced deliberately against our own gate — and it is why this README says page-side approval is necessary, not sufficient rather than claiming it is airtight.
We offer it as a datapoint rather than a complaint. A page cannot distinguish injected input from a human, so the capability has to come from the layer that can: this is a concrete argument for host-mediated elicitation, #165's requestUserInteraction(). We feature-detect it on every call and would route approval through it tomorrow — it is absent in Chrome 152, which is the other half of the finding. Until a host offers it, the most honest thing a page can do is record the evidence and show it to the person it affects.
Detection made legible. The page cannot stop an injected click, but it can put the timing in front of the person it affects.
Case 7 waited out the real 10-minute hold timer rather than simulating it. confirm_booking unregistered with reason_code: hold_expired, and the live region announced "Confirm booking is no longer available: the hold on the slot expired." #262's context survived the unregistration on both surfaces.
Five minutes, and you can check every claim on this page rather than taking it on trust.
| Surface | Setup |
|---|---|
| ChatGPT desktop built-in browser | Update the app. Set the model to GPT-5.6 Sol or Terra — Luna has WebMCP disabled, and it is the usual reason tools never appear. |
| Chrome 149+ | chrome://flags/#enable-webmcp-testing → Enabled → relaunch. |
The header badge should read ✓ WebMCP: detected.
Click Site tools in the address bar. In the starting state you should see exactly five: get_booking_state, list_accommodations, explain_capability, find_providers, select_provider.
That is the whole live surface. Nineteen tools are defined; an action that is not legal right now does not exist.
Press Ctrl+K (or ⌘K) and complete a booking with the keyboard alone: find_providers → select_provider → get_availability → hold_slot → set_intake.
Scroll to Live tools and expand "One registry, two callers — live view". Change the stage and watch both lists change at once. One diff, both callers.
Ask the agent to confirm. It cannot. confirm_booking returns pending_authorization, the approval card appears with every argument in full, and Approve is inert for 1.5 s. The Activity trail then records how many milliseconds you took, flagging anything under 800 ms as possibly automated.
Open it in Firefox, Safari, or Chrome without the flag. The badge says not detected; the palette falls back to the local registry; every visual control still works.
npm run verify # typecheck + 385 unit tests + build + 36 real-browser checks
npm run verify:browser # just the browser pass (needs a build and Chrome 149+)
npm test # unit tests only — no browser needed, safe in CI
node scripts/run-evals.mjs https://parity-webmcp.vercel.app/ # the structural evals
node scripts/screenshots.mjs http://localhost:4321/ # regenerate docs/screenshotsverify:browser serves dist/, drives headless Chrome with --enable-blink-features=WebMCP over the DevTools Protocol, and asserts that tools register, that getTools() returns them, that executeTool() round-trips, and that a state transition re-registers the live set.
Parity targets WCAG 2.2 Level AA, and docs/FUTURE.md lists the conformance criterion by criterion — including the ones still owed, and the fact that no screen reader has been run against this build. This is an accessibility product, so an accessibility defect here is self-refuting. scripts/a11y-smoke.md records what was actually checked and how — separating what a test asserts from what was verified by reading markup, and stating what has not been checked at all.
Highlights, each backed by a test:
- The whole booking, keyboard only, no mouse, no agent — driven with real key events, twice: once through the visual UI, once entirely through the palette.
- The calendar grid is a real
<table>with a<caption>and scoped headers, one tab stop via rovingtabindex, arrow/Home/End/PageUp/PageDown movement, Enter to hold, Escape to leave rather than trap, and the focused cell announced. - Nothing is conveyed by colour alone — selected, refused, held, taken, the WebMCP badge and every error carry text or an
aria-hiddenglyph beside a word. - Date of birth is a text input with a stated ISO example, not a date picker. The tool validates it and returns a correction naming the field, wired to the input with
aria-invalidandaria-describedby. - Contrast is a design constraint, not a preference, and it is measured rather than asserted. Indigo on cream is 12.3:1 for body text; the peach spot colour is 2.27:1 and therefore decoration or ink-on-peach (5.4:1) only. The deep terracotta that carries error text and links is 5.31:1 on cream and 4.81:1 on the deeper panel. Those numbers are measured — an earlier value shipped with a comment claiming 4.6:1 while actually measuring 3.09:1, so every error message using it failed 1.4.3 AA.
npm run audit:a11ynow runs axe-core over every stage of the flow, including a rendered refusal, so a colour cannot claim a ratio it does not have. - The loading screen never gates content — the app mounts and registers underneath it from the first frame,
prefers-reduced-motionskips it entirely, any key dismisses it, and it isaria-hidden.
git clone https://github.com/mysticalseeker24/parity-webmcp
cd parity-webmcp
npm install
npm run devThen open the dev URL in a WebMCP browser (see above). Without WebMCP the app still works: the palette falls back to the internal registry and the visual UI is unaffected. Progressive enhancement throughout.
┌──────────────────────────────┐
│ src/tools/*.ts │
│ 19 defineTool() specs │
│ ONE Zod schema each │
└──────────────┬───────────────┘
│
┌──────────────▼───────────────┐
│ src/lib/defineTool.ts │
│ + registry.ts │
│ z.toJSONSchema() · validate│
│ · announce · audit · undo │
└──────┬─────────────────┬─────┘
│ │
registerTool() │ │ getTools() + executeTool()
▼ ▼
┌────────────────────┐ ┌──────────────────────┐
│ BROWSER (client) │ │ CommandPalette.tsx │
│ Site tools panel │ │ VoiceInput.tsx │
└─────────┬──────────┘ └──────────┬───────────┘
│ │
AI agent human user
│ │
└───────────┬────────────┘
▼
┌───────────────────────┐
│ store.ts (Zustand) │
│ → React UI + a11y │
│ live region │
└───────────────────────┘
| Path | What it is |
|---|---|
src/lib/defineTool.ts |
The factory. One spec → six consumers. Enforces the character budgets at definition time. |
src/lib/registry.ts |
The only file that calls registerTool. Diffs the live set on every store change. A test greps the tree to keep it that way. |
src/lib/result.ts |
The ToolResult envelope (#282). |
src/lib/grants.ts |
The gate. One implementation, three gated tools. |
src/lib/reasons.ts |
Every reason_code and its human sentence — one source for the agent and the announcer (#262). |
src/lib/announcer.ts |
Store changes → spoken sentences, with the actor named. |
src/lib/voiceMatch.ts |
Pure matching logic, assembled from each tool's own declarations. |
src/lib/timers.ts |
Hold expiry, plus a written audit of every timer in the codebase and what clears it. |
src/lib/undo.ts |
Inverse snapshots for reversible tools. Gated tools are never undoable. |
src/lib/webmcpInterop.ts |
The seam between what webmcp-types promises and what Chrome does. |
src/data/ |
Synthetic fixtures: 16 providers, deterministic slots, coverage rules as data. |
scripts/a11y-audit.mjs |
axe-core over every stage of the flow, plus the accessibility tree Chrome exposes. Not a screen-reader result — see docs/SCREEN_READER.md. |
scripts/verify-browser.mjs |
36 assertions against real Chrome over CDP, including that every surface mirrors a tool call made from any other. |
scripts/run-evals.mjs |
The structural adversarial evals. |
Stack. Vite 8 · React 19 · TypeScript strict · Zod 4 (z.toJSONSchema) · Tailwind 4 · Zustand · webmcp-types · Web Speech API · Vitest · deployed on Vercel.
No backend. No database. No auth. No secrets. Fixture data is synthetic and slots are generated deterministically from a seed, so demos are reproducible.
Building this turned up several behaviours that contradict webmcp-types and the documentation. All are recorded with reproduction steps in .agent/PHASE1_FINDINGS.md, and npm run verify:browser re-checks them on every run.
| Finding | Why it matters |
|---|---|
RegisteredTool.inputSchema is typed object but arrives as a JSON string |
The palette renders forms from it; reading .properties off a string gives undefined and every form renders empty, with no error |
executeTool() resolves to a JSON string, not the returned value |
Property access on the result is silently undefined |
executeTool() rejects object arguments with UnknownError: Failed to parse input arguments |
Confirmed, not assumed |
executeTool is missing from webmcp-types entirely |
Declaration merge in src/types/webmcp-augment.d.ts |
execute is called with ONE argument — no options, no signal |
({ id }, { signal }) => throws on the destructure before the tool body runs; the browser then reports every tool as failed with nothing in the console. The most expensive finding here. |
requestUserInteraction() does not exist in Chrome 152 |
The complete ModelContext surface is executeTool, getTools, ontoolchange, registerTool. It is the right home for approval (#165), and its absence is why the page card is the only channel. |
annotations come back defaulted, not echoed |
Do not assert deep equality against what you registered |
| The declarative and imperative paths disagree about who called | On one browser (Chromium 153), SubmitEvent.prototype carries agentInvoked, so a declarative form handler can tell an agent from a person. An imperative tool is handed ToolExecuteCallbackOptions { signal } and nothing else — no identity, no scope, no correlation id. We are entirely imperative, which is why the actor in our announcements is inferred rather than known. Reported on #96, since closed on scope — agent identity is being treated as a broader "agents on the web" question than WebMCP itself. |
| On Chrome 152 a caller's abort cancels the report, not the work | executeTool(tool, args, {signal}) rejects the caller, but 152's execute never sees the signal, so the tool runs to completion and its writes land — measured at <body data-applied="5"> after the caller aborted. An agent that aborts a batch and retries has applied it twice. Conformance lag, not a spec gap: verified on Chromium 153 (Edge), the signal arrives, the loop stops at 3 of 5, and only 3 writes land. What survives on 153 is the settlement question — the tool's {applied, remaining} is still discarded and AbortError.cause is undefined. Reported on #299. |
| On Chrome 152 a tool that unregisters itself mid-execute rejects its caller, after succeeding | Rejects with "The operation failed for an unknown transient reason (e.g. out of memory)" while the action has already landed. Any registry deriving its live set from page state hits this, since a state-changing tool routinely removes itself, and an agent told the booking failed will retry. A Chromium conformance bug, not a spec gap — #248 already covers it, CL 8224887 fixed it, and it is verified resolved here on Chromium 153. We keep the page-side mitigation (skip the unregistration of a running tool) because 152 is the shipping stable build. We proposed a WPT case for it and withdrew it: measuring three abort shapes showed the existing tests already reach the bug, so ours added nothing. |
- The Declarative (HTML form) WebMCP API is unused. Evaluated and rejected: ChatGPT's built-in browser does not expose declarative tools, and that is the judging surface.
- No iframes, no cross-origin tool exposure. ChatGPT's browser does not discover tools registered in iframes, same-origin or not.
- No routing. Tools belong to the page; a route change would unregister every tool mid-flow.
- Booking state resets on reload. It is a demo; there is nothing to persist and no user data to keep.
- No CAPTCHA, puzzle, or timing challenge on the approval path — even though one would frustrate #288. Every such trick excludes the people this product exists for.
- Verified in Chrome; not yet exercised in ChatGPT's built-in browser. Everything documented here was run in Chrome 149+ with the WebMCP flag, which is the same imperative API surface. ChatGPT's browser supports a documented subset (no declarative API, no iframes) that Parity already stays inside, but the app has not been driven by a language model there.
- Voice is Chrome-only (Web Speech API). The button feature-detects and says so rather than failing silently, and every voice capability has a keyboard equivalent.
- WebMCP is a proposed standard — a W3C Community Group draft in a Chrome
origin trial — so its API surface may still change.
src/lib/webmcpInterop.tsis the single seam where that is absorbed. - Tools belong to the page. Navigating away or closing the tab unregisters them. That is expected WebMCP behaviour, and it is why Parity is a single page with no routing.
- Booking state resets on reload. It is a demo with synthetic data; there is nothing to persist and no user data to keep.
- Spec issue #288 cannot be closed from inside a page. Parity reproduces it, records it, and says so — see the evals. It is an argument for host-mediated elicitation (#165), which we already feature-detect.
MIT — see LICENSE.







