diff --git a/DESIGN.md b/DESIGN.md
index 09bf217..119ec09 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -2,7 +2,7 @@
 
 ## Overview
 
-A loud, cheerful 1990s supermarket weekly flyer for visitors reading vault 6 (BaskVault `0x739fd5b653aa092a434534fa1ade67c1770b5a5b` on Robinhood Chain) and using a wallet to deposit, redeem or manage Stock Tokens. Every route shares the store-sign header, hanging aisle navigation, stocked shelves, sky-blue surround and checkerboard floor. Figures, warnings and owner controls use plain white surfaces. The owner’s store worker is the only person on the site, in three supplied poses for Vault, Deposit and Redeem.
+A loud, cheerful 1990s supermarket weekly flyer for visitors reading vault 6 (BaskVault `0x739fd5b653aa092a434534fa1ade67c1770b5a5b` on Robinhood Chain) and using a wallet to deposit, redeem or manage Stock Tokens. Every route shares the store-sign header, hanging aisle navigation, stocked shelves, sky-blue surround and checkerboard floor. Figures, warnings and owner controls use plain white surfaces. The owner’s store worker is the only person on the site, in three supplied poses that pop out of the Vault, Deposit and Redeem title panels.
 
 ## Colors
 
@@ -27,33 +27,34 @@ Status always has words; color alone never carries a check result. There is one
 
 Anton (`Flyer`) is a local regular WOFF2 face for chunky condensed uppercase headings and the store sign. VT323 (`Pixel`) is a local regular WOFF2 face for the marquee and small accent labels. Body, forms, warnings and numbers use Arial/Helvetica/system sans at 16px and line-height 1.5. Address strings use monospace. Font licenses are local. No external font request is needed.
 
-H1 is 64px on desktop and 36px on phones. Title eyebrows use bold Arial at 14px/20px to avoid pixel-font shimmer on scaled displays. H2 is 32px (30px on phones), H3 25px (24px on phones). Headings use line-height 1.125 and balanced wrapping. Body measure is at most 70–75 characters for prose. Numbers use tabular numerals; quantities and addresses wrap without losing their full value. Inputs stay at 16px to avoid phone focus zoom. Native bold remains distinct in the system body family; local display faces use only their supplied regular weight.
+H1 is 64px on desktop and 36px on phones. Title eyebrows use bold Arial at 14px/20px to avoid pixel-font shimmer on scaled displays; the Vault title has none. On the three character pages the desktop heading instead fills its column on one line, or two balanced lines when one line would be too small. H2 is 32px (30px on phones), H3 25px (24px on phones). Headings use line-height 1.125 and balanced wrapping. Body measure is at most 70–75 characters for prose. Numbers use tabular numerals; quantities and addresses wrap without losing their full value. Inputs stay at 16px to avoid phone focus zoom. Native bold remains distinct in the system body family; local display faces use only their supplied regular weight.
 
 ## Layout
 
-The content maximum is 1200px, with 20px desktop and 16px phone gutters. Flyer panels have 24px padding, 24px gaps and thick colored frames. Forms and details group within panels. The Vault hero uses a flexible title and 380px illustration column (320px at 661–960px). Its checker strip stays at the title’s bottom. At 660px and below, the picture frame spans the full width directly beneath the title, with WOW! retained.
+The content maximum is 1200px, with 20px desktop and 16px phone gutters. Flyer panels have 24px padding, 24px gaps and thick colored frames. Forms and details group within panels. The Vault, Deposit and Redeem title panels share one pop-out layout. The heading and sentence (and the eyebrow on Deposit and Redeem) sit in the left column, centred top to bottom. The character stands at the right end on the checker strip, her head rising above the panel's top edge, with her speech bubble beside her head. Her picture is 390px high, 340px at 999px and below. At 660px and below she stands on her own yellow shelf at the top of the panel (300px high, 270px below 360px): on Vault the heading starts 17px under her shelf with the sentence below it; on Deposit and Redeem the eyebrow and heading stand beside her and the sentence follows below. The checker strip stays at least 24px below the title text at every width.
 
-At 960px, stock cards fall from three columns to two; role and owner grids become one column. At 660px, stock cards, forms, docs and claims use one column; the menu retains four legible hanging signs. Metric panels retain two columns. Each stock is a complete phone card with explicit field labels, not a horizontally scrolling table. The data refresh action stays beside its status. Phones omit the duplicate global transaction summary, keeping the status beside its action. Phone header, title and shelf spacing is reduced so task guidance appears sooner. Long addresses wrap. Required screenshots cover 1440px and 375px; additional checks and their limits are recorded with validation.
+The Stock shelves labels fill as many columns as fit (5 big and 7 small labels a row at 1440px, 2 big and 3 small on a 375px phone; 2 small at 360px and below, 1 big at 320px). At 960px, role and owner grids become one column. At 660px, forms, docs and claims use one column; the menu retains four legible hanging signs. Metric panels retain two columns. Each stock is a shelf label with its words written out, never a horizontally scrolling table. The data refresh action stays beside its status. Phones omit the duplicate global transaction summary, keeping the status beside its action. Phone header, title and shelf spacing is reduced so task guidance appears sooner. Long addresses wrap. Required screenshots cover 1440px and 375px; additional checks and their limits are recorded with validation.
 
 ## Elevation & Depth
 
-This is a flat print-inspired system. Flyer panels use a 5px sunshine border with a 3px red outer frame. Nested panels use 2px royal-blue borders. The sign and hanging menu use solid offset ink shadows. All text stays unrotated and in normal document flow; only the overflow-clipped slogan track moves. White receipt/data panels contain no decorative texture.
+This is a flat print-inspired system. Flyer panels use a 5px sunshine border with a 3px red outer frame. Nested panels use 2px royal-blue borders. The sign and hanging menu use solid offset ink shadows. Text stays in normal document flow. On the Stock shelves the shelf signs, the share stickers and the CLOSED stamp sit slightly tilted, like stickers on a shelf edge. Only the overflow-clipped slogan track moves continuously; the shelf labels swing once (see Components). White receipt/data panels contain no decorative texture.
 
 ## Shapes
 
-Panels and receipts are rectangular; controls use 3px corner radii and at least 44px height. Art combines original SVG/CSS with the manifest files kept byte for byte: the owner’s character (the only person on the site) and Microsoft Fluent Emoji flat food (MIT). The three pictures show a produce crate, an offered basket and a full grocery bag. The project’s BASKET PROTOCOL name badge is allowed. Word-only starbursts use a CSS polygon and carry only WOW! or Fresh! The only checker pattern is a decorative floor/title strip. Decoration has no currency, numerical labels, real product marks or borrowed characters.
+Panels and receipts are rectangular; controls use 3px corner radii and at least 44px height. Art combines original SVG/CSS with the manifest files kept byte for byte: the owner’s character (the only person on the site) and Microsoft Fluent Emoji flat food (MIT). The three pictures show a produce crate, an offered basket and a full grocery bag. The project’s BASKET PROTOCOL name badge is allowed. The only word-only starburst is Fresh! on the stock shelves (a CSS polygon). The only checker pattern is a decorative floor/title strip. The favicon is a red panel with a yellow frame and the header's basket mark in yellow. Decoration has no currency, numerical labels, real product marks or borrowed characters.
 
 ## Components
 
-- `components.tsx`: `PageTitle`, `Note`, `Empty`, `Addr`, `AddressLink`, `RoleInfo`, `TxButton`, `ActionStatus`, `DisabledReason`, `Receiver`, and the basket mark. Reuse these for hierarchy, warnings, readable addresses and guarded actions.
+- `components.tsx`: `PageTitle` (optional eyebrow, rendered only when given; optional title character: picture and speech bubble), `Note`, `Empty`, `Addr`, `AddressLink`, `RoleInfo`, `TxButton`, `ActionStatus`, `DisabledReason`, `Receiver`, and the basket mark. Reuse these for hierarchy, warnings, readable addresses and guarded actions.
 - `Scenery.tsx`: `Marquee` and `StoreShelf`. The two decorative shelf rows use empty-alt local images: the first 14 food SVGs in manifest order above, then the next 19 below, each list repeated five times and clipped without motion. The light-blue back wall is `#c4e7ff`; red planks have ink edges. Desktop icons are 40px squares with 12px gaps in a 120px strip. Phones use 22px squares, 8px gaps and 3px planks in a 50px strip, with a 4px gap above the shelf frame; this preserves the previous above-fold messages at 375×812. Both shelf locations share this system.
-- `Marquee` has two identical halves, each four copies of the unchanged slogans and at least one viewport wide. Only `overflow: hidden` clips the window; the moving track has `will-change: transform`. It loops from 0 to −50% in 180 seconds on desktop and 45 seconds on phones. There is no pause, stop or hide control, per the owner’s decision. Animation runs only under `prefers-reduced-motion: no-preference`; reduced motion is static.
-- `.character-picture` uses each manifest width/height, `display: block`, `width: 100%`, `object-fit: contain` and `object-position: 50% 100%`. Vault picture heights are 300/260/200px; flow pictures are 320/260/240px at desktop/tablet/phone widths. Frames grow to accommodate speech. At the narrowest tablet aside widths, the Redeem bubble sits above-left of the head with a downward tail, reserving space above the bag; phone bubbles sit alongside the head. Deposit and Redeem stages use sunshine with 4px red borders. Speech stays still in white rounded bubbles with 3px ink borders and tails, in Flyer at 18px/1.4 (15px on phones); copy retains its supplied case. Each picture has its assigned descriptive alt text. No image is cropped, stretched, recolored or animated.
-- `Vault.tsx`: metric cards, stock cards and `DepositState`. Symbol, state, held amount, NAV share and failed checks remain visible; Details reveals feed and pool data. A search filters cards without changing contract order. Price status comes from contract reasons (fifteen, in `BaskVault.Reason` order); reasons 9–11 explicitly say the pool check was not run. `DepositState` (also on Deposit) prints the hours in New York words plus the raw seconds, and for reason 3 says when deposits reopen (weekday, New York time, date, countdown and the visitor's local time) and for reason 14 that they wait for a price update, computed by `newYork.ts` from `settings()` and the latest block timestamp. Unreadable values are spelled out, never shown as a real zero.
+- `Marquee` has two identical halves, each holding eight copies of the unchanged slogan line (720px wide in VT323 at 24px). Each half shows only its first k lines, k being the fewest whole lines that cover the window: 1 up to 720px wide, 2 up to 1440px, 3 up to 2160px, and so on up to 8 above 5040px. So there is no blank space in the window, the text runs on across the seam with the normal word gap, and the moving track is at most two screens plus two lines wide (no `will-change`; a very wide moving block stops being drawn on iPhones). Only `overflow: hidden` clips the window. It loops from 0 to −50% in k × 45 seconds (16px per second), or k × 11.25 seconds at 660px and below (64px per second). There is no pause, stop or hide control, per the owner’s decision. Animation runs only under `prefers-reduced-motion: no-preference`; reduced motion is static.
+- Title characters: each picture keeps its manifest width/height ratio with `object-fit: contain`, bottom-aligned, standing on the checker strip (on her shelf on phones). The bubble's tail points at her mouth; the bubble stays clear of her face, hands and held items, and no word is split across lines. Speech stays still in white rounded bubbles with ink borders, in Flyer at 20px (18px at 999px and below, 16px on phones); copy retains its supplied case. Lines: Vault "I was hoping you would come through my aisle", Deposit "Go ahead and put it in", Redeem "are you sure that’s all you came here for?". Each picture has its assigned descriptive alt text. No image is cropped, stretched, recolored or animated.
+- `Vault.tsx`: metric cards, the Stock shelves and `DepositState`. The Stock shelves are a store shelf unit (light-blue back wall, royal-blue uprights, the food strip as its top shelf) with every stock as a yellow shelf-edge label clipped onto a red shelf edge, in two groups under red shelf signs: "In the basket" (held, or held amount unreadable: big labels, biggest share first) and "On the shelf, not held" (small labels, listing order). Every label shows the ticker, the feed price as a red flyer price, when it updated ("just now" under a minute; the drawer keeps the full words) and the status in words (Open, Closed to deposits, Retired, or "Open · not taking deposits" with the price reason in a chip); big labels add the share sticker and bar, the value and the amount held. Only a feed price missing or too old (reason 9) is dimmed with an "old price" tag; under reasons 10 and 11 the price passed the age check, so it shows normally and the chip gives the reason. Warnings (check this pairing, balance check) print on the label. Tapping a label opens a drawer under its row with the feed, feed price and age, pool check, held amount, share, owed amount and the Stock Token and price feed links (Close or Escape). Filters All / Open / Closed / Held with counts and a search by ticker or address narrow the shelves; while one is on, "Show all" brings every stock back. Money uses `usd()`, cut to the cent like the NAV figure. The labels of each row swing once on their clips when the row first comes into view and lift 4px on hover or focus; nothing moves under reduced motion, and filtering or searching stops the swing for good. Price status comes from contract reasons (fifteen, in `BaskVault.Reason` order); reasons 9–11 explicitly say the pool check was not run. `DepositState` (also on Deposit) prints the hours in words (New York time, or UTC-5/UTC-4 under Dst 1/2), and for reason 3 says when deposits reopen (weekday, time, date, a countdown from block time and the visitor's local time) and for reason 14 that they wait for a price update, computed by `newYork.ts` from `settings()` and the latest block timestamp. Once the opening is reached it re-reads the vault and says deposits may be open. Unreadable values are spelled out, never shown as a real zero.
+- `Docs.tsx`: plain explanations of the vault; an FAQ panel after Redemption answers what happens when a stock can’t be sent on redeem (the Redeem page itself carries no such note).
 - `Flows.tsx`: decimal amount fields, exact Use full balance controls, search-to-add stocks, previews immediately after selected amounts, named approval steps and owed-first claim cards. Claim all precedes the cards; zero balances fold away. Receivers remain full, wrapped and labelled. Preview data is invalidated when inputs/accounts change and after successful deposits.
-- `Owner.tsx`: `ActionForm`, pairing cards, genesis sequence (`listGenesis`, `finalizeGenesis`), settings and pending proposal cards built from `pendingProposals` ids and `proposal(id)`, executable from two to nine days after creation. The Hours setting shows the current schedule in words and raw seconds and takes From and To as a weekday plus New York time (or "Always open"), previewing value, value2 and words; Dst shows its three rule words; FreshCount and FreshHours explain the market-holiday closure. Proposals send the `BaskVault.Action` struct. Forms use native details disclosures. Stock selectors begin on Choose a stock, retain an existing choice across reads and clear it when the stock disappears. Launch folds to one done line; Pause, Pending and Immediate precede proposal forms. Jump controls scroll and focus without a route change. Consequential irreversible actions require an explicit checkbox; unauthorized controls remain visible and disabled. Financial buttons use system text rather than display lettering.
+- `Owner.tsx`: `ActionForm`, pairing cards, genesis sequence (`listGenesis`, `finalizeGenesis`), settings and pending proposal cards built from `pendingProposals` ids and `proposal(id)`, executable from two to nine days after creation. The Hours setting shows the current schedule in words and raw seconds and takes From and To as a weekday plus New York time (or "Always open"), previewing value, value2 and words; Dst shows its three rule words; FreshCount and FreshHours explain the market-holiday closure. Proposals send the `BaskVault.Action` struct. Forms use native details disclosures. Stock selectors begin on Choose a stock, retain an existing choice across reads and clear it when the stock disappears. Launch folds to one done line; Pause, Pending and Immediate precede proposal forms. Jump controls scroll and focus without a route change. Finalize stays disabled until the listing rows are pasted and every pasted row is listed with the same values. Consequential irreversible actions require an explicit checkbox; unauthorized controls remain visible and disabled. Financial buttons use system text rather than display lettering.
 
-All controls use native elements and visible labels. Focus has a 3px ink perimeter with a sunshine surround. Hash navigation focuses the page H1; a skip link reaches main content. Errors use alert regions, transaction progress uses a status region, and read failures offer Retry. Disabled buttons have nearby reasons and recovery controls. Primary hover/focus/active states explicitly keep white text on ink; disabled primary buttons use the same legible muted palette as other disabled controls. Action-local status retains transaction links and reports confirmed refreshes, proposal IDs/ready times and remaining owed amounts. Loading says Reading...; failure says unreadable with Retry. Balance and claim Retry controls appear only after failed reads; a complete, successful empty claim read says that nothing is owed. Incomplete stock reads say “Owed balances unreadable. Retry vault.” with Retry vault. Claim and loss result scopes include the token address so equal symbols cannot overwrite one another’s result. Motion is limited to the continuously running slow marquee (unless reduced motion is requested) and color-only control feedback. Buttons no longer scale text on press. Forced-colors focus uses the system Highlight color.
+All controls use native elements and visible labels. Focus has a 3px ink perimeter with a sunshine surround. Hash navigation focuses the page H1; a skip link reaches main content. Errors use alert regions, transaction progress uses a status region, and read failures offer Retry. Disabled buttons have nearby reasons and recovery controls. Primary hover/focus/active states explicitly keep white text on ink; disabled primary buttons use the same legible muted palette as other disabled controls. Action-local status retains transaction links and reports confirmed refreshes, proposal IDs/ready times and remaining owed amounts. Loading says Reading...; failure says unreadable with Retry. Balance and claim Retry controls appear only after failed reads; a complete, successful empty claim read says that nothing is owed. Incomplete stock reads say “Owed balances unreadable. Retry vault.” with Retry vault. Claim and loss result scopes include the token address so equal symbols cannot overwrite one another’s result. Motion is limited to the continuously running slow marquee, the Stock shelves labels' one-time restocking swing and 4px lift (all off when reduced motion is requested) and color-only control feedback. Buttons no longer scale text on press. Forced-colors focus uses the system Highlight color.
 
 ## Do's and Don'ts
 
diff --git a/README.md b/README.md
index 703481d..dedf6bf 100644
--- a/README.md
+++ b/README.md
@@ -29,10 +29,11 @@ Publish the **contents of the committed `dist/` directory** to the existing stat
 - `allAssets()` supplies `managedBalance`, `owedBalance`, `balanceReadable`, `shortfall` (short means shortfall above zero), prices, price reasons and pool prices. Failed aggregate reads fall back to `assetTokens()` and `asset(token)` per stock; pool checks and reasons remain unreadable. One `depositStatus([])` supplies the global status, and the latest block timestamp is read with every snapshot because the vault's hours and freshness use block time.
 - Deposit hours are seconds since Sunday 00:00 New York time (`hoursFrom` inclusive, `hoursTo` exclusive; both zero means always open), with the `dst` setting choosing the US daylight saving rule, never daylight saving (UTC-5) or always daylight saving (UTC-4). `web/src/newYork.ts` ports `NewYorkTime.sol`; the deposit status says when deposits reopen (reason 3) or that they wait for a price update (reason 14), computed from `settings()` and the latest block, never the browser time zone.
 - Deposits use token/amount arrays, exact short approvals, wallet receiver, 0.5% minimum-share tolerance and a ten-minute deadline. The contract preview checks the size limit. Successful deposits clear inputs and the old preview.
-- Redemption refreshes its preview immediately before sending, uses a selected nonzero receiver other than the vault, and 0.1% minimum amounts in current `assetTokens` order. Unsent stocks are owed to that receiver. Claims read every listed token and send groups of at most ten; one failing stock reverts its whole batch, nothing is lost, and each stock has its own Claim button.
+- Redemption refreshes its preview immediately before sending, uses a selected nonzero receiver other than the vault, and 0.1% minimum amounts in current `assetTokens` order. Unsent stocks are owed to that receiver (explained in the Docs FAQ). Claims read every listed token and send groups of at most ten; one failing stock reverts its whole batch, nothing is lost, and each stock has its own Claim button.
 - Genesis listings use `listGenesis`, show each row as it is checked, preserve row order and re-read each listing after confirmation. Whether a token is listed comes from `assetTokens()` because `asset()` reverts for unlisted tokens. A set pool requires a `minLiquidity` above zero. Current `poolWindow` pool liquidity and pool/feed gap are checked before listing; failed or marked rows need correction. A declined prompt can resume after checks. Submitted hashes survive receipt timeouts in session storage; listing compares pending/latest nonces after reload and prefers the node's record of the saved transaction's nonce over the count saved before the prompt.
-- The only browser storage is per-tab listing text and pending transaction recovery; there are no cookies, trackers or new services.
-- Governance sends `propose(Action)` with the `BaskVault.Action` struct (kind, token, target, pool, quoteFeed, value, value2, setting), fields per kind as in the pinned source and unused fields zero. Proposals wait two days and are executable until nine days after creation (exclusive); the Proposed event's `executableAt` is shown after sending. Settings are in vault 6 order with `Dst` at index 6. The UI additionally requires deposits paused to execute Retire and Resync, and to propose Resync.
+- The only browser storage is the pasted listing rows (kept for this tab and copied for new tabs) and pending transaction recovery; there are no cookies, trackers or new services.
+- Governance sends `propose(Action)` with the `BaskVault.Action` struct (kind, token, target, pool, quoteFeed, value, value2, setting), fields per kind as in the pinned source and unused fields zero. Proposals wait two days and are executable until nine days after creation (exclusive); the Proposed event's `executableAt` and `expiresAt` are shown after sending. Settings are in vault 6 order with `Dst` at index 6. The UI additionally requires deposits paused to execute Retire and Resync, and to propose Resync.
+- Dates are written in words with UTC and New York time, for example "Sun 11 Oct 2026, 04:40 UTC (00:40 New York)", never as a numeric date. A start ("executable from", "Wait until", a loss's recognition date) is rounded up to the next whole minute and an end is written "until just before" a time rounded down, so a waiting window never looks longer than it is.
 
 ## Reproduce ABI and runtime
 
@@ -51,9 +52,11 @@ Compilation uses solc 0.8.26+commit.8a97fa7a via `--standard-json`, optimizer 20
 
 ## Validation
 
-`npm run validate` checks decimal-normalized NAV, indicative flags, all eleven proposal kinds as the Action struct (including Hours and Dst), minimums, receivers, listing input, revert wording, live aggregate reads and bytecode identity. `check-interface.ts` adds the New York hours parser, the `NewYorkTime` port's inside/nextOpening vectors for all three `dst` modes, setting words and the pool `minLiquidity` rule. `check-preservation.mjs` checks unchanged protected configuration/contracts, forbids every abandoned vault address fragment in every file and keeps the send-check invariants. `check-calldata.mjs` keeps `Losses.tsx`, `main.tsx`, `components.tsx` and `Scenery.tsx` byte-identical to HEAD and compares every call expression of `Flows.tsx` and `Vault.tsx` with HEAD.
+`npm run validate` checks decimal-normalized NAV, indicative flags, all eleven proposal kinds as the Action struct (including Hours and Dst), minimums, receivers, listing input, revert wording, live aggregate reads and bytecode identity. `check-interface.ts` adds the New York hours parser, the `NewYorkTime` port's inside/nextOpening vectors for all three `dst` modes, setting words and the pool `minLiquidity` rule. `check-preservation.mjs` checks unchanged protected configuration/contracts, forbids every abandoned vault address fragment in every file and keeps the send-check invariants. `check-calldata.mjs` compares the source with the commit it was applied to (HEAD): see "Site update v9" below for what it allows.
 
-The bounded browser/fork runner covers a 25-row listing with a declined prompt, receipt timeout, pending nonce and reload, a US market holiday (every feed three hours old) and a Saturday, the Hours and Dst proposals and every transaction control. It requires Anvil, solc 0.8.26, Playwright and Chromium (WebKit for `check-art.mjs`). The runner requires an unfinalized empty genesis state so that it can exercise initial listing. Install Playwright outside the repository if necessary, and set `PLAYWRIGHT_MODULE` to its `index.mjs` when it is not at the runner's environment default; `BASKET_RPC` selects the upstream RPC.
+The bounded browser/fork runner covers a 25-row listing with a declined prompt, receipt timeout, pending nonce and reload, a US market holiday (every feed three hours old) and a Saturday, the Hours and Dst proposals and every transaction control. It requires Anvil, solc 0.8.26, Playwright and Chromium (WebKit for `check-art.mjs`). The runner requires an unfinalized empty genesis state so that it can exercise initial listing. Install Playwright outside the repository if necessary, and set `PLAYWRIGHT_MODULE` to its `index.mjs` when it is not at the runner's environment default.
+
+The runner forks block **83,874,298** by default: the last block where vault 6 is empty and not finalized, with the same code as today. The live vault now has 25 listed stocks and may be finalized, so a fresh block can no longer exercise the first listing. That block is older than what pruning RPCs keep, so the runner reads it from the archive RPC `https://robinhood.api.pocket.network` through a small read-only proxy built into the runner: only read methods pass, block-hash parameters become block numbers, at most eight requests run at once and busy or failed reads are retried. `BASKET_FORK_BLOCK` and `BASKET_RPC` still override both; an override RPC must be an archive node for chain 4663, and an override block must keep vault 6 empty and unfinalized. The runner also mines one local block before its first call (Anvil 1.8 needs it) and waits for the second "List stocks" pass to finish before Finalize.
 
 ```sh
 cd web
@@ -70,12 +73,52 @@ node scripts/check-calldata.mjs
 node scripts/check-bundle.mjs
 ```
 
-It pins a fresh block after 83,448,310 (or `BASKET_FORK_BLOCK`), caches the needed genuine account/storage (vault 6 layout: words 0-41, the tokens array, the address and proposal mappings) and next 512 block-history ring reads before public RPC pruning, preserves the actual vault bytecode, creates disposable Stock Token/feed/pool fixtures on the fork (feeds have a settable lag), serves the actual production export at `/preview/`, exercises wallet actions and writes screenshots and decoded sends to `artifacts/`. Before each deposit it warps to the next opening when the fork is outside the hours and checks `insideHours()` on both sides of the boundary. All child services close when the command ends.
+It forks the block above (it must be after 83,448,310), caches the needed genuine account/storage (vault 6 layout: words 0-41, the tokens array, the address and proposal mappings) and next 512 block-history ring reads before public RPC pruning, preserves the actual vault bytecode, creates disposable Stock Token/feed/pool fixtures on the fork (feeds have a settable lag), serves the actual production export at `/preview/`, exercises wallet actions and writes screenshots and decoded sends to `artifacts/`. Before each deposit it warps to the next opening when the fork is outside the hours and checks `insideHours()` on both sides of the boundary. All child services close when the command ends.
 
 Actual results, design review coverage, screenshots and limitations are recorded in [artifacts/validation.md](artifacts/validation.md). The 2026-10-09 vault 6 production build, typecheck, live/ABI, guard, export, motion and fix checks and the fork walk-through passed (61 checks, 70 wallet sends). The 24 empty/25-stock screenshots cover all six pages at 1440 and 375px. WebKit was unavailable for `check-art.mjs`, so its manifest hash part was repeated separately and its WebKit render part is recorded as unperformed; the art files are unchanged. Native Windows display scaling and physical phones remain unverified. Fork evidence is local testing, not an independent certification or a live transaction.
 
 Fonts are Anton and VT323 under the SIL Open Font License; notices are in `web/public/fonts/`. Art is original SVG/CSS plus the manifest files kept byte for byte: the owner’s character (the only person on the site) and Microsoft Fluent Emoji food (MIT). `artifacts/art-manifest.json` pins all 37 assets; the food license is `web/public/art/food/Fluent-Emoji-MIT.txt`. There are no borrowed characters. Decorative artwork carries no numbers, currency signs or real brand names; the project’s BASKET PROTOCOL name badge is allowed. The pinned Better Interface and Impeccable attribution and licenses are retained in `web/validation/DESIGN-GUIDANCE-LICENSE`.
 
-The slogan strip always runs, with no pause control, except when the visitor requests reduced motion. Local art is loaded through relative image URLs; the shipped export makes no outside requests except chain RPC reads. The two food shelves and all three picture frames are documented in [DESIGN.md](DESIGN.md).
+The slogan strip always runs, with no pause control, except when the visitor requests reduced motion. Local art is loaded through relative image URLs; the shipped export makes no outside requests except chain RPC reads. The two food shelves, the title characters and the slogan strip are documented in [DESIGN.md](DESIGN.md).
 
 To compare phone visibility to a saved previous export, run `BASKET_BASELINE_DIST=/absolute/path/to/previous/dist node scripts/check-visibility.mjs` from `web/`. It checks six routes at 375×812, both without a wallet and with a read-only injected connection to the live owner.
+
+## Site update v9
+
+Look:
+
+- The store worker pops out of the Vault, Deposit and Redeem title panels. She stands on the checker strip at the panel's right end, her head rises above its top edge and her speech bubble sits beside her head. On phones she stands on her own shelf at the top of the panel. The separate picture frames and the WOW! burst are gone; Fresh! on the stock shelves stays.
+- The tagline is gone from the footer and from the Vault title. The footer keeps the basket mark, "Basket Protocol" and its links. The Vault title has no eyebrow; its heading and sentence sit centred beside her.
+- The yellow note about unsent stocks left the Redeem page. A new FAQ panel in Docs, right after Redemption, explains it.
+- The slogan strip shows only as many whole slogan lines as the screen needs (rule in DESIGN.md), so wide windows have no blank gap and phones keep drawing it.
+- Stock shelves: each stock is a yellow shelf-edge label on a red store shelf (rule in DESIGN.md). Held stocks get big labels at the top, biggest share first; the rest get small labels in listing order. A tap opens the details (feed, pool check, owed amount, both addresses). Filters and search are kept, with "Show all" while one is on. The labels swing once when their shelf first comes into view (never under reduced motion). Values are cut to the cent like the NAV figure. Display only: no read, check or transaction changed.
+- New favicon: a red panel with a yellow frame and the header's basket in yellow.
+
+Fixes (the same inputs still give the same calldata; the only new behaviour near a send is a refusal before the wallet prompt):
+
+1. Pool and List proposals take `minLiquidity` as a 128-bit number, like the listing rows.
+2. BalanceGas and PayGas show the vault's combined gas rules and the current maximum.
+3. Under Dst 1 or 2 the hours read "UTC-5" or "UTC-4" instead of New York time.
+4. PaymentFailed and BalanceUnreadable name the stock; a failing Claim all says which stock blocked the batch.
+5. MathOverflow and InvalidTick have plain words.
+6. The reopen countdown follows block time; once the opening is reached the page re-reads the vault and says deposits may be open.
+7. Dates are in words (see Integration).
+8. FreshCount 0 reads "off"; other values read in words.
+9. Vault and Deposit show the hours in words only; Owner keeps the raw seconds.
+10. The Launch panel says when the listed stocks are unreadable.
+11. Redeem preview amounts follow each stock's index and are hidden when the stock list is unreadable.
+12. Pool liquidity words use the vault's `poolWindow` and `poolDeviation`.
+13. Once a pending listing transaction is mined or replaced, the page says so; a transaction cancelled or replaced in the wallet is never reported as Confirmed.
+14. Finalize needs the pasted listing rows and refuses rows listed with other values.
+15. Under Dst 0 an Hours start on Sunday 2:00-2:59 am is refused (that hour is skipped on the spring-forward Sunday).
+16. The vault itself is refused as new owner, guardian or fee recipient.
+
+What the checks allow in this update:
+
+- `check-bundle.mjs`: in `web/src` only the look files (components, Vault, Flows, Docs, styles, main, Scenery) and the fix files (chain, model, newYork, governance, Owner, wallet) change; Losses, poolMath, deployment and the ABI stay as they were; `web/pinned`, `web/index.html`, the build configuration and the validation fixtures are unchanged; in `web/public` only `favicon.svg` changes, and it and `dist/favicon.svg` must have the chosen icon's SHA-256; no file is added.
+- `check-calldata.mjs`: main and Scenery equal HEAD once their one edit is put back. In every source file the vault, token, feed and read calls, the argument parsers and encoders and every wallet send or raw provider request equal HEAD, apart from the listed fix changes; sends and requests have no exception at all, and Vault, Scenery, main and Docs have none. Vault.tsx makes no read, check or send call; its controls equal a pinned list (the Retry vault button and address links, plus the Stock shelves' Details, Close, filters, search and Show all) and the shelves' handlers equal their pinned text. The changed Owner actions and the governance argument builders equal HEAD once their listed pieces are put back, and the new refusal helpers equal their pinned text. HEAD's and the new encoders are run side by side on thousands of inputs, under fixed clocks for the deadline: same calldata, and only the listed new refusals.
+- `check-art.mjs` (Chromium and WebKit): the title characters, the tagline gone, the other pages' eyebrows unchanged, the footer, the slogan strip rule, and the Stock shelves (one label per listed stock with ticker, price, status and Details, inside the shelf unit, at least 44px to tap, no old stock cards, still under reduced motion; the unit's food strip shows its first row only). `check-motion.mjs` (Chromium, three display scales): the same strip rule while scrolling, and the shelves' swing runs once per label and stops.
+- `check-visibility.mjs`: only the Vault tagline may disappear from the first phone screen; title text pushed down by her picture is listed with its reason.
+- `check-interface.ts`: unit cases for the fixes and the date rounding.
+
+The fork runner's 24 screenshots are JPEG quality 36 (40 before): with the Docs FAQ and the longer Owner texts the quality-40 set no longer fits the 8 MiB delivery budget. So run `run-browser.mjs` before `check-bundle.mjs` (as in the list above): until the runner rewrites the 24 screenshots, the tree still holds the quality-40 set and the bundle reads over the limit.
diff --git a/web/public/favicon.svg b/web/public/favicon.svg
index 3070648..50345f9 100644
--- a/web/public/favicon.svg
+++ b/web/public/favicon.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><rect width="64" height="64" rx="8" fill="#174bc1"/><path d="m10 26 7 29h30l7-29ZM19 27 29 9m16 18L35 9M24 34v13m8-13v13m8-13v13" fill="none" stroke="#ffdb29" stroke-width="5" stroke-linejoin="round"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><rect width="64" height="64" fill="#ffdb29"/><rect x="5" y="5" width="54" height="54" fill="#df2029"/><g transform="translate(9.6 12.4) scale(0.56)" fill="none" stroke="#ffdb29" stroke-width="7" stroke-linejoin="round" stroke-linecap="round"><path d="M9 28h62L63 62H17L9 28Z"/><path d="M23 28 35 8M57 28 45 8M28 39v12M40 39v12M52 39v12M6 28h68"/></g></svg>
\ No newline at end of file
diff --git a/web/scripts/check-art.mjs b/web/scripts/check-art.mjs
index ca02070..e4ec09f 100644
--- a/web/scripts/check-art.mjs
+++ b/web/scripts/check-art.mjs
@@ -13,7 +13,7 @@ const manifest = JSON.parse(manifestBytes), hashes = [];
 for (const dir of ["web/public", "dist"]) {
   const expected = manifest.files.map(f => f.path).sort();
   const actual = fs.readdirSync(path.join(root, dir, "art"), {recursive:true, withFileTypes:true})
-    .filter(e => e.isFile()).map(e => path.relative(path.join(root,dir),path.join(e.parentPath,e.name))).sort();
+    .filter(e => e.isFile()).map(e => path.relative(path.join(root,dir),path.join(e.parentPath,e.name)).split(path.sep).join("/")).sort();
   assert.deepEqual(actual, expected);
   for (const f of manifest.files) {
     const b = fs.readFileSync(path.join(root, dir, f.path));
@@ -22,11 +22,67 @@ for (const dir of ["web/public", "dist"]) {
     hashes.push({path: `${dir}/${f.path}`, bytes:b.length, sha256:sha(b)});
   }
 }
+// Look update: the pop-out title character on Vault, Deposit and Redeem.
+const LINES = {vault:"I was hoping you would come through my aisle", deposit:"Go ahead and put it in", redeem:"are you sure that’s all you came here for?"};
+// Picture regions in natural pixels [x0, y0, x1, y1]. The bubble may cover no opaque pixel of the picture and none of
+// these boxes; its tail may cover no opaque pixel of the face (mouth included), hands or held items; the title text
+// may cover no opaque pixel of the figure.
+const REGIONS = {
+  vault: {w:606, h:1000, face:[150,55,300,212], raisedHand:[22,12,118,128], restingHand:[345,476,430,532], crate:[290,405,596,902]},
+  deposit: {w:313, h:1000, face:[78,58,208,205], leftHand:[30,282,96,348], rightHand:[218,282,282,348], basket:[10,296,293,505]},
+  redeem: {w:484, h:1000, face:[240,52,372,214], bag:[12,42,306,448], leftHand:[58,358,136,450], rightHand:[178,378,268,452]},
+};
+const pictureHeight = width => width >= 1000 ? 390 : width >= 661 ? 340 : width >= 360 ? 300 : 270;
+const bundle = fs.readdirSync(path.join(root, "dist/assets")).filter(f => f.endsWith(".js")).map(f => fs.readFileSync(path.join(root, "dist/assets", f), "utf8")).join("\n");
+for (const line of Object.values(LINES)) assert.ok(bundle.includes(line), line);
+assert.ok(bundle.includes("A different receiver must connect here to claim any stocks still owed to it."), "receiver wording");
+for (const gone of ["hehe", "WOW!", "Unsent stocks are owed", "must connect to claim", "vault-hero", "clerk-panel", "picture-stage"]) assert.ok(!bundle.includes(gone), "removed from the bundle: " + gone);
+// v9 A4: the old tagline is gone from the whole built site (page, scripts, styles, icon), in any letter case.
+const TAGLINE = /one\s+basket/i;
+for (const f of fs.readdirSync(path.join(root, "dist"), {recursive:true}).map(String).filter(f => /\.(html|js|css|svg|json|txt)$/.test(f)))
+  assert.doesNotMatch(fs.readFileSync(path.join(root, "dist", f), "utf8"), TAGLINE, "tagline in dist/" + f);
+// The other pages keep their eyebrow (HEAD text); the Vault title has none.
+const EYEBROWS = {vault:null, deposit:"Fill your basket", redeem:"At the checkout", docs:"Know your basket", owner:"Behind the counter", losses:"Accounting health"};
+// v9 A2 slogan strip: each half shows k whole slogan lines (one line is 720 px), k = the fewest lines that cover the
+// viewport (1 up to 720 px, 2 up to 1440 px, ... 8 from 5041 px); 45 s per line (16 px/s), 11.25 s at 660 px and
+// below (64 px/s); the moving block is at most two screens plus two lines wide and has no will-change.
+const SLOGAN = "Basket buddies! • Take a stroll down the aisles • Give your cart a twirl • ";
+const stripLines = width => Math.min(8, Math.max(1, Math.ceil(width / 720)));
+// In the page: the strip's geometry, with the animation paused at `fraction` of its loop (null: leave it). `joins` are
+// the gaps from the last glyph of each shown line to the first glyph of the next one (inside a half and across the
+// seam between the halves), `wordGap` the normal gap between a bullet and the next word.
+function stripGeometry(fraction) {
+  const track = document.querySelector(".marquee-track"), win = track.parentElement, a = track.getAnimations();
+  if (fraction !== null && a[0]) { a[0].pause(); a[0].currentTime = a[0].effect.getTiming().duration * fraction; }
+  const R = e => e.getBoundingClientRect();
+  const glyph = (span, i) => {
+    const w = document.createTreeWalker(span, NodeFilter.SHOW_TEXT);
+    for (let n, k = i; (n = w.nextNode()); k -= n.length) if (k < n.length) { const rg = document.createRange(); rg.setStart(n, k); rg.setEnd(n, k + 1); return rg.getBoundingClientRect(); }
+    return null;
+  };
+  const halves = [...track.children].map(h => ({text: h.textContent, width: R(h).width, minWidth: getComputedStyle(h).minWidth,
+    spans: [...h.children].map(s => ({text: s.textContent, display: getComputedStyle(s).display, width: R(s).width}))}));
+  const shown = [...track.children].map(h => [...h.children].filter(s => getComputedStyle(s).display !== "none"));
+  const run = shown.flat(), text = run[0].textContent, last = text.trimEnd().length - 1, bullet = text.indexOf("•");
+  const wordGap = glyph(run[0], bullet + 2).left - glyph(run[0], bullet).right;
+  const joins = run.slice(1).map((s, i) => glyph(s, 0).left - glyph(run[i], last).right);
+  const t = R(track), w = R(win), cs = getComputedStyle(track);
+  // Box edges, exact in both engines: the shown lines sit edge to edge from the track's left end to its right end,
+  // each line box as wide as its text (WebKit rounds single-glyph boxes to whole pixels, so glyph gaps get a looser bound).
+  const boxes = run.map(R), halfBoxes = [...track.children].map(R);
+  const edges = [boxes[0].left - t.left, t.right - boxes[boxes.length - 1].right, halfBoxes[0].left - t.left, halfBoxes[1].left - halfBoxes[0].right, t.right - halfBoxes[1].right,
+    ...boxes.slice(1).map((b, i) => b.left - boxes[i].right)];
+  const textWidths = run.map(sp => { const rg = document.createRange(); rg.selectNodeContents(sp); return R(sp).width - rg.getBoundingClientRect().width; });
+  return {halves, shownCounts: shown.map(s => s.length), track: t.width, frame: w.width, viewport: innerWidth, wordGap, joins,
+    lead: glyph(run[0], 0).left - t.left, tail: t.right - glyph(run[run.length - 1], last).right, edges, textWidths,
+    covers: t.left <= w.left + 0.01 && t.right >= w.right - 0.01, offset: t.left - w.left, running: a.filter(x => x.playState === "running").length, willChange: cs.willChange, animationName: cs.animationName,
+    transform: cs.transform, duration: a[0]?.effect.getTiming().duration, contain: getComputedStyle(win).contain, isolation: getComputedStyle(win).isolation};
+}
 const server = http.createServer((req,res) => {
   const parts = req.url.split("/");
   const dir = parts[1] === "baseline" ? process.env.BASKET_BASELINE_DIST : path.join(root,"dist");
   const p = path.resolve(dir, parts.slice(2).join("/") || "index.html");
-  if (!p.startsWith(dir+"/")) return res.writeHead(403).end();
+  if (!p.startsWith(dir+path.sep)) return res.writeHead(403).end();
   try {
     res.setHeader("Content-Type", ({".html":"text/html",".js":"application/javascript",".css":"text/css",".webp":"image/webp",".svg":"image/svg+xml",".woff2":"font/woff2"})[path.extname(p)] || "text/plain");
     res.end(fs.readFileSync(p));
@@ -34,7 +90,122 @@ const server = http.createServer((req,res) => {
 });
 await new Promise(r=>server.listen(0,"127.0.0.1",r));
 const base = `http://127.0.0.1:${server.address().port}`;
-const checks=[], visibility=[], bubbles=[];
+// Title panel geometry in the page: bubble words, bubble/strip/frame edges and the wallet hint gap; with `pixels`, the
+// picture pixels under the bubble, its tail and the title text.
+function titleGeometry({R, name, pixels}) {
+  const title = document.querySelector(".page-title"), r = e => e.getBoundingClientRect();
+  const holder = title.querySelector(":scope > .title-character"), img = holder.querySelector("img.character-picture"), bubble = holder.querySelector("p.speech-bubble");
+  const T = r(title), br = r(bubble), ir = r(img), cs = getComputedStyle(bubble), bw = parseFloat(getComputedStyle(title).borderTopWidth), bl = parseFloat(cs.borderLeftWidth);
+  const out = {overflow: document.documentElement.scrollWidth > innerWidth, split: [], wordOutside: []};
+  const tn = bubble.firstChild, lines = new Set();
+  for (const m of tn.textContent.matchAll(/\S+/g)) {
+    const rg = document.createRange(); rg.setStart(tn, m.index); rg.setEnd(tn, m.index + m[0].length);
+    const tops = new Set([...rg.getClientRects()].filter(x => x.width > 0).map(x => Math.round(x.top)));
+    if (tops.size !== 1) out.split.push(m[0]);
+    tops.forEach(t => lines.add(t));
+    const wr = rg.getBoundingClientRect();
+    if (wr.left < br.left + bl - 0.5 || wr.right > br.right - bl + 0.5 || wr.top < br.top + bl - 0.5 || wr.bottom > br.bottom - bl + 0.5) out.wordOutside.push(m[0]);
+  }
+  out.bubbleLines = lines.size;
+  const after = getComputedStyle(title, "::after"), stripTop = T.bottom - bw - parseFloat(after.height) - parseFloat(after.borderTopWidth);
+  const textRects = [title.querySelector(":scope > .eyebrow"), title.querySelector(":scope > h1"), title.querySelector(":scope > p:last-of-type")]
+    .filter(Boolean).flatMap(e => { const rg = document.createRange(); rg.selectNodeContents(e); return [...rg.getClientRects()].filter(x => x.width > 0); });
+  out.textToStrip = stripTop - Math.max(...textRects.map(x => x.bottom));
+  // v9 A4: the title text block (eyebrow, or the heading where there is none, down to the sentence) is centred
+  // vertically beside her on wider screens; on phones the Vault heading starts 17 px under her shelf.
+  const firstText = title.querySelector(":scope > .eyebrow") ?? title.querySelector(":scope > h1");
+  out.firstText = firstText.tagName;
+  out.textAbove = r(firstText).top - (T.top + bw + parseFloat(getComputedStyle(title).paddingTop));
+  out.textBelow = stripTop - parseFloat(after.marginTop) - r(title.querySelector(":scope > p:last-of-type")).bottom;
+  out.textUnderHolder = r(firstText).top - r(holder).bottom;
+  out.phone = innerWidth <= 660;
+  out.name = name;
+  out.bubbleInFrame = br.left >= T.left + bw - 0.5 && br.right <= T.right - bw + 0.5 && br.top >= T.top + bw - 0.5 && br.bottom <= stripTop + 0.5;
+  const hit = (a, b) => a.left < b.right && b.left < a.right && a.top < b.bottom && b.top < a.bottom;
+  out.textOnBubble = textRects.some(x => hit(x, br));
+  const reg = R[name], ratio = reg.w / reg.h;
+  let dw = ir.width, dh = ir.height;
+  if (ir.width / ir.height > ratio) dw = ir.height * ratio; else dh = ir.width / ratio;
+  const D = {x: ir.left + (ir.width - dw) / 2, y: ir.bottom - dh, w: dw, h: dh}, sx = dw / reg.w, sy = dh / reg.h;
+  const keys = Object.keys(reg).filter(k => !["w", "h"].includes(k));
+  const box = k => { const [a, b, c, d] = reg[k]; return {left: D.x + a * sx, top: D.y + b * sy, right: D.x + c * sx, bottom: D.y + d * sy}; };
+  out.bubbleOnRegions = keys.filter(k => hit(br, box(k)));
+  out.picture = {x: D.x, y: D.y, w: D.w, h: D.h, elementHeight: ir.height};
+  out.bubble = {x: br.x, y: br.y, w: br.width, h: br.height};
+  out.popAboveFrame = T.top - (D.y + 8 * sy);
+  out.pictureInView = D.x >= 0 && D.x + D.w <= innerWidth;
+  out.clipped = [];
+  for (let e = img.parentElement; e && e !== document.documentElement; e = e.parentElement) {
+    const c = getComputedStyle(e);
+    if (c.overflowX !== "visible" || c.overflowY !== "visible" || c.clipPath !== "none" || c.contain.includes("paint")) {
+      const er = r(e);
+      if (D.x < er.left - 0.5 || D.x + D.w > er.right + 0.5 || D.y < er.top - 0.5 || D.y + D.h > er.bottom + 0.5) out.clipped.push(e.className || e.tagName);
+    }
+  }
+  const wh = document.querySelector(".wallet-help");
+  if (wh) {
+    const btn = wh.querySelector("button"), rg = document.createRange();
+    rg.selectNodeContents(wh); rg.setEndBefore(btn);
+    const rs = [...rg.getClientRects()].filter(x => x.width > 0), b = r(btn), W = r(wh);
+    const t = {left: Math.min(...rs.map(x => x.left)), right: Math.max(...rs.map(x => x.right)), top: Math.min(...rs.map(x => x.top)), bottom: Math.max(...rs.map(x => x.bottom))};
+    const sameRow = b.top < t.bottom && t.top < b.bottom;
+    out.walletGap = sameRow ? b.left - t.right : b.top - t.bottom;
+    out.walletInside = b.right <= W.right + 0.5 && t.right <= W.right + 0.5;
+  }
+  if (pixels) {
+    const canvas = document.createElement("canvas"); canvas.width = reg.w; canvas.height = reg.h;
+    const g = canvas.getContext("2d"); g.drawImage(img, 0, 0, reg.w, reg.h);
+    const A = g.getImageData(0, 0, reg.w, reg.h).data;
+    const regionOf = (ix, iy) => keys.find(k => { const [a, b, c, d] = reg[k]; return ix >= a && ix <= c && iy >= b && iy <= d; }) || "other";
+    const scan = (rc, test) => {
+      const found = {};
+      for (let py = Math.floor(Math.max(rc.top, D.y)); py < Math.min(rc.bottom, D.y + D.h); py++)
+        for (let px = Math.floor(Math.max(rc.left, D.x)); px < Math.min(rc.right, D.x + D.w); px++) {
+          if (test && !test(px + 0.5, py + 0.5)) continue;
+          const ix = Math.floor((px + 0.5 - D.x) / sx), iy = Math.floor((py + 0.5 - D.y) / sy);
+          if (ix < 0 || iy < 0 || ix >= reg.w || iy >= reg.h || A[(iy * reg.w + ix) * 4 + 3] <= 60) continue;
+          const k = regionOf(ix, iy); found[k] = (found[k] || 0) + 1;
+        }
+      return found;
+    };
+    out.bubbleCovers = scan(br);
+    const before = getComputedStyle(bubble, "::before");
+    const ys = before.clipPath.replace(/^polygon\(|\)$/g, "").split(/,\s*(?![^(]*\))/).map(p => parseFloat(p.trim().split(/\s+(?![^(]*\))/).pop()));
+    const ox = br.left + bl, oy = br.top + parseFloat(cs.borderTopWidth) + parseFloat(before.top);
+    const tip = {x: ox + parseFloat(before.left), y: oy + ys[0]}, b1 = {x: ox, y: oy + ys[1]}, b2 = {x: ox, y: oy + ys[2]};
+    const side = (p, q, s) => (p.x - s.x) * (q.y - s.y) - (q.x - s.x) * (p.y - s.y);
+    const inTail = (x, y) => { const P = {x, y}, d1 = side(P, tip, b1), d2 = side(P, b1, b2), d3 = side(P, b2, tip); return !((d1 < 0 || d2 < 0 || d3 < 0) && (d1 > 0 || d2 > 0 || d3 > 0)); };
+    out.tail = {tip, b1, b2};
+    out.tailCovers = scan({left: Math.min(tip.x, ox), top: Math.min(tip.y, b1.y), right: Math.max(tip.x, ox), bottom: b2.y}, inTail);
+    out.textCovers = textRects.reduce((n, x) => n + Object.values(scan(x)).reduce((s, v) => s + v, 0), 0);
+  }
+  return out;
+}
+function assertGeometry(g, label, pixels) {
+  assert.equal(g.overflow, false, `${label} overflow`);
+  assert.deepEqual(g.split, [], `${label}: a bubble word is split`);
+  assert.deepEqual(g.wordOutside, [], `${label}: bubble text outside the bubble`);
+  assert.ok(g.textToStrip >= 12, `${label}: checker strip touches the title text (${g.textToStrip})`);
+  assert.equal(g.firstText, g.name === "vault" ? "H1" : "P", `${label}: the Vault title has no eyebrow, the others keep theirs`);
+  if (!g.phone) assert.ok(Math.abs(g.textAbove - g.textBelow) < 0.5, `${label}: title text not centred beside her (${g.textAbove} above, ${g.textBelow} below)`);
+  else if (g.name === "vault") assert.ok(Math.abs(g.textUnderHolder - 17) < 0.5, `${label}: Vault heading not 17 px under her shelf (${g.textUnderHolder})`);
+  assert.equal(g.bubbleInFrame, true, `${label}: bubble outside the title frame`);
+  assert.equal(g.textOnBubble, false, `${label}: title text under the bubble`);
+  assert.deepEqual(g.bubbleOnRegions, [], `${label}: bubble on face, hands or held item`);
+  assert.ok(g.popAboveFrame > 0, `${label}: head does not rise above the panel`);
+  assert.equal(g.pictureInView, true, `${label}: picture outside the viewport`);
+  assert.deepEqual(g.clipped, [], `${label}: picture clipped`);
+  assert.ok(g.walletGap >= 8, `${label}: wallet hint gap ${g.walletGap}`);
+  assert.equal(g.walletInside, true, `${label}: wallet hint outside its box`);
+  if (pixels) {
+    assert.deepEqual(g.bubbleCovers, {}, `${label}: bubble covers the picture`);
+    assert.deepEqual(Object.keys(g.tailCovers).filter(k => k !== "other"), [], `${label}: tail covers face, hands or held item`);
+    assert.equal(g.textCovers, 0, `${label}: title text on the figure`);
+  }
+}
+// A hash change re-renders asynchronously: wait until the requested route is the current page before measuring it.
+const routeShown = name => !!document.querySelector(`a[aria-current="page"][href="#${name}"]`);
+const checks=[], visibility=[], bubbles=[], shelfCounts=[];
 let browser;
 try {
   for (const [engine, launcher] of [["Chromium",chromium],["WebKit",webkit]]) {
@@ -44,66 +215,179 @@ try {
       try { const res=await fetch(route.request().url(), {method:"POST",headers:{"content-type":"application/json"},body:route.request().postData(),signal:AbortSignal.timeout(20000)}); await route.fulfill({body:await res.text(),contentType:"application/json"}); }
       catch {await route.abort();}
     });
-    for (const width of [375,2560]) {
+    const strips=[];
+    for (const width of [320,375,660,661,720,721,1024,1440,1441,1920,2160,2161,2560,2880,2881,3440,3600,3601,4320,4321,5040,5041,5760]) {
       await page.setViewportSize({width,height:1000});
       await page.goto(base+"/preview/#deposit");
+      await page.waitForFunction(routeShown,"deposit");
       await page.evaluate(()=>document.fonts.ready);
       assert.equal(await page.locator('.marquee button').count(),0);
-      const track=page.locator('.marquee-track');
-      const geometry=await track.evaluate(e=>({halves:[...e.children].map(c=>({width:c.getBoundingClientRect().width,text:c.textContent})),frame:e.parentElement.clientWidth,contain:getComputedStyle(e.parentElement).contain,isolation:getComputedStyle(e.parentElement).isolation,duration:e.getAnimations()[0].effect.getTiming().duration}));
-      assert.equal(geometry.halves[0].text,geometry.halves[1].text);
-      assert.ok(Math.abs(geometry.halves[0].width-geometry.halves[1].width)<0.01, "Identical halves within compositor subpixel rounding");
-      assert.ok(geometry.halves[0].width>=geometry.frame);
-      assert.equal(geometry.contain,"none"); assert.equal(geometry.isolation,"auto");
-      assert.equal(geometry.duration,width===375?45000:180000);
-      for (const fraction of [0,.25,.5,.75,.99999,1]) {
-        assert.equal(await track.evaluate((e,f)=>{const a=e.getAnimations()[0];a.pause();a.currentTime=a.effect.getTiming().duration*f;const r=e.getBoundingClientRect(),p=e.parentElement.getBoundingClientRect();return r.left<=p.left&&r.right>=p.right;},fraction),true);
-        await page.locator('.marquee').screenshot({path:path.join(captures,`${engine}-loop-${width}-${fraction}.png`)});
+      const k=stripLines(width),per=width<=660?11250:45000,label=`${engine} strip ${width}`;
+      const g=await page.evaluate(stripGeometry,null);
+      assert.equal(g.viewport,width,label);
+      assert.equal(g.halves.length,2,label+': two halves');
+      for(const h of g.halves) {
+        assert.equal(h.spans.length,8,label+': eight lines in the markup of each half');
+        for(const s of h.spans) assert.equal(s.text,SLOGAN,label+': line text');
+        assert.equal(h.minWidth,'auto',label+': no min-width on a half');
+        h.spans.forEach((s,i)=>{assert.equal(s.display==='none',i>=k,label+`: line ${i+1} shown only when k=${k} needs it`);if(i<k)assert.ok(Math.abs(s.width-720)<0.5,label+': one line is 720 px, not '+s.width);});
+      }
+      assert.deepEqual(g.shownCounts,[k,k],label+': k whole lines per half');
+      assert.equal(g.halves[0].text,g.halves[1].text,label+': identical halves');
+      assert.ok(Math.abs(g.halves[0].width-g.halves[1].width)<0.01,label+': equal halves');
+      assert.ok(Math.abs(g.halves[0].width-k*720)<0.5*k,label+': half = k lines, not '+g.halves[0].width);
+      assert.ok(k*720>=width&&g.halves[0].width>=g.frame-0.01,label+': k lines cover the viewport');
+      if(k>1&&width<=5760) assert.ok((k-1)*720<width,label+': the fewest lines that cover it');
+      assert.ok(g.track<=2*(width+720)+0.5,label+': moving block '+g.track+' px is over two screens plus two lines');
+      assert.equal(g.willChange,'auto',label+': no will-change');
+      assert.equal(g.contain,"none"); assert.equal(g.isolation,"auto");
+      assert.equal(g.animationName,'shop-scroll',label);
+      assert.ok(Math.abs(g.duration-k*per)<0.5,label+': loop '+g.duration+' ms');
+      assert.ok(Math.abs(g.halves[0].width/(g.duration/1000)-(width<=660?64:16))<0.05,label+': speed');
+      for (const fraction of [0,.1,.25,.5,.75,.9,.99999,1]) {
+        const s=await page.evaluate(stripGeometry,fraction);
+        assert.equal(s.covers,true,label+': strip window covered at '+fraction);
+        assert.ok(s.wordGap>0,label+': word gap');
+        // Line boxes edge to edge (no margin, padding or stretch anywhere in the track), each as wide as its text.
+        for(const e of s.edges) assert.ok(Math.abs(e)<0.01,label+': line boxes not edge to edge '+JSON.stringify(s.edges));
+        for(const e of s.textWidths) assert.ok(Math.abs(e)<1,label+': a line box wider than its text '+JSON.stringify(s.textWidths));
+        // Glyphs: WebKit reports single-glyph boxes rounded out to whole pixels (each edge up to 1 px off), hence 2.5 px
+        // there; a blank stretch would be a whole line (720 px) or more, and the box edges above are exact.
+        const tol=engine==='WebKit'?2.5:0.5;
+        assert.ok(Math.abs(s.lead)<tol,label+': text starts at the left end of the track '+s.lead);
+        assert.ok(Math.abs(s.tail-s.wordGap)<tol,label+': the track ends one space after the last bullet '+[s.tail,s.wordGap]);
+        assert.equal(s.joins.length,2*k-1);
+        for(const j of s.joins) assert.ok(Math.abs(j-s.wordGap)<tol,label+`: gap ${j} between lines (or across the seam) is not the word gap ${s.wordGap} at ${fraction}`);
+        if([375,1440,3440].includes(width)) await page.locator('.marquee').screenshot({path:path.join(captures,`${engine}-loop-${width}-${fraction}.png`)});
       }
       await page.emulateMedia({reducedMotion:"reduce"});
-      assert.equal(await track.evaluate(e=>getComputedStyle(e).animationName),"none");
+      await page.evaluate(()=>new Promise(r=>requestAnimationFrame(()=>requestAnimationFrame(r))));
+      const still=await page.evaluate(stripGeometry,null);
+      assert.equal(still.animationName,"none",label+': reduced motion');
+      assert.ok(Math.abs(still.offset)<0.01&&still.running===0&&['none','matrix(1, 0, 0, 1, 0, 0)'].includes(still.transform),label+': reduced motion still '+JSON.stringify([still.offset,still.running,still.transform]));
+      assert.equal(still.covers,true,label+': still strip full');
+      assert.deepEqual(still.shownCounts,[k,k]);
       await page.emulateMedia({reducedMotion:"no-preference"});
-      checks.push(`${engine} ${width}: equal full-width halves, sampled complete loop, 45/180s, overflow only, no pause, reduced motion still`);
+      strips.push(`${width}:${k}/${Math.round(g.track)}/${g.duration / 1000}s`);
     }
+    checks.push(`${engine} slogan strip, width:lines per half/track px/loop [${strips.join(' ')}]: eight lines in the markup of each half, the first k shown (k = the fewest 720 px lines covering the viewport), identical halves, track <= 2 x (viewport + 720), no will-change, 16 px/s (64 px/s at 660 px and below); at 8 loop positions the window is covered, line boxes sit edge to edge and every line join and the seam between the halves has the normal word gap; reduced motion still and full`);
     await page.emulateMedia({reducedMotion:"reduce"});
-    for(const width of [1440,960,800,661,660,375,320]) {
+    for(const width of [1440,1000,999,960,800,720,661,660,375,360,359,320]) {
       await page.setViewportSize({width,height:width===375?812:1000});
       for(const name of ["vault","deposit","redeem","docs","owner","losses"]) {
         await page.goto(base+"/preview/#"+name);
+        await page.waitForFunction(routeShown,name);
         await page.evaluate(()=>document.fonts.ready);
         await page.waitForFunction(()=>[...document.images].every(i=>i.complete&&i.naturalWidth>0));
         assert.equal(await page.evaluate(()=>document.documentElement.scrollWidth>innerWidth),false,`${engine} ${name} ${width} overflow`);
-        const shelf=await page.locator('.store-shelf').evaluateAll(es=>es.map(e=>[...e.children].map(row=>({width:row.clientWidth,last:row.lastElementChild.getBoundingClientRect().right,right:row.getBoundingClientRect().right,icons:[...row.children].map(i=>({src:i.getAttribute('src'),w:i.getBoundingClientRect().width,h:i.getBoundingClientRect().height,alt:i.alt,transform:getComputedStyle(i).transform}))}))));
+        const shelf=await page.locator('.store-shelf').evaluateAll(es=>es.map(e=>({unit:!!e.closest('.stock-section .sa-unit'),rows:[...e.children].map(row=>({display:getComputedStyle(row).display,width:row.clientWidth,last:row.lastElementChild.getBoundingClientRect().right,right:row.getBoundingClientRect().right,icons:[...row.children].map(i=>({src:i.getAttribute('src'),w:i.getBoundingClientRect().width,h:i.getBoundingClientRect().height,alt:i.alt,transform:getComputedStyle(i).transform}))}))})));
         assert.equal(shelf.length,name==='vault'?2:1);
+        // v9 Stock shelves: on Vault the second shelf is the top shelf of the stock shelf unit, which shows only its
+        // first food row (by design); every other shelf row is shown and filled to its end.
+        assert.equal(shelf.filter(s=>s.unit).length,name==='vault'?1:0,`${engine} ${name} ${width}: food shelf inside the Stock shelves unit`);
         const foods=manifest.files.filter(f=>f.path.endsWith('.svg'));
-        for(const rows of shelf) for(let n=0;n<2;n++) {
+        for(const {unit,rows} of shelf) for(let n=0;n<2;n++) {
           const row=rows[n],list=n?foods.slice(14):foods.slice(0,14);
-          assert.ok(row.last>=row.right,`shelf end ${width}`);
+          if(unit&&n===1) assert.equal(row.display,'none',`${engine} ${name} ${width}: the shelf unit shows only its first food row`);
+          else {assert.notEqual(row.display,'none',`${engine} ${name} ${width}: shelf row ${n+1} shown`);assert.ok(row.width>0&&row.icons.length>0,`${engine} ${name} ${width}: shelf row ${n+1} empty`);assert.ok(row.last>=row.right,`shelf end ${width}`);}
           for(let i=0;i<row.icons.length;i++) {const icon=row.icons[i];assert.equal(icon.w,icon.h);assert.equal(icon.alt,'');assert.equal(icon.transform,'none');assert.equal(icon.src,'./'+list[i%list.length].path);}
         }
+        // v9 Stock shelves (shelf-edge labels; the old stock cards are gone): once the vault is read, one label per
+        // listed stock (the All count) with its ticker, price, status and Details button, inside the shelf unit (no
+        // label sticks out sideways), filters and search at least 44 px tall, no motion under reduced motion.
+        if(name==='vault') {
+          await page.waitForFunction(()=>!document.querySelector('button.refresh')?.disabled);
+          const sh=await page.evaluate(()=>{
+            const sec=document.querySelectorAll('.stock-section'),s=sec[0],R=e=>e.getBoundingClientRect(),unit=s?.querySelector(':scope .sa-unit');
+            const labels=[...s.querySelectorAll('article.sa-label')].map(l=>({ticker:l.querySelector('h4')?.textContent??'',price:!!l.querySelector('.sa-price'),status:l.querySelector('.sa-st')?.textContent??'',more:l.querySelector('button.sa-more')?.getAttribute('aria-expanded'),left:R(l).left,right:R(l).right,height:R(l).height,inSlot:!!l.parentElement?.matches('li.sa-slot')&&!!l.closest('ul.sa-shelves[role="list"]')}));
+            const all=s.querySelector('.sa-filters button');
+            return {sections:sec.length,heading:s.querySelector(':scope > .section-heading h2')?.textContent,old:document.querySelectorAll('.stock-grid, .stock-card').length,unit:unit?{left:R(unit).left,right:R(unit).right}:null,labels,
+              all:all?Number(all.querySelector('.sa-count')?.textContent):null,allName:all?.firstChild?.textContent?.trim(),controls:[...s.querySelectorAll('.sa-filters button, .sa-search input')].map(e=>R(e).height),
+              moving:document.getAnimations().filter(a=>a.effect?.target?.closest?.('.stock-section')).length};
+          });
+          assert.equal(sh.sections,1,`${engine} vault ${width}: one Stock shelves panel`);
+          assert.equal(sh.heading,'Stock shelves');
+          assert.equal(sh.old,0,`${engine} vault ${width}: old stock cards`);
+          assert.ok(sh.unit,`${engine} vault ${width}: shelf unit`);
+          if(sh.all!==null) {
+            assert.equal(sh.allName,'All');
+            assert.equal(sh.labels.length,sh.all,`${engine} vault ${width}: one label per listed stock`);
+            assert.ok(sh.all>0);
+            for(const l of sh.labels) {
+              assert.ok(l.ticker.length>0&&l.price&&/^(Open|Closed|Retired)/.test(l.status)&&l.more==='false'&&l.inSlot,`${engine} vault ${width}: label ${JSON.stringify(l)}`);
+              assert.ok(l.left>=sh.unit.left-0.5&&l.right<=sh.unit.right+0.5,`${engine} vault ${width}: label ${l.ticker} outside the shelf unit`);
+              assert.ok(l.height>=44,`${engine} vault ${width}: label ${l.ticker} tap height ${l.height}`);
+            }
+            assert.equal(sh.controls.length,5);
+            for(const h of sh.controls) assert.ok(h>=44,`${engine} vault ${width}: filter/search height ${h}`);
+          }
+          assert.equal(sh.moving,0,`${engine} vault ${width}: motion in the Stock shelves under reduced motion`);
+          shelfCounts.push(`${engine} ${width}:${sh.labels.length}`);
+        }
+        // The old picture frames and the WOW! burst are gone everywhere; the Fresh! burst stays on the Stock shelves panel.
+        assert.equal(await page.locator('.vault-hero, .clerk-panel, .picture-stage, .deposit-picture, .redeem-picture').count(),0,`${engine} ${name} old frames`);
+        assert.equal(await page.getByText('WOW!').count(),0,`${engine} ${name} WOW!`);
+        assert.equal(await page.locator('.burst').count(),name==='vault'?1:0,`${engine} ${name} bursts`);
+        if(name==='vault') assert.equal(await page.locator('.stock-section .section-heading .burst.small').innerText(),'Fresh!');
+        // v9 A4: the tagline is nowhere on the page; the Vault title has no eyebrow (no empty one either), the other pages
+        // keep theirs; the footer is the basket icon, "Basket Protocol" and the links.
+        const words=await page.evaluate(()=>{const t=document.querySelector('.page-title'),e=t.querySelector(':scope > .eyebrow');return {eyebrow:e?e.textContent:null,eyebrows:t.querySelectorAll(':scope > p.eyebrow').length,first:t.firstElementChild.tagName,body:document.body.textContent,title:document.title,footer:[...document.querySelector('footer > div').children].map(c=>c.tagName.toLowerCase()+(c.getAttribute('class')?'.'+c.getAttribute('class'):'')+(c.tagName==='STRONG'?':'+c.textContent:''))};});
+        assert.equal(words.eyebrow,EYEBROWS[name],`${engine} ${name} eyebrow`);
+        assert.equal(words.eyebrows,name==='vault'?0:1,`${engine} ${name} eyebrow count`);
+        assert.equal(words.first,name==='vault'?'H1':'P',`${engine} ${name} first title element`);
+        assert.doesNotMatch(words.body+' '+words.title,TAGLINE,`${engine} ${name} tagline on the page`);
+        assert.deepEqual(words.footer,['svg.basket-icon','strong:Basket Protocol','span.footer-links'],`${engine} ${name} footer`);
         if(['vault','deposit','redeem'].includes(name)) {
-          const picture=await page.locator('.character-picture').evaluate(e=>({width:e.getAttribute('width'),height:e.getAttribute('height'),fit:getComputedStyle(e).objectFit,position:getComputedStyle(e).objectPosition,display:getComputedStyle(e).display,h:e.getBoundingClientRect().height,src:e.getAttribute('src')}));
+          assert.equal(await page.locator(`.page-title.has-character.character-${name}`).count(),1);
+          assert.equal(await page.locator('.character-picture').count(),1,`${engine} ${name} one picture`);
+          assert.equal(await page.locator('.speech-bubble').count(),1,`${engine} ${name} one bubble`);
+          assert.equal(await page.locator(`.page-title.character-${name} > .title-character > img.character-picture + p.speech-bubble`).count(),1,`${engine} ${name} picture and bubble in the title`);
+          assert.equal(await page.locator('aside.panel > :first-child').evaluateAll(es=>es.every(e=>e.tagName==='H2')),true,`${engine} ${name} asides start with their heading`);
+          const picture=await page.locator('.character-picture').evaluate(e=>({width:e.getAttribute('width'),height:e.getAttribute('height'),fit:getComputedStyle(e).objectFit,position:getComputedStyle(e).objectPosition,display:getComputedStyle(e).display,h:e.getBoundingClientRect().height,src:e.getAttribute('src'),alt:e.alt}));
           const f=manifest.files.find(f=>'./'+f.path===picture.src);
+          assert.equal(picture.src,`./art/character/${name}.webp`);
           assert.equal(Number(picture.width),f.width);assert.equal(Number(picture.height),f.height);
+          assert.ok(picture.alt.length>0);
           assert.equal(picture.fit,'contain');assert.equal(picture.position,'50% 100%');assert.equal(picture.display,'block');
-          assert.equal(picture.h,width>960?(name==='vault'?300:320):width>660?260:name==='vault'?200:240);
+          assert.ok(Math.abs(picture.h-pictureHeight(width))<0.01,`${engine} ${name} ${width} picture height ${picture.h}`);
           const bubble=page.locator('.speech-bubble');
-          assert.equal(await bubble.innerText(),({vault:'I was hoping you would come through my aisle',deposit:'Go ahead and put it in hehe',redeem:'are you sure that’s all you came here for?'})[name]);
+          assert.equal(await bubble.innerText(),LINES[name]);
           assert.equal(await bubble.evaluate(e=>getComputedStyle(e).transform),'none');
-          assert.equal(await bubble.evaluate(e=>{const b=e.getBoundingClientRect(),p=e.parentElement.getBoundingClientRect();return b.left>=p.left&&b.right<=p.right&&b.top>=p.top&&b.bottom<=p.bottom;}),true,`${engine} ${name} ${width}: speech stays inside frame`);
+          const geometry=await page.evaluate(titleGeometry,{R:REGIONS,name,pixels:true});
+          assertGeometry(geometry,`${engine} ${name} ${width}`,true);
           if([1440,800,375,320].includes(width)) {
-            await page.locator(name==='vault'?'.vault-hero':'.picture-stage').screenshot({path:path.join(captures,`${engine}-${name}-${width}.png`)});
+            const clip=await page.evaluate(()=>{const t=document.querySelector('.page-title').getBoundingClientRect(),i=document.querySelector('.character-picture').getBoundingClientRect(),top=Math.max(0,Math.min(t.top,i.top)+scrollY-12);return {x:0,y:top,width:innerWidth,height:t.bottom+scrollY+12-top};});
+            await page.screenshot({path:path.join(captures,`${engine}-${name}-${width}.png`),clip,fullPage:true});
             await page.screenshot({path:path.join(captures,`${engine}-${name}-${width}-screen.png`)});
           }
-          const geometry = await page.locator('.character-picture').evaluate(e => {
-            const i=e.getBoundingClientRect(), b=e.parentElement.querySelector('.speech-bubble').getBoundingClientRect();
-            const scale=Math.min(i.width/e.naturalWidth,i.height/e.naturalHeight);
-            return {scale,x:i.x+(i.width-e.naturalWidth*scale)/2,y:i.bottom-e.naturalHeight*scale,bubble:{x:b.x,y:b.y,width:b.width,height:b.height}};
-          });
-          bubbles.push({engine,name,width,picture,geometry});
+          if([1440,800,375,320].includes(width)) bubbles.push(JSON.parse(JSON.stringify({engine,name,width,picture,geometry:{picture:geometry.picture,bubble:geometry.bubble,bubbleLines:geometry.bubbleLines,textToStrip:geometry.textToStrip,popAboveFrame:geometry.popAboveFrame,walletGap:geometry.walletGap}},(k,v)=>typeof v==='number'?Math.round(v*100)/100:v)));
+        } else {
+          assert.equal(await page.locator('.page-title.has-character, .title-character, .character-picture, .speech-bubble').count(),0,`${engine} ${name} no character`);
         }
+        if(name==='redeem') assert.equal(await page.getByText(/Unsent stocks are owed/).count(),0,`${engine} redeem receiver note`);
+        if(name==='docs') {
+          const faq=await page.locator('.docs-grid > .panel').evaluateAll(ps=>{const i=ps.findIndex(p=>p.querySelector('h2')?.textContent==='Redemption'),f=ps[i+1];return {heading:f?.querySelector(':scope > h2')?.textContent,question:f?.querySelector(':scope > h3')?.textContent,answer:f?.querySelector(':scope > p')?.textContent.replace(/\s+/g,' ').trim()};});
+          assert.deepEqual(faq,{heading:'FAQ',question:'What if a stock can’t be sent when I redeem?',answer:'Rarely, a stock can’t be sent at that moment (for example its issuer has paused transfers). The vault then keeps it for the receiver, who collects it later with Claim on the Redeem page. Only the receiver wallet can claim, so redeem to a wallet you control, not an exchange deposit address.'});
+        }
+      }
+      checks.push(`${engine} ${width}: six routes without overflow; both shelf rows filled with ordered square images (the Stock shelves unit on Vault shows its first row only, by design); Stock shelves: one shelf-edge label per listed stock (${shelfCounts.at(-1)?.split(':')[1]}) with ticker, price, status and Details, inside the shelf unit, labels/filters/search at least 44 px, no old stock cards, still under reduced motion; title character inside the title panel with exact speech and picture height, head above the panel, bubble clear of the picture, tail clear of face/hands/items, whole bubble words, strip clear of the text, wallet hint gap; no old frames or WOW!, Fresh! kept; Docs FAQ; no Redeem receiver note; no tagline on the page, Vault title without eyebrow (text centred beside her, or 17 px under her on phones), other eyebrows kept, footer icon/name/links`);
+    }
+    // Every width from 320 to 2560 px: whole bubble words inside the bubble, the strip clear of the title text, the bubble in
+    // its frame and off the picture's face/hands/item boxes, no overflow and a wallet hint gap of at least 8 px.
+    for(const name of ["vault","deposit","redeem"]) {
+      await page.setViewportSize({width:1440,height:1000});
+      await page.goto(base+"/preview/#"+name);
+      await page.waitForFunction(routeShown,name);
+      await page.evaluate(()=>document.fonts.ready);
+      await page.waitForFunction(()=>[...document.images].every(i=>i.complete&&i.naturalWidth>0));
+      const lines={};
+      for(let width=320;width<=2560;width++) {
+        await page.setViewportSize({width,height:1000});
+        const g=await page.evaluate(titleGeometry,{R:REGIONS,name,pixels:width%40===0});
+        assertGeometry(g,`${engine} ${name} ${width}`,width%40===0);
+        lines[g.bubbleLines]=(lines[g.bubbleLines]||0)+1;
       }
-      checks.push(`${engine} ${width}: six routes without overflow; both shelf rows filled with ordered square images, Vault copy included; picture geometry and exact speech`);
+      checks.push(`${engine} ${name}: every width 320-2560 px keeps whole bubble words (bubble lines ${JSON.stringify(lines)}), the strip clear of the title text, the title text centred beside her (Vault heading 17 px under her on phones), the bubble in its frame and the wallet hint gap; picture pixels checked every 40 px`);
     }
     await browser.close();browser=undefined;
   }
diff --git a/web/scripts/check-bundle.mjs b/web/scripts/check-bundle.mjs
index 49ff322..f90be21 100644
--- a/web/scripts/check-bundle.mjs
+++ b/web/scripts/check-bundle.mjs
@@ -6,21 +6,36 @@ import {createHash} from 'node:crypto';
 const root=process.env.BASKET_SOURCE_ROOT||path.resolve('..');
 const git=args=>execFileSync('git',args,{cwd:root,encoding:'utf8'});
 const changed=git(['diff','--name-only','HEAD']).trim().split('\n').filter(Boolean);
-// Vault 6 re-point: web/pinned (its foundry.toml too) and web/src may change, except the four HEAD-frozen files checked by check-calldata.mjs.
-const frozenSource=['Losses.tsx','main.tsx','components.tsx','Scenery.tsx'].map(f=>'web/src/'+f);
+// v9 (look update, low fixes F1-F16, slogan strip, favicon, tagline removal, Stock shelves labels in Vault.tsx and
+// styles.css): only these web/src files may change;
+// Losses, poolMath, deployment and the ABI stay HEAD-frozen and main/Scenery may only take their one documented edit
+// (both byte-checked by check-calldata.mjs); web/pinned stays unchanged; in web/public only favicon.svg may change,
+// and only to the chosen icon (art files unchanged); no file is added to web/src or web/public.
+const lookSource=['components.tsx','Vault.tsx','Flows.tsx','Docs.tsx','styles.css','main.tsx','Scenery.tsx'].map(f=>'web/src/'+f);
+const fixSource=['chain.ts','model.ts','newYork.ts','governance.ts','Owner.tsx','wallet.tsx'].map(f=>'web/src/'+f);
+const frozenSource=['Losses.tsx','poolMath.ts','deployment.ts','vault.abi.json'].map(f=>'web/src/'+f);
+// The new favicon: red panel, yellow frame, the header's basket in yellow.
+const FAVICON_SHA256='0a31ead9064a33cbc12abe6388cf3f0a29888d3a183819e02116e56dd8ba2238';
+const sha256=p=>createHash('sha256').update(fs.readFileSync(path.join(root,p))).digest('hex');
+assert.equal(sha256('web/public/favicon.svg'),FAVICON_SHA256,'web/public/favicon.svg is the chosen icon');
+assert.equal(sha256('dist/favicon.svg'),FAVICON_SHA256,'dist/favicon.svg is the chosen icon');
 for(const p of changed){
- if(p.startsWith('web/pinned/'))continue;
+ assert.ok(!p.startsWith('web/pinned/'),'Pinned source changed: '+p);
+ assert.ok(!p.startsWith('web/public/')||p==='web/public/favicon.svg','Public file changed: '+p);
+ // The page shell and build configuration stay as at HEAD (no script can be added outside web/src); in web/validation only the README text changes.
+ assert.ok(!['web/index.html','web/vite.config.ts','web/tsconfig.json'].includes(p)&&(!p.startsWith('web/validation/')||p==='web/validation/README.md'),'Page shell, build configuration or validation fixture changed: '+p);
  assert.ok(!/(^|\/)(lib|node_modules|\.github|\.git)(\/|$)|(^|\/)\.env(?:\.|$)|(^|\/)(foundry\.toml|foundry\.lock|remappings\.txt|\.gitmodules|package\.json|[^/]*lock[^/]*)$/.test(p),'Protected path changed: '+p);
- if(p.startsWith('web/src/'))assert.ok(!frozenSource.includes(p),'HEAD-frozen source changed: '+p);
+ if(p.startsWith('web/src/'))assert.ok(!frozenSource.includes(p)&&(lookSource.includes(p)||fixSource.includes(p)),'Source outside the look update and the low fixes changed: '+p);
  assert.ok(!p.startsWith('src/'),'Root contract source changed');
 }
+assert.deepEqual(git(['ls-files','--others','--exclude-standard','--','web/src','web/public']).trim().split('\n').filter(Boolean),[],'New files in web/src or web/public');
 assert.ok(!git(['ls-files','--stage']).split('\n').some(s=>s.startsWith('160000 ')),'No git submodules');
 const files=[...new Set(git(['ls-files','--cached','--others','--exclude-standard','-z']).split('\0'))].filter(p=>p&&!p.startsWith('.imd/')&&!p.startsWith('test/scratch/')&&fs.existsSync(path.join(root,p))).sort();
 for(const p of files) assert.ok(!/(^|\/)(node_modules|\.npm|\.cache|\.vite|\.playwright-mcp)(\/|$)|\.(tgz|deb|tsbuildinfo)$/.test(p),'Dependency/cache/archive payload: '+p);
 const shots=files.filter(p=>/^artifacts\/(empty|stocks25)-.*\.jpg$/.test(p));assert.equal(shots.length,24);
 const extraImages=files.filter(p=>/^artifacts\/.*\.(png|jpg|webp|svg)$/.test(p)&&!shots.includes(p)&&!/^artifacts\/redeem-title-dpr-(1|1\.25|1\.5)\.png$/.test(p));assert.deepEqual(extraImages,[]);
 const productionFiles={};for(const p of files.filter(p=>p.startsWith('dist/'))){const b=fs.readFileSync(path.join(root,p));productionFiles[p]={bytes:b.length,sha256:createHash('sha256').update(b).digest('hex')};}
-const result={limitBytes:8388608,uncompressedDeliveryBytes:0,fileCount:files.length,productionExportBytes:Object.values(productionFiles).reduce((a,b)=>a+b.bytes,0),productionFiles,accounting:'Complete candidate file contents including tracked lib sources and this report. Excludes Git metadata, removed task inputs and disposable test/scratch. No Git metadata was modified.',checks:['Protected configuration, dependencies and root contracts unchanged; web/pinned and web/src changed only within the vault 6 scope','No git submodules or nested dependency/cache/archive payloads','24 required empty/25-stock JPEGs retained at quality 40; no additional artifact images','Both copies of all 37 manifest assets included']};
+const result={limitBytes:8388608,uncompressedDeliveryBytes:0,fileCount:files.length,productionExportBytes:Object.values(productionFiles).reduce((a,b)=>a+b.bytes,0),productionFiles,accounting:'Complete candidate file contents including tracked lib sources and this report. Excludes Git metadata, removed task inputs and disposable test/scratch. No Git metadata was modified.',checks:['Protected configuration, dependencies, root contracts, web/pinned, web/index.html, web/vite.config.ts, web/tsconfig.json and the validation fixtures unchanged; web/public unchanged except favicon.svg, which (and dist/favicon.svg) has the SHA-256 of the chosen icon; web/src changed only within the v9 scope (look: components, Vault (with the Stock shelves labels), Flows, Docs, styles, main (footer tagline removed), Scenery (slogan strip); low fixes: chain, model, newYork, governance, Owner, wallet; Losses, poolMath, deployment and the ABI frozen)','No git submodules or nested dependency/cache/archive payloads','24 required empty/25-stock JPEGs retained (quality 36 since v9, 40 before); no additional artifact images','Both copies of all 37 manifest assets included']};
 const report=path.join(root,'artifacts/bundle-check.json');
 for(let i=0;i<4;i++){fs.writeFileSync(report,JSON.stringify(result,null,2)+'\n');result.uncompressedDeliveryBytes=files.reduce((sum,p)=>sum+fs.statSync(path.join(root,p)).size,0);}
-fs.writeFileSync(report,JSON.stringify(result,null,2)+'\n');assert.ok(result.uncompressedDeliveryBytes<=result.limitBytes,JSON.stringify(result));console.log('PASS complete bundle',result.uncompressedDeliveryBytes,'/',result.limitBytes,'bytes; lib included');
+fs.writeFileSync(report,JSON.stringify(result,null,2)+'\n');assert.ok(result.uncompressedDeliveryBytes<=result.limitBytes,"Over the 8 MiB budget (if the 24 screenshots are still the quality-40 set, run scripts/run-browser.mjs first: it rewrites them at quality 36): "+JSON.stringify(result));console.log('PASS complete bundle',result.uncompressedDeliveryBytes,'/',result.limitBytes,'bytes; lib included');
diff --git a/web/scripts/check-calldata.mjs b/web/scripts/check-calldata.mjs
index 7d6008a..6a227f0 100644
--- a/web/scripts/check-calldata.mjs
+++ b/web/scripts/check-calldata.mjs
@@ -2,21 +2,375 @@ import fs from 'node:fs';
 import path from 'node:path';
 import assert from 'node:assert/strict';
 import { execFileSync } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
 import ts from 'typescript';
+import { build } from 'esbuild';
 const root=process.env.BASKET_SOURCE_ROOT||path.resolve('..');
-const baseline=p=>execFileSync('git',['show','HEAD:'+p],{cwd:root,encoding:'utf8'});
+const git=args=>execFileSync('git',args,{cwd:root,encoding:'utf8'});
+const baseline=p=>git(['show','HEAD:'+p]);
 const read=p=>fs.readFileSync(path.join(root,p),'utf8');
-// Vault 6 re-point: Losses, main, components and Scenery stay as at HEAD; Flows and Vault keep every call expression (only VAULT differs).
-const protectedFiles=['Losses.tsx','main.tsx','components.tsx','Scenery.tsx'];
+// v9 (look update + low fixes F1-F16). Byte-identical to HEAD: the pages left alone and everything that defines
+// the vault address, its code hash, its ABI and the pool arithmetic.
+const protectedFiles=['Losses.tsx','poolMath.ts','deployment.ts','vault.abi.json'];
 for(const f of protectedFiles) assert.equal(read('web/src/'+f),baseline('web/src/'+f),f);
-const names=new Set(['vault','token','feed','read','many','simulate','verifyNetwork','encode','depositArgs','redeemArgs','w.send','p.request']);
+// main.tsx and Scenery.tsx: byte-identical to HEAD once the one documented edit is put back (each piece exactly once):
+// A4 the footer tagline removed; A2 eight slogan lines per strip half instead of four.
+const TAGLINE=['Stock','Tokens.','One','basket.'].join(' ');
+const editedFiles={
+ 'main.tsx':[['<strong>Basket Protocol</strong>\n          <span className="footer-links">','<strong>Basket Protocol</strong>\n          <span>'+TAGLINE+'</span>\n          <span className="footer-links">']],
+ 'Scenery.tsx':[['{Array.from({ length: 8 }, (_, i) => (','{Array.from({ length: 4 }, (_, i) => (']],
+};
+for(const [f,edits] of Object.entries(editedFiles)){
+ let text=read('web/src/'+f);
+ for(const [n,o] of edits){assert.equal(text.split(n).length,2,f+': expected once: '+n);text=text.split(n).join(o);}
+ assert.equal(text,baseline('web/src/'+f),f+' changed beyond the documented edit');
+}
+// Calls that build, encode, simulate or send a transaction (or parse its arguments) or read the chain.
+const names=new Set(['vault','token','feed','read','many','simulate','verifyNetwork','encode','depositArgs','redeemArgs','w.send','p.request',
+ 'safe','proposalSpec','proposalAction','settingValues','poolValues','parseLaunch','encodeFunctionData','client.call','client.estimateGas',
+ 'client.getTransactionCount','client.waitForTransactionReceipt','address','recipient','amount','uint']);
+const actionAttributes=new Set(['onClick','onSubmit','onChange','getSpec','disabled','disabledReason','label','scope','role','primary','value','claim','reason','build']);
+// A6 G-A: wallet sends and raw provider requests in any form are guarded calls too: a callee ending in one of these
+// names (any receiver, optional chaining, casts, element access, string folding) or naming the provider (ethereum).
+const SEND=new Set(['send','request','sendTransaction','sendRawTransaction','writeContract','sendAsync','sendCalls','signTransaction','sendUnsignedTransaction']);
+const lit=n=>ts.isStringLiteralLike(n)?n.text:ts.isParenthesizedExpression(n)?lit(n.expression):ts.isBinaryExpression(n)&&n.operatorToken.kind===ts.SyntaxKind.PlusToken&&lit(n.left)!==undefined&&lit(n.right)!==undefined?lit(n.left)+lit(n.right):undefined;
+const unwrap=n=>ts.isParenthesizedExpression(n)||ts.isNonNullExpression(n)||ts.isAsExpression(n)||ts.isTypeAssertionExpression(n)||ts.isSatisfiesExpression?.(n)?unwrap(n.expression):n;
+const calleeName=c=>{const e=unwrap(c.expression);return ts.isIdentifier(e)?e.text:ts.isPropertyAccessExpression(e)?e.name.text:ts.isElementAccessExpression(e)?lit(e.argumentExpression):undefined;};
+const isGuarded=(n,tree)=>ts.isCallExpression(n)&&(names.has(n.expression.getText(tree))||SEND.has(calleeName(n))||/ethereum|(^|[.?\]])\s*(send|request|sendTransaction|sendRawTransaction|writeContract)\b/.test(n.expression.getText(tree)));
 function calls(text,file) {
- const tree=ts.createSourceFile(file,text,ts.ScriptTarget.Latest,true,file.endsWith('tsx')?ts.ScriptKind.TSX:ts.ScriptKind.TS),found=[];
+ const tree=ts.createSourceFile(file,text,ts.ScriptTarget.Latest,true,file.endsWith('tsx')?ts.ScriptKind.TSX:ts.ScriptKind.TS),found=[],all=[],attributes=[];
  const printer=ts.createPrinter({removeComments:true});
- function visit(n){if(ts.isCallExpression(n)&&names.has(n.expression.getText(tree)))found.push(printer.printNode(ts.EmitHint.Unspecified,n,tree).replace(/\s+/g,' '));ts.forEachChild(n,visit);}
- visit(tree);return found;
+ const print=n=>printer.printNode(ts.EmitHint.Unspecified,n,tree).replace(/\s+/g,' ');
+ const guardedIn=node=>{const g=[];(function v(n){if(isGuarded(n,tree))g.push(print(n));ts.forEachChild(n,v);})(node);return g;};
+ function where(attr){const owner=attr.parent.parent,tag=owner.tagName?.getText(tree)??'?';const named=attr.parent.properties.find(p=>ts.isJsxAttribute(p)&&['title','label','scope'].includes(p.name.getText(tree))&&p.initializer);return tag+(named?' '+named.name.getText(tree)+'='+named.initializer.getText(tree).replace(/\s+/g,' ').slice(0,60):'');}
+ function visit(n){
+  if(ts.isCallExpression(n)){all.push(print(n));if(isGuarded(n,tree))found.push(print(n));}
+  if(ts.isJsxAttribute(n)&&actionAttributes.has(n.name.getText(tree)))attributes.push({name:n.name.getText(tree),text:print(n),guarded:guardedIn(n),where:where(n)});
+  ts.forEachChild(n,visit);
+ }
+ visit(tree);return {found,all,attributes};
+}
+// Remove the first occurrence of each listed item; every listed item must be present.
+function without(list,items,what){const rest=[...list];for(const x of items){const i=rest.indexOf(x);assert.ok(i>=0,what+': expected '+x);rest.splice(i,1);}return rest;}
+// Exact, documented differences of the guarded calls (everything else must equal HEAD, in order).
+const expected={
+ 'governance.ts':{fix:'F1, F15, F16',why:'F1 minLiquidity parsed as uint128 (uint(v, 128) in minLiquidityOf); F16 address(v) in newOwner/newGuardian/feeRecipient (address() plus a refusal of the vault); F15 the current settings() passed down only to refuse a Sunday 2:00-2:59 am Hours start under Dst 0. The Action fields and the propose call are otherwise unchanged (see the differential encoding below).',
+  removed:['uint(v.minLiquidity)','address(v.next)','recipient(v.recipient)','settingValues(v)','vault("propose", [proposalAction(kind, v)])','proposalAction(kind, v)'],
+  added:['uint(v, 128)','address(v)','address(v)','address(v)','settingValues(v, settings)','vault("propose", [proposalAction(kind, v, settings)])','proposalAction(kind, v, settings)']},
+ 'Owner.tsx':{fix:'F15, F16',why:'F15 the Setting preview and build pass the current settings() (Dst) to settingValues/proposalSpec; F16 Transfer ownership parses the address with newOwner (address() plus a refusal of the vault) before the unchanged guardian read and vault("transferOwnership", [next]).',
+  removed:['settingValues({ ...v, setting: String(key), })','proposalSpec(10, { ...v, setting: String(key) })','address(v.next)'],
+  added:['settingValues({ ...v, setting: String(key), }, current)','proposalSpec(10, { ...v, setting: String(key) }, current)']},
+ 'wallet.tsx':{fix:'F13',why:'waitForTransactionReceipt gains onReplaced to learn whether the wallet cancelled or replaced the transaction (then the page says so instead of Confirmed). The eth_sendTransaction request, its data (encode(s)), gas, nonce read and simulation are unchanged.',
+  removed:['client.waitForTransactionReceipt({ hash: tx, timeout: 180000, pollingInterval: 3000, })'],
+  added:['client.waitForTransactionReceipt({ hash: tx, timeout: 180000, pollingInterval: 3000, onReplaced: (r) => { replaced = r.reason; }, })']},
+};
+// Owner.tsx action attributes that change, in page order, each with its send calls compared below. A6 G-B: each one,
+// printed without comments, must also equal HEAD's text once its documented pieces [v9, HEAD] are put back (each
+// exactly once), so the listing loop's row (checkedRows[i]), the listGenesis arguments, the new owner
+// (newOwner(v.next)) and everything else around the sends are pinned, not only the send calls.
+const ownerAttributes=[
+ ['onClick','List stocks / Resume listing button: F13 cancelled-in-wallet and not-listed-after-receipt words; same listingPending, inspectListing and w.send(vault("listGenesis", ...)) calls',[
+  ['let rowName = "Listing", rowNumber = 0;','let rowName = "Listing";'],['rowNumber = i + 1; ',''],
+  ['if (!after.listed) throw new TransactionCancelled("Not listed after the receipt."); if (after.error) throw new InputError(after.error);','if (!after.listed || after.error) throw new InputError(after.error || "Listing confirmation unreadable. Re-check before continuing.");'],
+  ['if (e instanceof TransactionCancelled) { const text = `Row ${rowNumber}: the transaction was cancelled in the wallet; nothing was listed. Press Resume listing.`; setError(text); w.notice("listing", text); } else setError(','setError(']]],
+ ['onClick','Wait for pending transaction button: F13 also clears the stale error',[['setPending(""); setError(""); setResume(true);','setPending(""); setResume(true);']]],
+ ['build','Set <setting> form: F15 passes the current settings() to proposalSpec(10, ...)',[['String(key) }, current)','String(key) })']]],
+ ['disabledReason','Finalize genesis: F14 "Paste the listing rows first..." and the listed-with-other-values words',[['{!listing.trim() ? PASTE_FIRST : listingError','{listingError'],['. List them first.` : differing.length ? differWords(differing) : "At least','. List them first.` : "At least']]],
+ ['disabled','Finalize genesis: F14 also disabled while the paste box is empty or a pasted row is listed with other values',[['finalized !== false || !listing.trim() || !!listingError','finalized !== false || !!listingError'],['!!unlisted.length || !!differing.length ||','!!unlisted.length ||']]],
+ ['build','Finalize genesis: F14 refuses an empty paste box and listed-with-other-values rows before the unchanged vault("finalizeGenesis")',[
+  ['{ if (!listing.trim()) throw new InputError(PASTE_FIRST); await w.listingPending();','{ await w.listingPending();'],
+  ['const pasted = parseLaunch(listing); const missing = pasted.filter((r) => !fresh.assets.some((a) => same(a.token, r.token)));','const missing = listing.trim() ? parseLaunch(listing).filter((r) => !fresh.assets.some((a) => same(a.token, r.token))) : [];'],
+  ['const changed = pasted.filter((r) => listedDiffers(fresh.assets, r)); if (changed.length) throw new InputError(differWords(changed.map((r) => r.ticker))); ',''],
+  ['${reasonWords(a.reason, fresh.globals.settings)}','${a.reason === undefined ? "unreadable" : reasons[a.reason]}']]],
+ ['build','Transfer ownership: F16 newOwner(v.next) refuses the vault before the unchanged vault("transferOwnership", [next])',[['const next = newOwner(v.next);','const next = address(v.next);']]],
+];
+const putBack=(text,pieces,what)=>{for(const [n,o] of pieces){assert.equal(text.split(n).length,2,what+': expected once: '+n);text=text.split(n).join(o);}return text;};
+// Every call expression must equal HEAD in these files, except the listed exact pairs (F11: Redeem legs by assetTokens index).
+const allCallsEqual={'components.tsx':[], 'Docs.tsx':[], 'Flows.tsx':[
+ ['s.assets.map((a, i) => (<p key={a.token}> <bdi>{a.symbol}</bdi>:{" "} {fmt(quote.amounts[i], a.tokenDecimals)} </p>))','s.assets.map((a) => (<p key={a.token}> <bdi>{a.symbol}</bdi>:{" "} {fmt(quote.amounts[a.index], a.tokenDecimals)} </p>))'],
+ ['fmt(quote.amounts[i], a.tokenDecimals)','fmt(quote.amounts[a.index], a.tokenDecimals)']]};
+// Vault.tsx (v9 with the Stock shelves labels): no read, check or send call at all (no guarded call here, and no send
+// or request in the scan below). Its action attributes are pinned in page order: HEAD's Retry vault button and the
+// vault, Stock Token and price feed address links, plus the shelves' controls (label Details, drawer Close, filters,
+// search, Show all), which only change what is shown; HEAD's search box value/onChange pair is replaced by the
+// shelves' search. The StockShelves handlers behind those controls are pinned too.
+const vaultAttributes={
+ head:['onClick={s.retry}','value={VAULT}','value={search}','onChange={(e) => setSearch(e.target.value)}','value={a.token}','value={a.feed}'],
+ now:['onClick={s.retry}','value={VAULT}','onClick={onToggle}','onClick={onClose}','value={a.token}','value={a.feed}','role="list"','role="group"','onClick={() => show(f, search)}','value={search}','onChange={(e) => show(filter, e.target.value)}','role="status"','onClick={() => show("all", "")}','onClick={() => show("all", "")}']};
+const vaultHandlers={
+ show:'const show = (f: ShelfFilter, text: string) => { stopRestock(); setOpenToken(undefined); setFilter(f); setSearch(text); };',
+ toggle:'const toggle = (token: string) => setOpenToken(openToken === token ? undefined : token);',
+ close:'const close = (token: string) => { setOpenToken(undefined); requestAnimationFrame(() => document.getElementById(`sa-more-${token}`)?.focus()); };',
+ group:'const group = { nav, settings: s.globals.settings, openToken, onToggle: toggle, onClose: close };'};
+// The variable statements declaring `list` inside the top-level function `fn`, printed without comments (one each).
+function localDeclarations(file,text,fn,list){
+ const tree=ts.createSourceFile(file,text,ts.ScriptTarget.Latest,true,ts.ScriptKind.TSX),printer=ts.createPrinter({removeComments:true}),out={};
+ const f=tree.statements.filter(st=>ts.isFunctionDeclaration(st)&&st.name?.text===fn);
+ assert.equal(f.length,1,file+': one '+fn);
+ (function v(n){if(ts.isVariableStatement(n))for(const d of n.declarationList.declarations)if(ts.isIdentifier(d.name)&&list.includes(d.name.text)){assert.ok(!out[d.name.text],file+': one '+d.name.text+' in '+fn);out[d.name.text]=printer.printNode(ts.EmitHint.Unspecified,n,tree).replace(/\s+/g,' ');}ts.forEachChild(n,v);})(f[0]);
+ return out;
+}
+const sources=git(['ls-tree','-r','--name-only','HEAD','web/src']).trim().split('\n').filter(p=>/\.tsx?$/.test(p)).map(p=>p.slice(8));
+assert.deepEqual(git(['ls-files','--cached','--others','--exclude-standard','web/src']).trim().split('\n').filter(p=>/\.tsx?$/.test(p)).map(p=>p.slice(8)).sort(),[...sources].sort(),'No source file added or removed');
+const counts={},ownerChanges=[];
+for(const f of sources){
+ const old=calls(baseline('web/src/'+f),f),now=calls(read('web/src/'+f),f),e=expected[f];
+ if(e) assert.deepEqual(without(now.found,e.added,f),without(old.found,e.removed,f),f+' changed guarded calls beyond the documented ones');
+ else assert.deepEqual(now.found,old.found,f+' changed calldata/read/check call expressions');
+ if(f==='Vault.tsx'){
+  assert.deepEqual(now.found,[],'Vault.tsx makes no read, check or send call');
+  assert.deepEqual(old.attributes.map(a=>a.text),vaultAttributes.head,'Vault.tsx HEAD action attributes');
+  assert.deepEqual(now.attributes.map(a=>a.text),vaultAttributes.now,'Vault.tsx changed an action attribute beyond the pinned Stock shelves controls');
+  for(const a of now.attributes) assert.deepEqual(a.guarded,[],'Vault.tsx '+a.where+': guarded call in an attribute');
+  const h=localDeclarations('web/src/Vault.tsx',read('web/src/Vault.tsx'),'StockShelves',Object.keys(vaultHandlers));
+  for(const [k,v] of Object.entries(vaultHandlers)) assert.equal(h[k],v,'Vault.tsx StockShelves '+k+' differs from the pinned text');
+ } else {
+ assert.equal(now.attributes.length,old.attributes.length,f+' action attribute count');
+ const changed=now.attributes.map((a,i)=>[old.attributes[i],a]).filter(([o,a])=>o.text!==a.text);
+ if(f==='Owner.tsx'){
+  assert.deepEqual(changed.map(([,a])=>a.name),ownerAttributes.map(x=>x[0]),'Owner.tsx changed action attributes');
+  changed.forEach(([o,a],i)=>{
+   assert.equal(o.name,a.name);
+   // The send calls inside each changed attribute: equal, apart from the documented Owner.tsx differences.
+   const removed=o.guarded.filter(x=>!a.guarded.includes(x)),added=a.guarded.filter(x=>!o.guarded.includes(x));
+   for(const x of removed) assert.ok(e.removed.includes(x),'Owner.tsx '+a.where+': removed '+x);
+   for(const x of added) assert.ok(e.added.includes(x),'Owner.tsx '+a.where+': added '+x);
+   assert.deepEqual(a.guarded.filter(x=>!added.includes(x)),o.guarded.filter(x=>!removed.includes(x)),'Owner.tsx '+a.where+' send call order');
+   assert.equal(putBack(a.text,ownerAttributes[i][2],'Owner.tsx '+a.where),o.text,'Owner.tsx '+a.where+' changed beyond its documented pieces');
+   ownerChanges.push({attribute:a.name,element:a.where,change:ownerAttributes[i][1],pieces:ownerAttributes[i][2].length,sendCallsBefore:o.guarded,sendCallsAfter:a.guarded});
+  });
+ } else assert.deepEqual(changed.map(([,a])=>a.text),[],f+' changed an action, send or check attribute');
+ }
+ if(allCallsEqual[f]){
+  const pairs=allCallsEqual[f];
+  assert.deepEqual(now.all,old.all.map(x=>pairs.find(p=>p[0]===x)?.[1]??x),f+' changed a call expression');
+ }
+ counts[f]={guarded:now.found.length,calls:now.all.length,attributes:now.attributes.length};
+}
+// A6 G-A: no web/src file gains, loses or changes a wallet send or raw request, with no exception. Listed in order per
+// file: every use of a send/request name or of the provider (ethereum), with the call around it; every string that
+// names a sending or signing method (folded across +); computed access to the global object; eval, Function, Reflect.
+const SEND_TEXT=/eth_send|eth_sign|personal_sign|wallet_send|signtypeddata|sendtransaction|sendrawtransaction|writecontract|^(send|request|ethereum)$/i;
+const ESCAPES=new Set(['ethereum','eval','Function','Reflect','globalThis']),GLOBAL=new Set(['window','globalThis','self','top','parent','frames']);
+function sendsOf(text,file){
+ const tree=ts.createSourceFile(file,text,ts.ScriptTarget.Latest,true,file.endsWith('tsx')?ts.ScriptKind.TSX:ts.ScriptKind.TS),printer=ts.createPrinter({removeComments:true}),out=[];
+ const print=n=>printer.printNode(ts.EmitHint.Unspecified,n,tree).replace(/\s+/g,' ');
+ const wraps=(p,n)=>(ts.isPropertyAccessExpression(p)||ts.isElementAccessExpression(p)||ts.isCallExpression(p))&&p.expression===n||ts.isNonNullExpression(p)||ts.isParenthesizedExpression(p)||ts.isAsExpression(p)||ts.isTypeAssertionExpression(p)||!!ts.isSatisfiesExpression?.(p);
+ const top=n=>{if(n.parent&&ts.isPropertyAccessExpression(n.parent)&&n.parent.name===n)n=n.parent;while(n.parent&&wraps(n.parent,n))n=n.parent;return n;};
+ (function v(n){
+  const s=lit(n);
+  if(ts.isIdentifier(n)&&(SEND.has(n.text)||ESCAPES.has(n.text)))out.push(print(top(n)));
+  else if(ts.isElementAccessExpression(n)&&GLOBAL.has(unwrap(n.expression).getText(tree))&&lit(n.argumentExpression)===undefined)out.push(print(n));
+  else if(s!==undefined&&!(n.parent&&lit(n.parent)!==undefined)&&SEND_TEXT.test(s))out.push(print(top(n)));
+  else if((ts.isTemplateExpression(n)||ts.isNoSubstitutionTemplateLiteral(n))&&SEND_TEXT.test(ts.isTemplateExpression(n)?n.head.text+n.templateSpans.map(x=>x.literal.text).join(''):n.text))out.push(print(n));
+  ts.forEachChild(n,v);
+ })(tree);
+ return out;
+}
+const NO_SEND=['Vault.tsx','Scenery.tsx','main.tsx','Docs.tsx'],sendUses={};
+for(const f of sources){
+ const h=sendsOf(baseline('web/src/'+f),f),n=sendsOf(read('web/src/'+f),f);
+ assert.deepEqual(n,h,f+': a wallet send, provider request or signing method was added, removed or changed');
+ if(NO_SEND.includes(f))assert.ok(n.every(x=>x==='window.ethereum'),f+' must contain no send or request (only the read of window.ethereum in main.tsx)');
+ if(n.length)sendUses[f]=n;
+}
+// components.tsx (the shared transaction button) keeps exactly HEAD's single wallet.send.
+assert.deepEqual(sendUses['components.tsx'].filter(x=>/\(/.test(x)),['wallet.send(await getSpec(), scope, scope)'],'components.tsx sends');
+// wallet.tsx send(), the only function that prompts the wallet: printed without comments it must equal HEAD once the
+// documented pieces are put back, so from, to, data, gas (estimate x 1.3), nonce, the chain and account rechecks,
+// the simulation and the eth_sendTransaction request are unchanged. F13: learn a cancel/replacement from
+// waitForTransactionReceipt and say so (no "Confirmed", no link); F7/A5: the proposal detail wording (its end rounded down).
+const sendEdits=[
+ ['let replaced: string | undefined; ',''],
+ ['onReplaced: (r) => { replaced = r.reason; }, ',''],
+ ['if (replaced === "cancelled" || replaced === "replaced") throw new TransactionCancelled(replaced === "cancelled" ? "The transaction was cancelled in the wallet; it did not run. Refresh the vault before retrying." : "The transaction was replaced in the wallet by a different one; it did not run. Refresh the vault before retrying."); ',''],
+ ['until just before ${date(expiresAt, "end")}, from the Proposed event.','until ${date(expiresAt)} (exclusive), from the Proposed event.'],
+ ['if (e instanceof TransactionCancelled) { notice(key, e.message); throw e; } ',''],
+ ['if (sent && !settled && s.functionName === "listGenesis") pendingShown.current = true; ',''],
+];
+function sendText(text){
+ const tree=ts.createSourceFile('wallet.tsx',text,ts.ScriptTarget.Latest,true,ts.ScriptKind.TSX),printer=ts.createPrinter({removeComments:true});let out;
+ (function v(n){if(ts.isFunctionDeclaration(n)&&n.name?.text==='send')out=printer.printNode(ts.EmitHint.Unspecified,n,tree).replace(/\s+/g,' ');ts.forEachChild(n,v);})(tree);
+ assert.ok(out,'wallet.tsx send() found');return out;
+}
+let sendNow=sendText(read('web/src/wallet.tsx'));
+for(const [n,o] of sendEdits){assert.equal(sendNow.split(n).length,2,'wallet.tsx send(): expected once: '+n);sendNow=sendNow.split(n).join(o);}
+assert.equal(sendNow,sendText(baseline('web/src/wallet.tsx')),'wallet.tsx send() changed beyond the documented F13/F7/A5 pieces');
+// Differential encoding: HEAD and current governance/model/chain bundled side by side. For the same inputs the
+// calldata must be byte-identical whenever the current page accepts; the current page may only add the
+// documented refusals (made before any wallet prompt), and never accepts what HEAD refused.
+const scratch=path.join(root,'test/scratch/calldata');
+fs.rmSync(scratch,{recursive:true,force:true});
+for(const p of git(['ls-tree','-r','--name-only','HEAD','web/src']).trim().split('\n').filter(p=>/\.(tsx?|json)$/.test(p))){
+ const out=path.join(scratch,'head',p.slice(4));fs.mkdirSync(path.dirname(out),{recursive:true});fs.writeFileSync(out,baseline(p));
+}
+const entry=src=>`export { proposalSpec, proposalAction } from "${src}/governance";\nexport { parseLaunch, address, recipient, amount, uint, deadline, depositArgs, redeemArgs } from "${src}/model";\nexport { encode, vault, token, VAULT } from "${src}/chain";\n`;
+fs.writeFileSync(path.join(scratch,'head-entry.ts'),entry('./head/src'));
+fs.writeFileSync(path.join(scratch,'now-entry.ts'),entry('../../../web/src')+'export { newOwner } from "../../../web/src/governance";\n');
+const bundle=async name=>{const outfile=path.join(scratch,name+'.mjs');await build({entryPoints:[path.join(scratch,name+'-entry.ts')],bundle:true,format:'esm',platform:'node',outfile,nodePaths:[path.resolve('node_modules')],logLevel:'error'});return import(pathToFileURL(outfile).href);};
+const head=await bundle('head'),now=await bundle('now');
+const SPRING='Sunday 2:00-2:59 am New York is skipped on the spring-forward Sunday; choose another start.';
+const U128='Minimum raw pool liquidity: enter an unsigned 128-bit whole number.';
+const V=now.VAULT,A='0x1111111111111111111111111111111111111111',B='0x2222222222222222222222222222222222222222',Z='0x0000000000000000000000000000000000000000';
+const badChecksum='0x'+V.slice(2).replace(/[a-f]/,c=>c.toUpperCase());
+const addrs=[A,B,V,V.toUpperCase().replace('0X','0x'),Z,'bad','',badChecksum];
+const liqs=['0','1','1000000',String(2n**128n-1n),String(2n**128n),String(2n**200n),String(2n**256n-1n),String(2n**256n),'-1','1.5',' 7',''];
+const hourTexts=['Monday 9:30 am','Friday 4:00 pm','Sunday 8:00 pm','Saturday 24:00','Sunday 12:00 am','Sunday 1:59 am','Sunday 2:00 am','Sunday 2:30 am','Sunday 2:59 am','Sunday 3:00 am','Always open','Monday 24:00','junk'];
+const values=['0','1','2','3','4','10','48','49','50','299','300','2000','3600','20000','86400','500000','500001',String(2n**256n-1n),String(2n**256n),'1.5',''];
+const settingsList=[undefined,{dst:0n},{dst:1n},{dst:2n}];
+const cases=[];
+for(const token of [A,V,Z,'bad'])for(const feed of [B,V,Z])for(const pool of [A,V,Z])for(const quoteFeed of [B,Z])for(const minLiquidity of liqs)cases.push([0,{token,feed,pool,quoteFeed,minLiquidity}]);
+for(const token of addrs)for(const feed of addrs)cases.push([1,{token,feed}]);
+for(const k of [2,3,4,6])for(const token of addrs)cases.push([k,{token}]);
+for(const token of [A,V,'bad'])for(const pool of [A,V,Z])for(const quoteFeed of [B,Z])for(const minLiquidity of liqs)cases.push([5,{token,pool,quoteFeed,minLiquidity}]);
+for(const next of addrs)cases.push([7,{next}]);
+for(const cap of ['0','1','1.5','10000000000','10000000000.000000000000000001','x',''])cases.push([8,{cap}]);
+for(const recipient of addrs)cases.push([9,{recipient}]);
+for(let k=0;k<=16;k++)if(k!==5)for(const value of values)cases.push([10,{setting:String(k),value}]);
+for(const from of hourTexts)for(const to of hourTexts)for(const settings of settingsList)cases.push([10,{setting:'5',from,to},settings]);
+for(const k of [11,-1])cases.push([k,{}]);
+const attempt=f=>{try{return {hex:f()};}catch(e){return {error:e.message};}};
+const tally={sameCalldata:0,bothRefused:0,newRefusals:{}};
+function compare(label,input,h,n,newRefusalAllowed,t=tally){
+ if(n.hex!==undefined){assert.ok(h.hex!==undefined,label+' accepted input HEAD refused: '+JSON.stringify(input));assert.equal(n.hex,h.hex,label+' calldata changed for '+JSON.stringify(input));t.sameCalldata++;}
+ else if(h.hex!==undefined){assert.ok(newRefusalAllowed(n.error),label+' new refusal not documented: '+n.error+' for '+JSON.stringify(input));t.newRefusals[n.error]=(t.newRefusals[n.error]||0)+1;}
+ else t.bothRefused++;
+}
+const isV=x=>typeof x==='string'&&x.toLowerCase()===V.toLowerCase();
+const json=x=>JSON.parse(JSON.stringify(x,(k,v)=>typeof v==='bigint'?String(v):v));
+for(const [kind,v,settings] of cases){
+ const h=attempt(()=>head.encode(head.proposalSpec(kind,v))),n=attempt(()=>now.encode(now.proposalSpec(kind,v,settings)));
+ compare('propose',json({kind,v,settings}),h,n,error=>{
+  if(error===U128)return [0,5].includes(kind)&&/^\d+$/.test(v.minLiquidity)&&BigInt(v.minLiquidity)>=2n**128n&&BigInt(v.minLiquidity)<2n**256n;
+  if(error==='The new guardian must not be the vault.')return kind===7&&isV(v.next);
+  if(error===SPRING){const from=kind===10&&v.setting==='5'?head.proposalAction(kind,v).value:-1n;return from>=7200n&&from<10800n&&(!settings||settings.dst===0n);}
+  return false;
+ });
+}
+for(const next of addrs)compare('transferOwnership',{next},attempt(()=>head.encode(head.vault('transferOwnership',[head.address(next)]))),attempt(()=>now.encode(now.vault('transferOwnership',[now.newOwner(next)]))),error=>error==='The new owner must not be the vault.'&&isV(next));
+for(const pool of [A,Z])for(const quoteFeed of [B,Z])for(const minLiquidity of liqs){
+ const text=`AAA ${A} ${B} ${pool} ${quoteFeed} ${minLiquidity}\nBBB ${B} ${A} ${Z} ${Z} 0`;
+ const listing=m=>m.parseLaunch(text).map(r=>m.encode(m.vault('listGenesis',[r.token,r.feed,r.pool,r.quoteFeed,r.minLiquidity]))).join();
+ compare('listGenesis',{text},attempt(()=>listing(head)),attempt(()=>listing(now)),()=>false);
+}
+// Deposit, redeem, claim, approve and owner-button calls built from the model parsers, compared under fixed clocks so
+// deadline() (the clock plus 600 s, the last argument of every deposit and redeem) is compared too. Here no new
+// refusal is allowed: every input must give the same calldata as HEAD or be refused by both.
+const sends={},clock=Date.now;
+const cmp=(label,input,f)=>compare(label,input,attempt(()=>f(head)),attempt(()=>f(now)),()=>false,sends[label]??={sameCalldata:0,bothRefused:0,newRefusals:{}});
+const clocks=[0,999,1791000000000,1791000000999,1791006123456.7,4102444800000];
+const amountTexts=['0','1','1.5','0.000001','0.0000001','1.000000000000000001','1.0000000000000000001','10000000000',
+ '115792089237316195423570985008687907853269984665640564039457.584007913129639935','115792089237316195423570985008687907853269984665640564039457.584007913129639936',
+ String(2n**256n-1n),String(2n**256n),' 2 ','2.','.5','-1','1e18','x',''];
+const legsList=[[],[0n],[0n,3333n],[1n,999n,1000n,10n**18n,2n**200n]];
+const depositInputs=[[[A,B],[1n,2n],A,1000n],[[A],[0n],B,0n],[[B,A,V],[10n**18n,3n,2n**255n],A,2n**256n-1n],[[],[],A,999n]];
+try{
+ for(const t of clocks){
+  Date.now=()=>t;
+  assert.equal(String(now.deadline()),String(head.deadline()),'deadline() at clock '+t);
+  for(const args of depositInputs){
+   assert.deepEqual(json(now.depositArgs(...args)),json(head.depositArgs(...args)),'depositArgs (all five arguments, deadline included) at clock '+t);
+   cmp('deposit',json({clock:t,args}),m=>m.encode(m.vault('deposit',m.depositArgs(...args))));
+  }
+  for(const shares of [0n,10n,2n**256n-1n])for(const legs of legsList){
+   assert.deepEqual(json(now.redeemArgs(shares,A,legs)),json(head.redeemArgs(shares,A,legs)),'redeemArgs (all four arguments, deadline included) at clock '+t);
+   cmp('redeemArgs',json({clock:t,shares,legs}),m=>m.encode(m.vault('redeem',m.redeemArgs(shares,A,legs))));
+  }
+ }
+ Date.now=()=>1791000000000;
+ // Redeem as Flows builds it: amount(input) shares, recipient(to), redeemArgs(shares, receiver, previewRedeem amounts).
+ for(const text of amountTexts)for(const to of addrs)for(const legs of legsList.slice(1,3))
+  cmp('redeem',json({text,to,legs}),m=>m.encode(m.vault('redeem',m.redeemArgs(m.amount(text),m.recipient(to),legs))));
+ // Deposit amounts (amount(input, false, tokenDecimals)) and the approve built from them.
+ for(const text of amountTexts)for(const d of [0,6,8,18])cmp('approve',{text,d},m=>m.encode(m.token(A,'approve',[m.VAULT,m.amount(text,false,d)])));
+ // Claim and Claim all: vault("claim", [tokens, recipient(to)]).
+ for(const to of addrs)for(const tokens of [[A],[A,B],Array(10).fill(B)])cmp('claim',{to,tokens},m=>m.encode(m.vault('claim',[tokens,m.recipient(to)])));
+ // Owner buttons: lowerNAVCap(amount(cap, true)), close and removeRetired(address(token)).
+ for(const text of amountTexts)cmp('lowerNAVCap',{text},m=>m.encode(m.vault('lowerNAVCap',[m.amount(text,true)])));
+ for(const fn of ['close','removeRetired'])for(const v of addrs)cmp(fn,{v},m=>m.encode(m.vault(fn,[m.address(v)])));
+ // The parsers' values themselves.
+ for(const v of [...liqs,...amountTexts])for(const bits of [128,256])cmp('uint',{v,bits},m=>String(m.uint(v,bits)));
+ for(const v of addrs)for(const zero of [false,true])cmp('address',{v,zero},m=>m.address(v,zero));
+}finally{Date.now=clock;}
+for(const [label,t] of Object.entries(sends)){
+ assert.ok(t.sameCalldata>0,label+': corpus has accepted inputs');
+ if(!['deposit','redeemArgs'].includes(label))assert.ok(t.bothRefused>0,label+': corpus has refused inputs');
+}
+// The transaction-argument builders and parsers, printed without comments, also equal HEAD.
+const pinned={'web/src/model.ts':['same','deadline','depositArgs','redeemArgs','amount','address','recipient','uint','parseLaunch'],'web/src/chain.ts':['vault','token','encode']};
+function declarations(file,text,list){
+ const tree=ts.createSourceFile(file,text,ts.ScriptTarget.Latest,true,file.endsWith('tsx')?ts.ScriptKind.TSX:ts.ScriptKind.TS),printer=ts.createPrinter({removeComments:true}),out={};
+ for(const st of tree.statements){
+  if(ts.isFunctionDeclaration(st)&&st.name&&list.includes(st.name.text))out[st.name.text]=printer.printNode(ts.EmitHint.Unspecified,st,tree);
+  if(ts.isVariableStatement(st))for(const d of st.declarationList.declarations)if(ts.isIdentifier(d.name)&&list.includes(d.name.text))out[d.name.text]=printer.printNode(ts.EmitHint.Unspecified,st,tree);
+ }
+ // Functions inside components (checkRows in LaunchListing): any depth, exactly one declaration.
+ (function v(n){if(n!==tree&&ts.isFunctionDeclaration(n)&&n.name&&list.includes(n.name.text)&&n.parent!==tree){assert.ok(!out[n.name.text],file+': one '+n.name.text);out[n.name.text]=printer.printNode(ts.EmitHint.Unspecified,n,tree);}ts.forEachChild(n,v);})(tree);
+ for(const n of list)assert.ok(out[n],file+': '+n+' found');
+ return out;
+}
+for(const [file,list] of Object.entries(pinned)){
+ const n=declarations(file,read(file),list),h=declarations(file,baseline(file),list);
+ for(const k of list)assert.equal(n[k],h[k],file+': '+k+' changed');
+}
+// A6 G-B: where the send arguments come from. Printed without comments (whitespace folded), each declaration equals
+// HEAD once its documented pieces [v9, HEAD] are put back, or equals the pinned v9 text (new in v9): the Guardian and
+// FeeRecipient proposal targets (newGuardian(v.next), feeRecipient(v.recipient)), the parsers they use, and the
+// listing rows (checkRows, unchanged) and the Finalize helpers.
+const pinnedV9={
+ 'web/src/governance.ts':{
+  proposalAction:[['v: Record<string, string>, settings?: any): Action','v: Record<string, string>): Action'],['target: newGuardian(v.next)','target: address(v.next)'],['target: feeRecipient(v.recipient)','target: recipient(v.recipient)'],['settingValues(v, settings)','settingValues(v)']],
+  proposalSpec:[['v: Record<string, string>, settings?: any) { return vault("propose", [proposalAction(kind, v, settings)]); }','v: Record<string, string>) { return vault("propose", [proposalAction(kind, v)]); }']],
+  settingValues:[['v: Record<string, string>, settings?: any): [','v: Record<string, string>): ['],['if (springForwardStart(from, settings ? BigInt(settings.dst) : 0n)) throw new InputError(SPRING_FORWARD_START); ','']],
+  poolValues:[['l = minLiquidityOf(v.minLiquidity);','l = uint(v.minLiquidity);']],
+  newOwner:'export function newOwner(v: string): Address { const next = address(v); if (same(next, VAULT)) throw new InputError("The new owner must not be the vault."); return next; }',
+  newGuardian:'function newGuardian(v: string): Address { const next = address(v); if (same(next, VAULT)) throw new InputError("The new guardian must not be the vault."); return next; }',
+  feeRecipient:'function feeRecipient(v: string): Address { const target = address(v); if (same(target, VAULT)) throw new InputError("The fee recipient must not be the vault."); return target; }',
+  minLiquidityOf:'function minLiquidityOf(v: string) { try { return uint(v, 128); } catch { throw new InputError("Minimum raw pool liquidity: enter an unsigned 128-bit whole number."); } }',
+  springForwardStart:'export function springForwardStart(from: bigint, dst: bigint) { return dst === 0n && from >= 7200n && from < 10800n; }',
+  SPRING_FORWARD_START:'export const SPRING_FORWARD_START = "Sunday 2:00-2:59 am New York is skipped on the spring-forward Sunday; choose another start.";'},
+ 'web/src/Owner.tsx':{
+  checkRows:[],
+  listedDiffers:'function listedDiffers(assets: Asset[], r: ReturnType<typeof parseLaunch>[number]) { const a = assets.find((x) => same(x.token, r.token)); return (!!a && (!same(a.feed, r.feed) || !same(a.pool, r.pool) || !same(a.quoteFeed, r.quoteFeed) || a.minLiquidity !== r.minLiquidity)); }',
+  differWords:'const differWords = (tickers: string[]) => `Listed with other values than the pasted lines: ${tickers.join(", ")}. Check pairings shows which field; paste the lines that were listed.`;',
+  PASTE_FIRST:'const PASTE_FIRST = "Paste the listing rows first so the page can check none is missing.";'},
+};
+const one=s=>s.replace(/\s+/g,' ');
+for(const [file,map] of Object.entries(pinnedV9)){
+ const list=Object.keys(map),n=declarations(file,read(file),list),old=list.filter(k=>typeof map[k]!=='string'),h=declarations(file,baseline(file),old);
+ for(const k of list)assert.equal(typeof map[k]==='string'?one(n[k]):putBack(one(n[k]),map[k],file+' '+k),typeof map[k]==='string'?map[k]:one(h[k]),file+': '+k+' differs from the pinned v9 text');
+}
+// The names those closures call are bound once, by the import from the module that defines them (no local
+// declaration in any scope can stand in for newOwner, vault, read, ...).
+const imports={'web/src/Owner.tsx':{newOwner:'./governance',inspectListing:'./governance',proposalSpec:'./governance',vault:'./chain',read:'./chain',InputError:'./chain',address:'./model',same:'./model',parseLaunch:'./model',loadSnapshot:'./model',TransactionCancelled:'./wallet'},
+ 'web/src/governance.ts':{vault:'./chain',VAULT:'./chain',InputError:'./chain',address:'./model',same:'./model',uint:'./model',amount:'./model'}};
+for(const [file,map] of Object.entries(imports)){
+ const tree=ts.createSourceFile(file,read(file),ts.ScriptTarget.Latest,true,file.endsWith('tsx')?ts.ScriptKind.TSX:ts.ScriptKind.TS),bound={};
+ (function v(n){
+  const id=n.name&&ts.isIdentifier(n.name)&&(ts.isVariableDeclaration(n)||ts.isFunctionDeclaration(n)||ts.isFunctionExpression(n)||ts.isParameter(n)||ts.isBindingElement(n)||ts.isClassDeclaration(n)||ts.isImportSpecifier(n)||ts.isNamespaceImport(n)||ts.isImportClause(n))?n.name.text:undefined;
+  if(id&&map[id])(bound[id]??=[]).push(ts.isImportSpecifier(n)&&!n.propertyName?n.parent.parent.parent.moduleSpecifier.text:'local '+ts.SyntaxKind[n.kind]);
+  ts.forEachChild(n,v);
+ })(tree);
+ for(const [k,m] of Object.entries(map))assert.deepEqual(bound[k],[m],file+': '+k+' is bound only by its import from '+m);
 }
-const files=['Flows.tsx','Vault.tsx'],counts={};
-for(const f of files){const old=calls(baseline('web/src/'+f),f),now=calls(read('web/src/'+f),f);assert.deepEqual(now,old,f+' changed calldata/read/check call expressions');counts[f]=now.length;}
-fs.writeFileSync('../artifacts/calldata-comparison.json',JSON.stringify({result:'PASS',baseline:execFileSync('git',['rev-parse','HEAD'],{cwd:root,encoding:'utf8'}).trim(),protectedFiles,counts,checks:['Losses.tsx, main.tsx, components.tsx and Scenery.tsx byte-identical to HEAD','All vault/token/feed calls, transaction arguments, encodings, reads and simulations in Flows.tsx and Vault.tsx equal the HEAD AST; only the VAULT constant and wording differ','chain.ts, model.ts, governance.ts, Owner.tsx, wallet.tsx, Docs.tsx, poolMath.ts and newYork.ts carry the vault 6 ABI, names and New York hours']},null,2)+'\n');
-console.log('PASS baseline call-expression comparison',counts);
+assert.equal(now.VAULT,head.VAULT,'the vault address the encoders use');
+for(const m of [U128,'The new guardian must not be the vault.','The new owner must not be the vault.',SPRING]) assert.ok(tally.newRefusals[m]>0,'corpus exercises: '+m);
+assert.ok(tally.sameCalldata>400,'corpus size '+JSON.stringify(tally));
+fs.rmSync(scratch,{recursive:true,force:true});
+fs.writeFileSync('../artifacts/calldata-comparison.json',JSON.stringify({result:'PASS',baseline:git(['rev-parse','HEAD']).trim(),protectedFiles,editedFiles:{'main.tsx':'A4: the footer tagline span removed','Scenery.tsx':'A2: eight slogan lines per strip half instead of four'},counts,
+ documentedGuardedCallChanges:expected,ownerActionAttributeChanges:ownerChanges,vaultStockShelves:{attributes:vaultAttributes,handlers:vaultHandlers},walletSendDocumentedPieces:sendEdits.map(([now,head])=>({now,head})),
+ differentialEncoding:{cases:cases.length,...tally},sendBuilders:{clocks,...sends},pinnedDeclarations:pinned,
+ sendsAndRequests:{sendFreeFiles:NO_SEND,usesPerFile:Object.fromEntries(Object.entries(sendUses).map(([f,x])=>[f,x.length])),components:sendUses['components.tsx'].filter(x=>/\(/.test(x))},
+ pinnedV9Declarations:Object.fromEntries(Object.entries(pinnedV9).map(([f,m])=>[f,Object.fromEntries(Object.entries(m).map(([k,x])=>[k,typeof x==='string'?'v9 text':x.length+' pieces from HEAD']))])),importBindings:imports,
+ checks:['Losses.tsx, poolMath.ts, deployment.ts and vault.abi.json byte-identical to HEAD; main.tsx and Scenery.tsx byte-identical to HEAD once the one documented edit is put back (A4 footer tagline removed; A2 eight slogan lines per half); no source file added or removed',
+  'Every vault/token/feed/read call, transaction argument parser, encoding, simulation and send (guarded names) in every web/src source equals the HEAD AST in order, apart from the exact documented changes listed here',
+  'Action/send/check JSX attributes equal HEAD in every file except the seven listed Owner.tsx attributes, whose send calls are compared one by one and whose whole printed text equals HEAD once their documented pieces are put back (the listing row checkedRows[i], the listGenesis arguments, newOwner(v.next) included), and Vault.tsx, whose attributes equal the pinned list (HEAD\'s Retry vault button and address links plus the Stock shelves controls, none with a guarded call) and whose StockShelves handlers equal their pinned text; Vault.tsx has no guarded call at all',
+  'Wallet sends and raw requests: in every web/src file the uses of a send/request name or of the provider (ethereum) with their calls, every string naming a sending or signing method, computed access to the global object and eval/Function/Reflect equal HEAD in order, with no exception; Vault, Scenery, main and Docs have no send or request (main only reads window.ethereum), components keeps the single wallet.send of HEAD',
+  'Argument sources: governance.ts proposalAction (Guardian target newGuardian(v.next), FeeRecipient target feeRecipient(v.recipient)), proposalSpec, settingValues and poolValues equal HEAD once their documented pieces are put back; newOwner, newGuardian, feeRecipient, minLiquidityOf and the spring-forward rule equal the pinned v9 text; Owner.tsx checkRows equals HEAD and the Finalize helpers equal the pinned v9 text; the names these call are bound only by their imports; the encoders use the same vault address',
+  'wallet.tsx send() (the only wallet prompt) equals HEAD once the six documented F13/F7/A5 pieces are put back: from, to, data, gas, nonce, chain and account rechecks, simulation and the eth_sendTransaction request unchanged',
+  'Every call expression in components.tsx, Docs.tsx and Flows.tsx equals HEAD, apart from the F11 Redeem-leg index pair',
+  'Differential encoding of HEAD and current governance/model/chain: identical calldata for every input the page accepts (proposals of every kind, transfer ownership, genesis listing); the only new refusals are the documented ones (uint128 minLiquidity, vault as guardian or new owner, Sunday 2:00-2:59 am start under Dst 0); nothing HEAD refused is accepted',
+  'Under six fixed clocks: deadline() and the full depositArgs and redeemArgs tuples (deadline included) equal HEAD, and so does the encoded deposit and redeem calldata; redeem built as Flows does (amount, recipient, redeemArgs), approve (amount with 0/6/8/18 decimals), claim (recipient), lowerNAVCap (amount, zero allowed), close and removeRetired (address), and the uint and address parsers give the same value or are refused by both, with no new refusal',
+  'The printed text (no comments) of same, deadline, depositArgs, redeemArgs, amount, address, recipient, uint and parseLaunch in model.ts and of vault, token and encode in chain.ts equals HEAD',
+  'Only the look and fix files change in web/src (check-bundle.mjs)']},null,2)+'\n');
+console.log('PASS baseline call-expression comparison',counts,'differential encoding',tally,'send builders',sends);
diff --git a/web/scripts/check-interface.ts b/web/scripts/check-interface.ts
index 90501cd..23cd036 100644
--- a/web/scripts/check-interface.ts
+++ b/web/scripts/check-interface.ts
@@ -6,10 +6,23 @@ import {
   parseLaunch,
   depositArgs,
   redeemArgs,
+  date,
+  hoursWords,
 } from "../src/model";
-import { settingWords, proposalAction, poolValues } from "../src/governance";
+import {
+  settingWords,
+  proposalAction,
+  poolValues,
+  settingValues,
+  gasMaximum,
+  settingBoundsWords,
+  freshWords,
+  proposalWords,
+  newOwner,
+  SPRING_FORWARD_START,
+} from "../src/governance";
 import { sqrtAtTick, poolMetrics } from "../src/poolMath";
-import { VAULT, zeroAddress } from "../src/chain";
+import { VAULT, zeroAddress, reasonWords, minutesOf } from "../src/chain";
 import {
   inside,
   nextOpening,
@@ -17,7 +30,15 @@ import {
   weekdayWords,
   hoursWordsOf,
   dstWords,
+  dateWords,
 } from "../src/newYork";
+import {
+  closedWords,
+  reopenAt,
+  mayBeOpen,
+  localWords,
+  hoursLine,
+} from "../src/Vault";
 // A wrong-checksum address built from VAULT itself: flip the case of its letters.
 const badChecksum = VAULT.replace(/[a-f]/g, (c) => c.toUpperCase());
 assert.notEqual(badChecksum, VAULT);
@@ -110,6 +131,365 @@ assert.throws(() =>
 );
 assert.equal(depositArgs([VAULT], [1n], VAULT, 1000n)[3], 995n);
 assert.deepEqual(redeemArgs(1n, VAULT, [0n, 3333n])[2], [0n, 3329n]);
+// ---- v9 low fixes ----
+const other = "0x1111111111111111111111111111111111111111";
+// F1: minLiquidity of a Pool or List proposal is a 128-bit number, like the listing parser.
+const u128 = 2n ** 128n - 1n;
+assert.equal(
+  poolValues({ pool: VAULT, quoteFeed: VAULT, minLiquidity: String(u128) })[2],
+  u128,
+);
+for (const big of [2n ** 128n, 2n ** 256n - 1n])
+  assert.throws(
+    () =>
+      poolValues({ pool: VAULT, quoteFeed: VAULT, minLiquidity: String(big) }),
+    /Minimum raw pool liquidity: enter an unsigned 128-bit whole number\./,
+  );
+assert.throws(
+  () => poolValues({ pool: VAULT, quoteFeed: VAULT, minLiquidity: "0" }),
+  /above zero/,
+);
+assert.equal(
+  proposalAction(5, {
+    token: VAULT,
+    pool: VAULT,
+    quoteFeed: VAULT,
+    minLiquidity: String(u128),
+  }).value,
+  u128,
+);
+assert.throws(
+  () =>
+    proposalAction(0, {
+      token: VAULT,
+      feed: VAULT,
+      pool: VAULT,
+      quoteFeed: VAULT,
+      minLiquidity: String(2n ** 128n),
+    }),
+  /128-bit/,
+);
+assert.throws(
+  () => parseLaunch(`BASK ${VAULT} ${VAULT} ${VAULT} ${VAULT} ${2n ** 128n}`),
+  /128-bit/,
+);
+// F2: BalanceGas/PayGas maximum, checked against the combined rule in
+// BaskVault._changedSettings (bounds 20,000-500,000 too).
+const allowed = (c: any) =>
+  c.balanceGas >= 20_000n &&
+  c.balanceGas <= 500_000n &&
+  c.payGas >= 20_000n &&
+  c.payGas <= 500_000n &&
+  c.maxAssets <= 28_000_000n / (c.balanceGas + 60_000n) &&
+  c.directLimit <= 28_000_000n / (c.balanceGas + c.payGas + 70_000n);
+const gasCases = [
+  { maxAssets: 100n, directLimit: 100n, balanceGas: 100_000n, payGas: 100_000n },
+  { maxAssets: 40n, directLimit: 3n, balanceGas: 50_000n, payGas: 300_000n },
+  { maxAssets: 25n, directLimit: 0n, balanceGas: 50_000n, payGas: 50_000n },
+  { maxAssets: 350n, directLimit: 254n, balanceGas: 20_000n, payGas: 20_000n },
+];
+for (const c of gasCases) {
+  // Current settings always pass the vault's own check.
+  assert.ok(allowed(c));
+  for (const [key, field] of [
+    [12, "balanceGas"],
+    [13, "payGas"],
+  ] as const) {
+    const max = gasMaximum(key, c)!;
+    if (max >= 20_000n)
+      assert.ok(allowed({ ...c, [field]: max }), `${field} ${max} allowed`);
+    assert.ok(!allowed({ ...c, [field]: max + 1n }), `${field} ${max + 1n} refused`);
+  }
+}
+assert.equal(gasMaximum(12, gasCases[0]), 110_000n);
+assert.equal(gasMaximum(13, gasCases[0]), 110_000n);
+assert.equal(gasMaximum(13, gasCases[2]), 500_000n);
+assert.match(
+  settingBoundsWords(12, gasCases[0]),
+  /maxAssets × \(balanceGas \+ 60,000\) ≤ 28,000,000 and directLimit × \(balanceGas \+ payGas \+ 70,000\) ≤ 28,000,000\. Current maximum 110,000 /,
+);
+assert.match(
+  settingBoundsWords(13, gasCases[0]),
+  /directLimit × \(balanceGas \+ payGas \+ 70,000\) ≤ 28,000,000\. Current maximum 110,000 /,
+);
+assert.equal(gasMaximum(12, gasCases[3]), 20_000n);
+assert.equal(gasMaximum(13, gasCases[3]), 20_236n);
+// Words for a maximum under 20,000 (settings the vault would not hold).
+assert.match(
+  settingBoundsWords(12, { ...gasCases[3], maxAssets: 400n }),
+  /no value fits: lower MaxAssets or DirectLimit first/,
+);
+assert.match(settingBoundsWords(13, undefined), /Current maximum unreadable/);
+assert.equal(gasMaximum(11, gasCases[0]), undefined);
+// F3: Dst 1 or 2 hours are a fixed UTC-5 / UTC-4, not New York time.
+assert.equal(
+  hoursWordsOf(72000n, 504000n, 1n),
+  "Sunday 8:00 pm to Friday 8:00 pm UTC-5",
+);
+assert.equal(
+  hoursWordsOf(72000n, 504000n, 2n),
+  "Sunday 8:00 pm to Friday 8:00 pm UTC-4",
+);
+assert.equal(
+  hoursWordsOf(72000n, 504000n, 0n),
+  "Sunday 8:00 pm to Friday 8:00 pm New York time",
+);
+const hoursSettings = (dst: bigint) => ({
+  hoursFrom: 72000n,
+  hoursTo: 504000n,
+  dst,
+  freshCount: 1n,
+  freshHours: 1n,
+  poolWindow: 1800n,
+  poolDeviation: 300n,
+});
+assert.equal(
+  hoursWords(hoursSettings(1n)),
+  "Sunday 8:00 pm to Friday 8:00 pm UTC-5",
+);
+assert.equal(
+  settingWords(5, 72000n, 504000n, hoursSettings(2n)),
+  "Sunday 8:00 pm to Friday 8:00 pm UTC-4",
+);
+// F9: the Vault and Deposit pages show the hours in words only.
+assert.equal(
+  hoursLine(hoursSettings(0n)),
+  "Sunday 8:00 pm to Friday 8:00 pm New York time",
+);
+// F6: the countdown follows now (block time plus the seconds since the read)
+// and never shows next week's time at the boundary.
+const saturdayNoon = BigInt(Date.UTC(2026, 9, 10, 16, 0) / 1000); // Sat 10 Oct 2026, 12:00 New York
+for (const dst of [0n, 1n, 2n]) {
+  const s = hoursSettings(dst),
+    t = nextOpening(saturdayNoon, 72000n, dst);
+  assert.equal(reopenAt(s, t - 1n), t);
+  assert.equal(reopenAt(s, t), undefined, "read block already inside the hours");
+  const zone = dst === 0n ? "New York time" : dst === 1n ? "UTC-5" : "UTC-4";
+  assert.match(
+    closedWords(3, s, t - 7260n, t - 7260n)!,
+    new RegExp(
+      `^Deposits reopen Sunday 8:00 pm ${zone} \\(.*, in 2 h 1 min; your time .*\\)\\.`,
+    ),
+  );
+  assert.match(closedWords(3, s, t - 7260n, t - 7200n)!, /, in 2 h 0 min; /);
+  assert.match(closedWords(3, s, t - 7260n, t - 1n)!, /, in 0 h 0 min; /);
+  assert.equal(closedWords(3, s, t - 7260n, t), mayBeOpen);
+  assert.equal(
+    closedWords(3, s, t, t),
+    mayBeOpen,
+    "status reason 3 read on an earlier block",
+  );
+  assert.equal(closedWords(3, s, t + 3600n, t + 3600n), mayBeOpen);
+}
+assert.equal(mayBeOpen, "Deposits may be open now. Press Refresh vault.");
+// F7: dates in words, never a numeric date.
+const oct11 = BigInt(Date.UTC(2026, 9, 11, 4, 40) / 1000);
+assert.equal(dateWords(oct11), "Sun 11 Oct 2026, 04:40 UTC (00:40 New York)");
+assert.equal(date(oct11), "Sun 11 Oct 2026, 04:40 UTC (00:40 New York)");
+assert.equal(
+  date(BigInt(Date.UTC(2026, 9, 11, 2, 5) / 1000)),
+  "Sun 11 Oct 2026, 02:05 UTC (Sat 22:05 New York)",
+);
+assert.equal(
+  date(BigInt(Date.UTC(2027, 0, 4, 15, 0) / 1000)),
+  "Mon 4 Jan 2027, 15:00 UTC (10:00 New York)",
+);
+assert.equal(date(0n), "Not set");
+assert.equal(date(undefined), "unreadable");
+assert.equal(date(2n ** 64n), "unreadable");
+// v9 A5: a window start ("executable from", "Wait until", Losses' recognition date; the default) is rounded up to
+// the next whole minute when it has seconds, an end ("until just before") down; whole minutes stay as they are.
+const at0440 = "Sun 11 Oct 2026, 04:40 UTC (00:40 New York)",
+  at0441 = "Sun 11 Oct 2026, 04:41 UTC (00:41 New York)";
+assert.equal(date(oct11, "start"), at0440);
+assert.equal(date(oct11, "end"), at0440);
+for (const s of [1n, 30n, 59n]) {
+  assert.equal(date(oct11 + s), at0441, `start + ${s} s rounds up`);
+  assert.equal(date(oct11 + s, "start"), at0441);
+  assert.equal(date(oct11 + s, "end"), at0440, `end + ${s} s rounds down`);
+}
+assert.equal(date(oct11 + 60n, "end"), at0441);
+assert.equal(date(oct11 - 1n, "end"), "Sun 11 Oct 2026, 04:39 UTC (00:39 New York)");
+// Rounding up crosses the hour, the day (and the New York weekday) and the year.
+assert.equal(
+  date(BigInt(Date.UTC(2026, 9, 11, 3, 59, 1) / 1000)),
+  "Sun 11 Oct 2026, 04:00 UTC (00:00 New York)",
+);
+assert.equal(
+  date(BigInt(Date.UTC(2026, 9, 11, 3, 59, 1) / 1000), "end"),
+  "Sun 11 Oct 2026, 03:59 UTC (Sat 23:59 New York)",
+);
+assert.equal(
+  date(BigInt(Date.UTC(2026, 11, 31, 23, 59, 30) / 1000)),
+  "Fri 1 Jan 2027, 00:00 UTC (Thu 19:00 New York)",
+);
+// Never earlier than the real start, never later than the real end, at every second of a sample hour.
+for (let s = 0n; s < 3600n; s += 7n) {
+  const t = oct11 + s,
+    words = (x: string) => {
+      const m = x.match(/^\w{3} (\d+) \w{3} 2026, (\d{2}):(\d{2}) UTC/)!;
+      return BigInt(Date.UTC(2026, 9, Number(m[1]), Number(m[2]), Number(m[3])) / 1000);
+    };
+  const up = words(date(t)),
+    down = words(date(t, "end"));
+  assert.ok(up >= t && up - t < 60n && up % 60n === 0n, `start ${t}`);
+  assert.ok(down <= t && t - down < 60n && down % 60n === 0n, `end ${t}`);
+}
+assert.equal(date(1n), "Thu 1 Jan 1970, 00:01 UTC (Wed 19:01 New York)");
+assert.equal(date(253402300740n), "Fri 31 Dec 9999, 23:59 UTC (18:59 New York)");
+assert.equal(date(253402300741n), "unreadable", "rounding up past year 9999");
+assert.equal(date(253402300799n, "end"), "Fri 31 Dec 9999, 23:59 UTC (18:59 New York)");
+// Every date() shown on the pages: "until just before" (the end of a proposal's window) rounds down, every other one
+// (executable from, Wait until, Losses' recognition date) is a start and rounds up.
+{
+  const shown: string[] = [];
+  for (const f of ["Owner.tsx", "wallet.tsx", "Losses.tsx", "Vault.tsx", "Flows.tsx", "main.tsx", "components.tsx", "Docs.tsx"]) {
+    const text = fs.readFileSync(`src/${f}`, "utf8");
+    for (const m of text.matchAll(/(.{0,40})\bdate\(([^()]*)\)/g)) shown.push(`${f}: ${m[1].trim()} date(${m[2]})`);
+  }
+  assert.deepEqual(shown.filter((x) => /"end"/.test(x)).map((x) => /until just before \$\{ ?date\(/.test(x)), [true, true], "the two window ends round down");
+  for (const x of shown.filter((x) => !/"end"/.test(x))) assert.ok(!/until just before/.test(x), "an end rounded up: " + x);
+  assert.equal(shown.length, 7, "date() uses on the pages: " + JSON.stringify(shown));
+}
+const local = localWords(oct11);
+assert.equal(
+  local,
+  new Date(Number(oct11) * 1000).toLocaleString(undefined, {
+    weekday: "short",
+    day: "numeric",
+    month: "short",
+    hour: "numeric",
+    minute: "2-digit",
+    timeZoneName: "short",
+  }),
+);
+assert.doesNotMatch(local, /\d{1,2}:\d{2}:\d{2}/, "no seconds");
+assert.doesNotMatch(
+  local,
+  /\d{1,4}[/.-]\d{1,2}[/.-]\d{1,4}/,
+  "no numeric date",
+);
+assert.ok(
+  closedWords(3, hoursSettings(0n), oct11 - 90000n, oct11 - 90000n)!.includes(
+    `your time ${localWords(nextOpening(oct11 - 90000n, 72000n, 0n))})`,
+  ),
+);
+// F8: FreshCount in words, with singular and plural.
+assert.equal(freshWords(0n, 1n), "off: deposits stay open when prices stop");
+assert.equal(
+  freshWords(1n, 1n),
+  "at least 1 listed stock price updated within the last 1 hour; deposits close when prices stop (US market holidays) until one updates",
+);
+assert.equal(
+  freshWords(3n, 2n),
+  "at least 3 listed stock prices updated within the last 2 hours; deposits close when prices stop (US market holidays) until one updates",
+);
+assert.equal(
+  settingWords(3, 2n, 0n, { freshHours: 1n }),
+  "at least 2 listed stock prices updated within the last 1 hour; deposits close when prices stop (US market holidays) until one updates",
+);
+assert.equal(settingWords(3, 0n), "off: deposits stay open when prices stop");
+assert.match(settingWords(4, 1n), /^1 hour; /);
+assert.match(settingWords(4, 48n), /^48 hours; /);
+// F12: reason 12 and the pairing label use settings().poolWindow and poolDeviation.
+assert.equal(
+  reasonWords(12, hoursSettings(0n)),
+  "pool check failed (30-minute pool price over 3% off the feed, unreadable, under its floor or quote feed bad)",
+);
+assert.equal(
+  reasonWords(12, { poolWindow: 900n, poolDeviation: 150n }),
+  "pool check failed (15-minute pool price over 1.5% off the feed, unreadable, under its floor or quote feed bad)",
+);
+assert.doesNotMatch(reasonWords(12, null), /30-minute|3%/);
+assert.equal(reasonWords(3, hoursSettings(0n)), "outside deposit hours");
+assert.equal(minutesOf(1800n), "30-minute");
+assert.equal(minutesOf(600n), "10-minute");
+// F15: under Dst 0 an Hours start on Sunday 2:00-2:59 am is refused (skipped
+// on the spring-forward Sunday); unreadable settings count as Dst 0.
+const springForward = new RegExp(
+  SPRING_FORWARD_START.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"),
+);
+assert.equal(
+  SPRING_FORWARD_START,
+  "Sunday 2:00-2:59 am New York is skipped on the spring-forward Sunday; choose another start.",
+);
+for (const from of [
+  "Sunday 2:00 am",
+  "Sunday 2:30 am",
+  "Sunday 2:59 am",
+  "Sunday 02:15",
+])
+  for (const settings of [{ dst: 0n }, undefined]) {
+    assert.throws(
+      () => settingValues({ setting: "5", from, to: "Friday 4:00 pm" }, settings),
+      springForward,
+    );
+    assert.throws(
+      () =>
+        proposalAction(10, { setting: "5", from, to: "Friday 4:00 pm" }, settings),
+      springForward,
+    );
+  }
+for (const dst of [1n, 2n])
+  assert.deepEqual(
+    settingValues(
+      { setting: "5", from: "Sunday 2:30 am", to: "Friday 4:00 pm" },
+      { dst },
+    ),
+    [5, 9000n, 489600n],
+  );
+for (const from of ["Sunday 1:59 am", "Sunday 3:00 am", "Monday 2:30 am"])
+  assert.equal(
+    settingValues({ setting: "5", from, to: "Friday 4:00 pm" }, { dst: 0n })[0],
+    5,
+  );
+assert.deepEqual(
+  settingValues(
+    { setting: "5", from: "Sunday 1:00 am", to: "Sunday 2:30 am" },
+    { dst: 0n },
+  ),
+  [5, 3600n, 9000n],
+  "only the start is refused",
+);
+assert.deepEqual(
+  settingValues(
+    { setting: "5", from: "Always open", to: "Always open" },
+    { dst: 0n },
+  ),
+  [5, 0n, 0n],
+);
+// F16: the vault is refused as new owner, guardian and fee recipient (zero was already refused).
+for (const v of [VAULT, VAULT.toLowerCase()]) {
+  assert.throws(() => newOwner(v), /The new owner must not be the vault\./);
+  assert.throws(
+    () => proposalAction(7, { next: v }),
+    /The new guardian must not be the vault\./,
+  );
+  assert.throws(
+    () => proposalAction(9, { recipient: v }),
+    /The fee recipient must not be the vault\./,
+  );
+}
+for (const k of [7, 9])
+  assert.throws(
+    () => proposalAction(k, { next: zeroAddress, recipient: zeroAddress }),
+    /valid nonzero address/,
+  );
+assert.throws(() => newOwner(zeroAddress), /valid nonzero address/);
+assert.equal(newOwner(other), other);
+assert.equal(proposalAction(7, { next: other }).target, other);
+assert.equal(proposalAction(9, { recipient: other }).target, other);
+assert.match(
+  proposalWords(
+    proposalAction(10, {
+      setting: "5",
+      from: "Monday 9:30 am",
+      to: "Friday 4:00 pm",
+    }),
+    hoursSettings(1n),
+  ),
+  /Monday 9:30 am to Friday 4:00 pm UTC-5$/,
+);
 fs.mkdirSync("../artifacts", { recursive: true });
 fs.writeFileSync(
   "../artifacts/interface-unit.json",
@@ -124,6 +504,16 @@ fs.writeFileSync(
         "Action struct per proposal kind; set pool refuses minLiquidity 0",
         "TickMath boundaries and harmonic liquidity formula",
         "unchanged deposit/redeem minimum arithmetic",
+        "v9 F1: Pool/List minLiquidity limited to 128 bits; a set pool with 0 still refused",
+        "v9 F2: BalanceGas/PayGas maximum equals the vault's combined rule at max and max+1; bounds words",
+        "v9 F3/F9: Dst 1 and 2 hours in UTC-5/UTC-4 words; Vault/Deposit hours in words only",
+        "v9 F6: countdown follows the vault clock; boundary and inside-hours cases say Deposits may be open now",
+        "v9 F7: dates in words (UTC and New York, US rule), your time without seconds or a numeric date",
+        "v9 A5: a waiting window's start rounded up to the next whole minute, its end ('until just before') down",
+        "v9 F8: FreshCount words with singular and plural; 0 is off",
+        "v9 F12: reason 12 and the pairing label from settings().poolWindow and poolDeviation",
+        "v9 F15: Sunday 2:00-2:59 am Hours start refused under Dst 0 (and unreadable Dst), allowed under Dst 1 and 2",
+        "v9 F16: the vault refused as new owner, guardian and fee recipient",
       ],
     },
     null,
diff --git a/web/scripts/check-motion.mjs b/web/scripts/check-motion.mjs
index 7621650..1e4d93d 100644
--- a/web/scripts/check-motion.mjs
+++ b/web/scripts/check-motion.mjs
@@ -49,6 +49,11 @@ try {
       "losses",
     ]) {
       await page.goto(url + "#" + name);
+      // A hash change re-renders asynchronously: wait until the requested route is the current page.
+      await page.waitForFunction(
+        (n) => !!document.querySelector(`a[aria-current="page"][href="#${n}"]`),
+        name,
+      );
       await page.evaluate(() => document.fonts.ready);
       await page.waitForFunction(
         () => !document.querySelector("button.refresh").disabled,
@@ -57,7 +62,7 @@ try {
         page.evaluate(() =>
           [
             ...document.querySelectorAll(
-              ".page-title > p, .page-title h1, .brand, .burst",
+              ".page-title > p, .page-title h1, .page-title .title-character > *, .brand, .burst",
             ),
           ].map((e) => {
             const r = e.getBoundingClientRect(),
@@ -83,14 +88,75 @@ try {
       checks.push(
         `${name}: title/brand/sticker geometry stable while scrolling at Linux Chromium DPR ${scale}`,
       );
+      if (name === "vault") {
+        // v9 Stock shelves: the restocking swing is the panel's only motion and runs once per label: every animation
+        // there has one iteration and ends within 2 s (delay included); after scrolling through the whole page
+        // nothing in the panel is still moving, and scrolling back up starts nothing again.
+        const shelves = () =>
+          page.evaluate(() =>
+            document
+              .getAnimations()
+              .filter((a) => a.effect?.target?.closest?.(".stock-section"))
+              .map((a) => ({
+                label: a.effect.target.querySelector?.("h4")?.textContent ?? "",
+                iterations: a.effect.getComputedTiming().iterations,
+                end: a.effect.getComputedTiming().endTime,
+                running: a.playState === "running",
+              })),
+          );
+        const labels = await page.locator(".stock-section article.sa-label").count();
+        const height = await page.evaluate(() => document.documentElement.scrollHeight);
+        const seen = [];
+        for (let y = 0; y <= height; y += 200) {
+          await page.evaluate((y) => scrollTo(0, y), y);
+          await page.waitForTimeout(50);
+          seen.push(...(await shelves()));
+        }
+        assert.ok(
+          seen.every((a) => a.iterations === 1 && a.end <= 2000),
+          `Stock shelves: an endless or long animation at DPR ${scale}`,
+        );
+        const swung = new Set(seen.map((a) => a.label));
+        if (labels) assert.ok(swung.size > 0, `Stock shelves: no restocking swing at DPR ${scale}`);
+        await page.waitForTimeout(2100);
+        assert.equal(
+          (await shelves()).filter((a) => a.running).length,
+          0,
+          `Stock shelves still moving at DPR ${scale}`,
+        );
+        for (let y = height; y >= 0; y -= 400) {
+          await page.evaluate((y) => scrollTo(0, y), y);
+          await page.waitForTimeout(50);
+        }
+        assert.equal(
+          (await shelves()).length,
+          0,
+          `Stock shelves moved again on scrolling back at DPR ${scale}`,
+        );
+        checks.push(
+          `vault: Stock shelves restocking swing once per label (${swung.size} of ${labels} labels seen swinging), one iteration within 2 s, nothing moving afterwards or on scrolling back, DPR ${scale}`,
+        );
+      }
+      // Look update: the shot covers the title panel up to the title character; her detailed picture would
+      // multiply these tracked PNGs and break the 8 MiB bundle budget (check-bundle.mjs).
       if (name === "redeem")
-        await page
-          .locator(".page-title")
-          .screenshot({
-            path: path.join(out, `redeem-title-dpr-${scale}.png`),
-          });
+        await page.screenshot({
+          path: path.join(out, `redeem-title-dpr-${scale}.png`),
+          fullPage: true,
+          clip: await page.locator(".page-title").evaluate((e) => {
+            const r = e.getBoundingClientRect(),
+              c = e.querySelector(".title-character"),
+              right = c ? c.getBoundingClientRect().left - 8 : r.right;
+            return {
+              x: r.left,
+              y: r.top + scrollY,
+              width: right - r.left,
+              height: r.height,
+            };
+          }),
+        });
     }
-    for (const width of [375, 661, 1440, 1920, 2560]) {
+    for (const width of [375, 661, 1440, 1920, 2560, 3440]) {
       await page.setViewportSize({ width, height: 1000 });
       await page.goto(url + "#deposit");
       await page.evaluate(() => document.fonts.ready);
@@ -98,11 +164,27 @@ try {
       const lengths = await track.evaluate((e) => ({
         track: e.getBoundingClientRect().width,
         frame: e.parentElement.getBoundingClientRect().width,
+        halves: [...e.children].map((h) => ({
+          width: h.getBoundingClientRect().width,
+          shown: [...h.children].filter(
+            (s) => getComputedStyle(s).display !== "none",
+          ).length,
+        })),
+        willChange: getComputedStyle(e).willChange,
       }));
+      // v9 slogan strip: each half is k whole 720 px lines, k the fewest that cover the viewport; the moving block
+      // is at most two screens plus two lines wide and has no will-change.
+      const k = Math.min(8, Math.max(1, Math.ceil(width / 720)));
+      for (const h of lengths.halves) {
+        assert.equal(h.shown, k, `${k} lines per half at ${width}`);
+        assert.ok(Math.abs(h.width - 720 * k) < 0.5 * k, `Half width ${width}`);
+      }
       assert.ok(
-        lengths.track / 2 >= lengths.frame,
+        720 * k >= width && lengths.track / 2 >= lengths.frame - 0.01,
         `No empty stretch ${width}`,
       );
+      assert.ok(lengths.track <= 2 * (width + 720) + 0.5, `Track ${width}`);
+      assert.equal(lengths.willChange, "auto", `No will-change ${width}`);
       for (const position of [0, 0.25, 0.49999, 0.75, 0.99999]) {
         const gap = await track.evaluate((e, fraction) => {
           const a = e.getAnimations()[0];
@@ -115,7 +197,7 @@ try {
         assert.equal(gap, false);
       }
       checks.push(
-        `Marquee covers ${width}px at every sampled loop position, DPR ${scale}`,
+        `Marquee (${k} whole lines per half, no will-change) covers ${width}px at every sampled loop position, DPR ${scale}`,
       );
     }
     await context.close();
diff --git a/web/scripts/check-visibility.mjs b/web/scripts/check-visibility.mjs
index d1fa3c9..9b43d1d 100644
--- a/web/scripts/check-visibility.mjs
+++ b/web/scripts/check-visibility.mjs
@@ -2,7 +2,33 @@ import fs from 'node:fs';import http from 'node:http';import path from 'node:pat
 const server=http.createServer((req,res)=>{const ps=req.url.split('?')[0].split('/'),root=ps[1]==='old'?process.env.BASKET_BASELINE_DIST:path.resolve('../dist'),p=path.join(root,ps.slice(2).join('/')||'index.html');try{res.setHeader('Content-Type',({'.js':'application/javascript','.css':'text/css','.html':'text/html','.svg':'image/svg+xml','.webp':'image/webp','.woff2':'font/woff2'})[path.extname(p)]||'text/plain');res.end(fs.readFileSync(p));}catch{res.writeHead(404).end();}});await new Promise(r=>server.listen(0,'127.0.0.1',r));
 const b=await chromium.launch(),page=await b.newPage({viewport:{width:375,height:812},reducedMotion:'reduce'});const results=[];
 const owner=JSON.parse(fs.readFileSync('../artifacts/live-validation.json')).globals.owner;
+// v9 look (final, owner's phone mockup): on phones the pop-out character stands in the title panel above the title
+// words of Vault, Deposit and Redeem, and the no-wallet hint puts "Copy site link" on its own row (same words, 32 px
+// taller). Only these moves are allowed below the first screen; every other element visible on the first screen
+// of the previous build must still be visible there, with the same words (line breaks aside).
+const characterPages=['vault','deposit','redeem'];
+// v9 A4: the Vault title's eyebrow (the old tagline) is removed on purpose; only that element may vanish, only on Vault.
+const taglineWords=/^stocktokens.onebasket.$/i;
 await page.addInitScript(({owner})=>{if(location.search.includes('connected')) window.ethereum={request:async({method})=>method==='eth_chainId'?'0x1237':[owner]};},{owner});
 try{await page.route(/https:\/\//,async route=>{try{const r=await fetch(route.request().url(),{method:'POST',headers:{'content-type':'application/json'},body:route.request().postData()});await route.fulfill({body:await r.text(),contentType:'application/json'});}catch{await route.abort();}});
-for(const variant of ['no-wallet','connected']) for(const name of ['vault','deposit','redeem','docs','owner','losses']){const snapshots=[];for(const ver of ['old','new']){await page.goto(`http://127.0.0.1:${server.address().port}/${ver}/?${variant}#${name}`);await page.evaluate(()=>document.fonts.ready);await page.waitForFunction(()=>!document.querySelector('button.refresh').disabled);await page.evaluate(()=>scrollTo(0,0));snapshots.push(await page.locator('main p, main input, main button, main select, main textarea, main summary, main .empty, main .note').evaluateAll(es=>es.filter(e=>e.getBoundingClientRect().height>0).map(e=>({tag:e.tagName,text:e.innerText||e.getAttribute('aria-label')||e.name||e.type,y:e.getBoundingClientRect().top,bottom:e.getBoundingClientRect().bottom}))))}
-const prior=snapshots[0].filter(x=>x.y>=0&&x.bottom<=812);results.push({variant,name,prior,regressions:prior.filter(x=>!snapshots[1].some(y=>x.text===y.text&&y.bottom<=812))});}for(const r of results) if(r.regressions.length) throw Error(JSON.stringify(r));console.log('PASS 375x812 baseline visibility: six pages, no-wallet and connected');fs.writeFileSync('../artifacts/phone-visibility.json',JSON.stringify(results,null,2));}finally{await b.close();await new Promise(r=>server.close(r));}
+for(const variant of ['no-wallet','connected']) for(const name of ['vault','deposit','redeem','docs','owner','losses']){const snapshots=[],layout=[];for(const ver of ['old','new']){await page.goto(`http://127.0.0.1:${server.address().port}/${ver}/?${variant}#${name}`);await page.evaluate(()=>document.fonts.ready);await page.waitForFunction(()=>!document.querySelector('button.refresh').disabled);await page.evaluate(()=>scrollTo(0,0));snapshots.push(await page.locator('main p, main input, main button, main select, main textarea, main summary, main .empty, main .note').evaluateAll(es=>es.filter(e=>e.getBoundingClientRect().height>0).map(e=>({tag:e.tagName,text:e.innerText||e.getAttribute('aria-label')||e.name||e.type,y:e.getBoundingClientRect().top,bottom:e.getBoundingClientRect().bottom,inTitle:!!e.closest('.page-title')}))));
+layout.push(await page.evaluate(()=>{const box=s=>{const e=document.querySelector(s);if(!e)return null;const r=e.getBoundingClientRect();return {top:r.top,bottom:r.bottom,height:r.height};};return {hint:box('main .wallet-help'),title:box('main .page-title'),picture:box('main .page-title .title-character img.character-picture')};}));}
+const words=t=>String(t).replace(/\s+/g,''),[old,now]=snapshots,[,newLayout]=layout,oldLayout=layout[0];
+const hintGrowth=(newLayout.hint?.height??0)-(oldLayout.hint?.height??0);
+// Where an element of the previous first screen went; null if its words are gone.
+const counterpart=x=>now.filter(y=>words(y.text)===words(x.text)).sort((a,c)=>Math.abs(a.y-x.y)-Math.abs(c.y-x.y))[0]??null;
+const prior=old.filter(x=>x.y>=0&&x.bottom<=812),moved=[],removed=[],regressions=[];
+for(const x of prior){const y=counterpart(x);if(y&&y.bottom<=812)continue;
+ if(!y&&name==='vault'&&taglineWords.test(words(x.text))){removed.push({tag:x.tag,oldBottom:x.bottom,reason:'old Vault eyebrow (tagline) removed (v9)'});continue;}
+ // Title words of the character pages: below the character's head, still inside the title panel.
+ const character=!!y&&y.inTitle&&characterPages.includes(name)&&!!newLayout.picture&&y.y>newLayout.picture.top;
+ // Title words pushed down by the taller wallet hint only (no wallet), by no more than its growth.
+ const hint=!!y&&y.inTitle&&variant==='no-wallet'&&hintGrowth>0&&hintGrowth<=40&&y.bottom<=812+hintGrowth+1;
+ if(character||hint)moved.push({tag:x.tag,text:x.text,oldBottom:x.bottom,newBottom:y.bottom,reason:character?'pop-out character above the title words (v9 look)':'wallet hint '+hintGrowth+' px taller (v9 look)'});
+ else regressions.push({...x,now:y});}
+const checks=[];
+if(characterPages.includes(name)){checks.push('character picture starts on the first screen');if(!newLayout.picture||newLayout.picture.height<=0||newLayout.picture.top<0||newLayout.picture.top>=812)regressions.push({tag:'IMG',text:'title character',now:newLayout.picture});}
+// The report leaves the removed tagline's words out.
+results.push({variant,name,prior:prior.map(x=>taglineWords.test(words(x.text))?{...x,text:'(old Vault eyebrow, removed)'}:x),hintGrowth,moved,removed,checks,regressions});}
+for(const r of results) if(r.regressions.length) throw Error(JSON.stringify({variant:r.variant,name:r.name,regressions:r.regressions,moved:r.moved}));
+console.log('PASS 375x812 baseline visibility: six pages, no-wallet and connected;',results.reduce((n,r)=>n+r.moved.length,0),'title elements moved by the v9 look (character, wallet hint);',results.reduce((n,r)=>n+r.removed.length,0),'tagline elements removed (Vault)');fs.writeFileSync('../artifacts/phone-visibility.json',JSON.stringify(results,null,2));}finally{await b.close();await new Promise(r=>server.close(r));}
diff --git a/web/scripts/run-browser.mjs b/web/scripts/run-browser.mjs
index 4a4199e..1de4455 100644
--- a/web/scripts/run-browser.mjs
+++ b/web/scripts/run-browser.mjs
@@ -38,25 +38,130 @@ const freePort = () =>
   });
 const port = await freePort(),
   rpc = `http://127.0.0.1:${port}`;
-const upstreamRpc =
-  process.env.BASKET_RPC || "https://rpc.mainnet.chain.robinhood.com";
-const head = await fetch(upstreamRpc, {
-  method: "POST",
-  headers: { "content-type": "application/json" },
-  body: JSON.stringify({
-    jsonrpc: "2.0",
-    id: 1,
-    method: "eth_blockNumber",
-    params: [],
-  }),
-}).then((r) => r.json());
-const forkBlock = BigInt(process.env.BASKET_FORK_BLOCK || head.result);
+// The walk-through lists stocks through genesis, so vault 6 must be empty and
+// unfinalized. 83874298 is the last block where it was (same runtime hash);
+// the live vault has since been listed and may be finalized.
+const forkBlock = BigInt(process.env.BASKET_FORK_BLOCK || 83874298);
 assert.ok(forkBlock > 83448310n);
+// A pinned past block needs an archive endpoint; the public RPCs prune it.
+const upstreamRpc =
+  process.env.BASKET_RPC || "https://robinhood.api.pocket.network";
+// Anvil forks through this local read-only proxy. It forwards read methods
+// only, asks by block number where Anvil asks by block hash (archive backends
+// refuse hash-addressed historical reads), keeps at most 8 upstream requests
+// in flight (bursts get throttled) and retries transient failures.
+const readMethods = new Set([
+  "eth_chainId",
+  "net_version",
+  "web3_clientVersion",
+  "eth_blockNumber",
+  "eth_getBlockByNumber",
+  "eth_getBlockByHash",
+  "eth_getBlockReceipts",
+  "eth_getBalance",
+  "eth_getTransactionCount",
+  "eth_getCode",
+  "eth_getStorageAt",
+  "eth_getProof",
+  "eth_getAccount",
+  "eth_getAccountInfo",
+  "eth_call",
+  "eth_gasPrice",
+  "eth_maxPriorityFeePerGas",
+  "eth_feeHistory",
+  "eth_getTransactionByHash",
+  "eth_getTransactionByBlockNumberAndIndex",
+  "eth_getTransactionReceipt",
+]);
+let upstreamActive = 0;
+const upstreamQueue = [];
+async function upstream(method, params) {
+  if (upstreamActive < 8) upstreamActive++;
+  else await new Promise((r) => upstreamQueue.push(r));
+  try {
+    for (let attempt = 1; ; attempt++) {
+      try {
+        const r = await fetch(upstreamRpc, {
+          signal: AbortSignal.timeout(60000),
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+        });
+        if (r.status === 429 || r.status >= 500)
+          throw Error(`HTTP ${r.status}`);
+        const j = await r.json(); // throws on an HTML challenge page
+        const transient = /historical state|rate limit|too many|timeout/i;
+        if (j.error && transient.test(j.error.message))
+          throw Error(j.error.message);
+        return j;
+      } catch (e) {
+        if (attempt === 6) throw e;
+        await new Promise((r) => setTimeout(r, 500 * attempt));
+      }
+    }
+  } finally {
+    const next = upstreamQueue.shift();
+    if (next) next();
+    else upstreamActive--;
+  }
+}
+const blockNumbers = new Map();
+function byNumber(p) {
+  if (!p || typeof p !== "object" || !("blockHash" in p)) return p;
+  if (!blockNumbers.has(p.blockHash))
+    blockNumbers.set(
+      p.blockHash,
+      upstream("eth_getBlockByHash", [p.blockHash, false]).then(
+        (j) => j.result.number,
+        (e) => {
+          blockNumbers.delete(p.blockHash);
+          throw e;
+        },
+      ),
+    );
+  return blockNumbers.get(p.blockHash);
+}
+const proxy = http.createServer(async (req, res) => {
+  let body = "";
+  try {
+    for await (const chunk of req) body += chunk;
+  } catch {
+    return res.destroy(); // Anvil dropped the request
+  }
+  const one = async (q) => {
+    if (!readMethods.has(q?.method))
+      return {
+        jsonrpc: "2.0",
+        id: q?.id ?? null,
+        error: { code: -32601, message: "Read-only fork proxy" },
+      };
+    try {
+      const params = await Promise.all((q.params ?? []).map(byNumber));
+      return { ...(await upstream(q.method, params)), id: q.id };
+    } catch (e) {
+      return {
+        jsonrpc: "2.0",
+        id: q.id,
+        error: { code: -32000, message: `Upstream: ${e.message}` },
+      };
+    }
+  };
+  let q = null;
+  try {
+    q = JSON.parse(body);
+  } catch {}
+  const answer = Array.isArray(q)
+    ? await Promise.all(q.map(one))
+    : await one(q);
+  res.writeHead(200, { "content-type": "application/json" });
+  res.end(JSON.stringify(answer));
+});
+await new Promise((r) => proxy.listen(0, "127.0.0.1", r));
 const proc = spawn(
   "anvil",
   [
     "--fork-url",
-    process.env.BASKET_RPC || "https://rpc.mainnet.chain.robinhood.com",
+    `http://127.0.0.1:${proxy.address().port}`,
     "--fork-block-number",
     String(forkBlock),
     "--port",
@@ -100,6 +205,9 @@ try {
     }
   }
   console.log("Fork RPC ready", rpc);
+  // Some Anvil versions refuse eth_call on the forked head ("Excess blob gas
+  // not set"); a locally mined block carries the blob-gas fields.
+  await raw("evm_mine");
   const pc = createPublicClient({ chain, transport: transport(rpc) });
   assert.equal(keccak256(await pc.getCode({ address: VAULT })), RUNTIME_HASH);
   const rv = (name, args = []) =>
@@ -308,7 +416,7 @@ try {
       return;
     }
     const file = path.resolve(dist, p.slice(9));
-    if (!file.startsWith(dist + "/")) {
+    if (!file.startsWith(dist + path.sep)) {
       res.writeHead(403).end();
       return;
     }
@@ -589,10 +697,12 @@ try {
           `${state} ${name} overflow ${width}`,
         );
         const file = `${state}-${name.toLowerCase()}-${width}.jpg`;
+        // Quality 36 (40 before v9): the Docs FAQ and the longer Owner texts made
+        // the quality-40 set about 163 KB larger, over the 8 MiB delivery budget.
         await page.screenshot({
           path: path.join(artifacts, file),
           type: "jpeg",
-          quality: 40,
+          quality: 36,
           fullPage: true,
         });
         shots.push(file);
@@ -723,6 +833,17 @@ try {
     indices.map((i) => stocks[i].toLowerCase()),
   );
   await page.getByRole("button", { name: "List stocks", exact: true }).click();
+  // The earlier "All rows listed" text stays on screen while this second pass
+  // re-reads the vault; wait for the pass to end so it cannot overlap the
+  // Finalize send (its pending checks would clear that send's status link).
+  await page.waitForFunction(
+    () =>
+      [...document.querySelectorAll("button")].find(
+        (b) => b.textContent === "List stocks",
+      )?.disabled === false,
+    null,
+    { timeout: 60000 },
+  );
   await page
     .getByText("All rows listed and matched against chain.", { exact: true })
     .waitFor({ timeout: 60000 });
@@ -1049,10 +1170,18 @@ try {
       { exact: true },
     )
     .waitFor({ state: "attached" });
-  assert.ok(
-    (await page.locator(".stock-card").first().innerText()).includes(
-      "unreadable",
-    ),
+  // v9 Stock shelves: the stocks are shelf-edge labels; with the aggregate
+  // read failed every label says its price reason is unreadable.
+  const shelfLabels = page.locator(".stock-section article.sa-label");
+  assert.ok((await shelfLabels.first().innerText()).includes("unreadable"));
+  assert.ok((await shelfLabels.count()) > 0);
+  assert.deepEqual(
+    [...new Set(await shelfLabels.locator(".sa-chip").allInnerTexts())],
+    ["price reason: unreadable"],
+  );
+  assert.equal(
+    await shelfLabels.locator(".sa-chip").count(),
+    await shelfLabels.count(),
   );
   failAggregate = false;
   checks.push("Aggregate failure fallback");
@@ -1231,4 +1360,6 @@ try {
   await browser?.close();
   if (server) await new Promise((r) => server.close(r));
   proc.kill("SIGTERM");
+  proxy.closeAllConnections?.();
+  proxy.close();
 }
diff --git a/web/src/Docs.tsx b/web/src/Docs.tsx
index 131b25f..77f6279 100644
--- a/web/src/Docs.tsx
+++ b/web/src/Docs.tsx
@@ -46,6 +46,17 @@ export function DocsPage() {
             a receiver you control.
           </p>
         </section>
+        <section className="panel">
+          <h2>FAQ</h2>
+          <h3>What if a stock can’t be sent when I redeem?</h3>
+          <p>
+            Rarely, a stock can’t be sent at that moment (for example its issuer
+            has paused transfers). The vault then keeps it for the receiver, who
+            collects it later with Claim on the Redeem page. Only the receiver
+            wallet can claim, so redeem to a wallet you control, not an exchange
+            deposit address.
+          </p>
+        </section>
         <section className="panel">
           <h2>NAV</h2>
           <p>
diff --git a/web/src/Flows.tsx b/web/src/Flows.tsx
index 34eb57c..6ea68dc 100644
--- a/web/src/Flows.tsx
+++ b/web/src/Flows.tsx
@@ -183,7 +183,18 @@ export function DepositPage({ snapshot: s, wallet: w }: Props) {
   }
   return (
     <>
-      <PageTitle eyebrow="Fill your basket" title="Deposit Stock Tokens">
+      <PageTitle
+        eyebrow="Fill your basket"
+        title="Deposit Stock Tokens"
+        character={{
+          kind: "deposit",
+          src: "./art/character/deposit.webp",
+          width: 313,
+          height: 1000,
+          alt: "Store worker holding out a shopping basket",
+          line: "Go ahead and put it in",
+        }}
+      >
         Choose one or more open stocks. They go into the vault together in one
         deposit.
       </PageTitle>
@@ -480,10 +491,6 @@ export function DepositPage({ snapshot: s, wallet: w }: Props) {
           </p>
         </section>
         <aside className="panel">
-          <div className="picture-stage deposit-picture">
-            <img className="character-picture" src="./art/character/deposit.webp" width="313" height="1000" alt="Store worker holding out a shopping basket" />
-            <p className="speech-bubble">Go ahead and put it in hehe</p>
-          </div>
           <h2>Before you deposit</h2>
           <p>Size limit: {usd(s.globals.NAV_CAP)}.</p>
           <p>
@@ -552,7 +559,18 @@ export function RedeemPage({ snapshot: s, wallet: w }: Props) {
   }, [w.account, s.loadedAt, retry]);
   return (
     <>
-      <PageTitle eyebrow="At the checkout" title="Redeem BASK">
+      <PageTitle
+        eyebrow="At the checkout"
+        title="Redeem BASK"
+        character={{
+          kind: "redeem",
+          src: "./art/character/redeem.webp",
+          width: 484,
+          height: 1000,
+          alt: "Store worker handing over a full grocery bag",
+          line: "are you sure that’s all you came here for?",
+        }}
+      >
         Receive your share of every stock. Redemption is always open.
       </PageTitle>
       <div className="flow-layout">
@@ -628,10 +646,6 @@ export function RedeemPage({ snapshot: s, wallet: w }: Props) {
                 spellCheck={false}
               />
             </label>
-            <Note warning>
-              Unsent stocks are owed to the receiver. Only that wallet can claim
-              them. Choose a wallet you control that can call this vault.
-            </Note>
             <button disabled={working || w.busy}>
               {working ? "Checking..." : "Preview redemption"}
             </button>
@@ -651,12 +665,21 @@ export function RedeemPage({ snapshot: s, wallet: w }: Props) {
             <div className="receipt">
               <h3>Redemption preview</h3>
               <p>Fee: {fmt(quote.fee)} BASK</p>
-              {s.assets.map((a, i) => (
-                <p key={a.token}>
-                  <bdi>{a.symbol}</bdi>:{" "}
-                  {fmt(quote.amounts[i], a.tokenDecimals)}
+              {/* Each leg by the stock's own assetTokens index, and only from a
+                  complete list of the same length as the preview. */}
+              {s.complete && quote.amounts.length === s.assets.length ? (
+                s.assets.map((a) => (
+                  <p key={a.token}>
+                    <bdi>{a.symbol}</bdi>:{" "}
+                    {fmt(quote.amounts[a.index], a.tokenDecimals)}
+                  </p>
+                ))
+              ) : (
+                <p>
+                  Amounts per stock are not shown: the stock list is unreadable
+                  or has changed. Refresh vault and preview again.
                 </p>
-              ))}
+              )}
               <Receiver value={to} wallet={w} />
               <TxButton
                 snapshot={s}
@@ -696,17 +719,9 @@ export function RedeemPage({ snapshot: s, wallet: w }: Props) {
           </p>
         </section>
         <aside className="panel">
-          <div className="picture-stage redeem-picture">
-            <img className="character-picture" src="./art/character/redeem.webp" width="484" height="1000" alt="Store worker handing over a full grocery bag" />
-            <p className="speech-bubble">are you sure that’s all you came here for?</p>
-          </div>
           <h2>Take your basket home</h2>
           <details>
             <summary>Transaction details</summary>
-            <Note warning>
-              Unsent stocks are owed to the receiver. Only that wallet can claim
-              them. Choose a wallet you control that can call this vault.
-            </Note>
             <p>
               Minimum amounts are 0.1% below a fresh preview taken just before
               sending, with zero kept as zero. They follow assetTokens order.
diff --git a/web/src/Owner.tsx b/web/src/Owner.tsx
index 87adb07..195f676 100644
--- a/web/src/Owner.tsx
+++ b/web/src/Owner.tsx
@@ -8,7 +8,8 @@ import {
   explain,
   InputError,
   zeroAddress,
-  reasons,
+  reasonWords,
+  minutesOf,
   type Spec,
 } from "./chain";
 import {
@@ -44,13 +45,15 @@ import {
   proposalKinds,
   settingNames,
   settingFields,
-  settingBounds,
+  settingBoundsWords,
+  gasMaximum,
   settingWords,
   settingValues,
+  newOwner,
   type Pairing,
 } from "./governance";
-import { dstWords, hoursWordsOf } from "./newYork";
-import type { Wallet } from "./wallet";
+import { dstWords, hoursWordsOf, zoneWords } from "./newYork";
+import { TransactionCancelled, type Wallet } from "./wallet";
 type Props = { snapshot: Snapshot; wallet: Wallet };
 type Field = {
   key: string;
@@ -287,7 +290,11 @@ function PairingRows({ rows }: { rows: Pairing[] }) {
           {!same(r.pool, zeroAddress) && (
             <>
               <p>
-                Current 30-minute liquidity:{" "}
+                Current{" "}
+                {r.poolWindow === undefined
+                  ? "pool-window"
+                  : minutesOf(r.poolWindow)}{" "}
+                liquidity:{" "}
                 {r.liquidity === undefined ? "unreadable" : String(r.liquidity)}{" "}
                 ·{" "}
                 {r.liquidity === undefined
@@ -337,8 +344,14 @@ function LaunchListing({
     let live = true;
     if (w.account && same(w.account, s.globals.owner))
       w.listingPending()
-        .then(() => {
-          if (live) setPending("");
+        .then((finished) => {
+          if (!live) return;
+          setPending("");
+          // The saved transaction is mined or replaced: its timeout text is stale.
+          if (finished) {
+            setError("");
+            setResume(true);
+          }
         })
         .catch((e) => {
           if (live) setPending(explain(e));
@@ -474,7 +487,8 @@ function LaunchListing({
           lock.current = true;
           setWorking(true);
           setError("");
-          let rowName = "Listing";
+          let rowName = "Listing",
+            rowNumber = 0;
           try {
             await w.listingPending();
             const checkedRows = await checkRows();
@@ -484,6 +498,7 @@ function LaunchListing({
               );
             for (let i = 0; i < checkedRows.length; i++) {
               const r = checkedRows[i];
+              rowNumber = i + 1;
               rowName = `Row ${i + 1} of ${checkedRows.length}: ${r.symbol}`;
               setProgress(rowName);
               await w.listingPending();
@@ -503,11 +518,10 @@ function LaunchListing({
                 rowName,
               );
               const after = await inspectListing(r);
-              if (!after.listed || after.error)
-                throw new InputError(
-                  after.error ||
-                    "Listing confirmation unreadable. Re-check before continuing.",
-                );
+              // A receipt but no listing: the wallet cancelled or replaced it.
+              if (!after.listed)
+                throw new TransactionCancelled("Not listed after the receipt.");
+              if (after.error) throw new InputError(after.error);
               setRows((old) =>
                 old.map((x) => (same(x.token, r.token) ? after : x)),
               );
@@ -515,7 +529,12 @@ function LaunchListing({
             setProgress("All rows listed and matched against chain.");
             setResume(false);
           } catch (e) {
-            setError(`${rowName}: ${explain(e)}`);
+            if (e instanceof TransactionCancelled) {
+              // Never "Confirmed": say it in the listing status and the top bar too.
+              const text = `Row ${rowNumber}: the transaction was cancelled in the wallet; nothing was listed. Press Resume listing.`;
+              setError(text);
+              w.notice("listing", text);
+            } else setError(`${rowName}: ${explain(e)}`);
             setResume(true);
             try {
               await w.listingPending();
@@ -539,6 +558,7 @@ function LaunchListing({
             try {
               await w.waitPending();
               setPending("");
+              setError("");
               setResume(true);
             } catch (e) {
               setPending(explain(e));
@@ -563,10 +583,12 @@ function SettingForm(props: Props) {
   const currentWords = !current
     ? "unreadable — Retry vault"
     : key === 5
-      ? `${hoursWordsOf(current.hoursFrom, current.hoursTo)}; ${current.hoursFrom}-${current.hoursTo}`
+      ? `${hoursWordsOf(BigInt(current.hoursFrom), BigInt(current.hoursTo), BigInt(current.dst))}; ${current.hoursFrom}-${current.hoursTo}`
       : key === 6
         ? `${dstWords[Number(current.dst)] ?? "unknown"}; ${current.dst}`
-        : `${current[settingFields[key]]}; ${settingWords(key, BigInt(current[settingFields[key]]))}`;
+        : `${current[settingFields[key]]}; ${settingWords(key, BigInt(current[settingFields[key]]), 0n, current)}`;
+  const fixedZone =
+    current && BigInt(current.dst) !== 0n ? BigInt(current.dst) : undefined;
   return (
     <div className="panel setting-panel">
       <h3>Setting</h3>
@@ -588,13 +610,15 @@ function SettingForm(props: Props) {
         Current {settingFields[key]}:{" "}
         {props.snapshot.loading ? "Reading..." : currentWords}
       </p>
-      <p>Bounds: {settingBounds[key]}</p>
+      <p>Bounds: {settingBoundsWords(key, current)}</p>
       {key === 5 && (
         <p>
           Hours are seconds since Sunday 00:00 New York time. Enter From and To
           as a weekday and New York time, e.g. "Monday 9:30 am" and "Friday
           4:00 pm" (To may be "Saturday 24:00"), or "Always open" in both. The
           start is inclusive and the end exclusive.
+          {fixedZone !== undefined &&
+            ` With the current Dst ${fixedZone}, the vault reads these times as ${zoneWords(fixedZone)} all year, not New York time.`}
         </p>
       )}
       {key === 6 && (
@@ -607,7 +631,7 @@ function SettingForm(props: Props) {
         <p>
           Deposits need at least FreshCount listed stock prices updated within
           the last FreshHours hours, so they close when prices stop (US market
-          holidays) until one updates.
+          holidays) until one updates. FreshCount 0 turns this off.
         </p>
       )}
       <ActionForm
@@ -637,20 +661,29 @@ function SettingForm(props: Props) {
         }
         preview={(v) => {
           try {
-            const [, value, value2] = settingValues({
-              ...v,
-              setting: String(key),
-            });
+            const [, value, value2] = settingValues(
+              {
+                ...v,
+                setting: String(key),
+              },
+              current,
+            );
+            const max = gasMaximum(key, current);
             return key === 5
-              ? `Proposed value ${value}, value2 ${value2}; ${settingWords(key, value, value2)}`
-              : `Proposed raw value: ${value}; ${settingWords(key, value)}`;
+              ? `Proposed value ${value}, value2 ${value2}; ${settingWords(key, value, value2, current)}`
+              : `Proposed raw value: ${value}; ${settingWords(key, value, 0n, current)}` +
+                  (max !== undefined && value > max
+                    ? `. Over the current maximum ${max}: the vault would refuse it.`
+                    : "");
           } catch (e) {
             return e instanceof InputError
               ? e.message
               : "Enter a proposed value to see its plain units.";
           }
         }}
-        build={(v) => proposalSpec(10, { ...v, setting: String(key) })}
+        build={(v) =>
+          proposalSpec(10, { ...v, setting: String(key) }, current)
+        }
       />
     </div>
   );
@@ -740,10 +773,12 @@ function Proposals({ snapshot: s, wallet: w }: Props) {
                     "unlisted / symbol unreadable")}
               </p>
               {!same(token, zeroAddress) && <Addr value={token} />}
-              <p className="chain-text">{proposalWords(p.action)}</p>
+              <p className="chain-text">
+                {proposalWords(p.action, s.globals.settings)}
+              </p>
               <p>
                 {ready
-                  ? `ready until ${date(expiresAt)} (exclusive)`
+                  ? `ready until just before ${date(expiresAt, "end")}`
                   : `waiting, executable from ${date(readyAt)}`}
               </p>
               {paused && (
@@ -818,6 +853,26 @@ function Proposals({ snapshot: s, wallet: w }: Props) {
     </section>
   );
 }
+const listingStores = [() => sessionStorage, () => localStorage];
+const PASTE_FIRST =
+  "Paste the listing rows first so the page can check none is missing.";
+// A pasted row whose stock is listed with another feed, pool, quote feed or
+// minLiquidity (Check pairings names the field).
+function listedDiffers(
+  assets: Asset[],
+  r: ReturnType<typeof parseLaunch>[number],
+) {
+  const a = assets.find((x) => same(x.token, r.token));
+  return (
+    !!a &&
+    (!same(a.feed, r.feed) ||
+      !same(a.pool, r.pool) ||
+      !same(a.quoteFeed, r.quoteFeed) ||
+      a.minLiquidity !== r.minLiquidity)
+  );
+}
+const differWords = (tickers: string[]) =>
+  `Listed with other values than the pasted lines: ${tickers.join(", ")}. Check pairings shows which field; paste the lines that were listed.`;
 export function OwnerPage(props: Props) {
   const { snapshot: s, wallet: w } = props;
   const stock = (stocks = s.assets): Field => ({
@@ -838,28 +893,39 @@ export function OwnerPage(props: Props) {
   const feedField: Field = { key: "feed", label: "Stock USD feed address" };
   const failing = s.assets.filter((a) => a.reason !== 0);
   const finalized = s.globals.genesisFinalized;
+  // The pasted rows are kept in this tab (sessionStorage) and for new tabs
+  // (localStorage); this tab's own copy wins.
   const [listing, setListingState] = useState(() => {
-    try {
-      return sessionStorage.getItem("basket-listing") || "";
-    } catch {
-      return "";
-    }
+    for (const store of listingStores)
+      try {
+        const saved = store().getItem("basket-listing");
+        if (saved) return saved;
+      } catch {
+        /* storage optional */
+      }
+    return "";
   });
   const setListing = (value: string) => {
     setListingState(value);
-    try {
-      sessionStorage.setItem("basket-listing", value);
-    } catch {
-      /* storage optional */
-    }
+    for (const store of listingStores)
+      try {
+        store().setItem("basket-listing", value);
+      } catch {
+        /* storage optional */
+      }
   };
   let unlisted: string[] = [],
+    differing: string[] = [],
     listingError = "";
   if (listing.trim())
     try {
-      unlisted = parseLaunch(listing)
+      const pasted = parseLaunch(listing);
+      unlisted = pasted
         .filter((r) => !s.assets.some((a) => same(a.token, r.token)))
         .map((r) => r.ticker);
+      differing = pasted
+        .filter((r) => listedDiffers(s.assets, r))
+        .map((r) => r.ticker);
     } catch (e) {
       listingError = explain(e);
     }
@@ -929,17 +995,23 @@ export function OwnerPage(props: Props) {
                 title="Finalize genesis"
                 folded={false}
                 disabledReason={
-                  listingError ||
-                  (unlisted.length
-                    ? `Unlisted rows: ${unlisted.join(", ")}. List them first.`
-                    : "At least three readable stocks must pass every check. Correct failed stocks and retry vault.")
+                  !listing.trim()
+                    ? PASTE_FIRST
+                    : listingError ||
+                      (unlisted.length
+                        ? `Unlisted rows: ${unlisted.join(", ")}. List them first.`
+                        : differing.length
+                          ? differWords(differing)
+                          : "At least three readable stocks must pass every check. Correct failed stocks and retry vault.")
                 }
                 label="Finalize genesis"
                 description="At least three listed stocks must each have reason OK in allAssets()."
                 disabled={
                   finalized !== false ||
+                  !listing.trim() ||
                   !!listingError ||
                   !!unlisted.length ||
+                  !!differing.length ||
                   !s.aggregate ||
                   !s.complete ||
                   s.assets.length < 3 ||
@@ -947,18 +1019,24 @@ export function OwnerPage(props: Props) {
                 }
                 confirmation="I understand this is irreversible, deposits can start at once, and later stocks can only be added by a List proposal."
                 build={async () => {
+                  if (!listing.trim()) throw new InputError(PASTE_FIRST);
                   await w.listingPending();
                   const fresh = await loadSnapshot();
-                  const missing = listing.trim()
-                    ? parseLaunch(listing).filter(
-                        (r) =>
-                          !fresh.assets.some((a) => same(a.token, r.token)),
-                      )
-                    : [];
+                  const pasted = parseLaunch(listing);
+                  const missing = pasted.filter(
+                    (r) => !fresh.assets.some((a) => same(a.token, r.token)),
+                  );
                   if (missing.length)
                     throw new InputError(
                       `Unlisted rows: ${missing.map((r) => r.ticker).join(", ")}. List them first.`,
                     );
+                  const changed = pasted.filter((r) =>
+                    listedDiffers(fresh.assets, r),
+                  );
+                  if (changed.length)
+                    throw new InputError(
+                      differWords(changed.map((r) => r.ticker)),
+                    );
                   if (
                     !fresh.aggregate ||
                     !fresh.complete ||
@@ -971,7 +1049,7 @@ export function OwnerPage(props: Props) {
                           .filter((a) => a.reason !== 0)
                           .map(
                             (a) =>
-                              `${a.symbol}: ${a.reason === undefined ? "unreadable" : reasons[a.reason]}`,
+                              `${a.symbol}: ${reasonWords(a.reason, fresh.globals.settings)}`,
                           )
                           .join("; ") ||
                           "At least three readable stocks required."),
@@ -982,16 +1060,20 @@ export function OwnerPage(props: Props) {
               <p>
                 {s.loading
                   ? "Reading..."
-                  : `${s.assets.length} stocks listed: ${s.assets.map((a) => a.symbol).join(", ") || "None"}`}
+                  : !s.complete
+                    ? "Listed stocks unreadable · Retry vault"
+                    : `${s.assets.length} ${s.assets.length === 1 ? "stock" : "stocks"} listed: ${s.assets.map((a) => a.symbol).join(", ") || "None"}`}
               </p>
               {unlisted.length > 0 && (
                 <p className="error">Unlisted rows: {unlisted.join(", ")}</p>
               )}
+              {differing.length > 0 && (
+                <p className="error">{differWords(differing)}</p>
+              )}
               {listingError && <p className="error">{listingError}</p>}
               {failing.map((a) => (
                 <p className="error" key={a.token}>
-                  {a.symbol}:{" "}
-                  {a.reason === undefined ? "unreadable" : reasons[a.reason]}
+                  {a.symbol}: {reasonWords(a.reason, s.globals.settings)}
                 </p>
               ))}
             </div>
@@ -1079,7 +1161,7 @@ export function OwnerPage(props: Props) {
             description="The new owner must accept from their own wallet and must not be the guardian."
             fields={[{ key: "next", label: "New owner address" }]}
             build={async (v) => {
-              const next = address(v.next);
+              const next = newOwner(v.next);
               if (same(next, await read(vault("guardian"))))
                 throw new InputError("The new owner must not be the guardian.");
               return vault("transferOwnership", [next]);
diff --git a/web/src/Scenery.tsx b/web/src/Scenery.tsx
index 3873f5a..d1b5c7a 100644
--- a/web/src/Scenery.tsx
+++ b/web/src/Scenery.tsx
@@ -5,7 +5,7 @@ export function Marquee() {
         <div className="marquee-track">
           {[0, 1].map((half) => (
             <div className="marquee-half" key={half}>
-              {Array.from({ length: 4 }, (_, i) => (
+              {Array.from({ length: 8 }, (_, i) => (
                 <span key={i}>
                   Basket buddies! • Take a stroll down the aisles • Give your cart a twirl •{" "}
                 </span>
diff --git a/web/src/Vault.tsx b/web/src/Vault.tsx
index 4205491..9d82649 100644
--- a/web/src/Vault.tsx
+++ b/web/src/Vault.tsx
@@ -1,5 +1,13 @@
-import { useState } from "react";
-import { VAULT, zeroAddress, reasons } from "./chain";
+import {
+  useEffect,
+  useLayoutEffect,
+  useRef,
+  useState,
+  type CSSProperties,
+  type ReactNode,
+  type RefObject,
+} from "react";
+import { VAULT, zeroAddress, reasonWords } from "./chain";
 import {
   navOf,
   assetValue,
@@ -8,45 +16,116 @@ import {
   age,
   pairingMatches,
   hoursWords,
+  type Asset,
   type Snapshot,
 } from "./model";
 import { PageTitle, AddressLink, Note, Empty } from "./components";
 import { StoreShelf } from "./Scenery";
 import {
   countdown,
+  inside,
   nextOpening,
   nyDate,
   weekdayWords,
   zoneWords,
 } from "./newYork";
+export const mayBeOpen = "Deposits may be open now. Press Refresh vault.";
+// The reopen time in the viewer's own zone, in words (no seconds, no numeric date).
+export const localWords = (t: bigint) =>
+  new Date(Number(t) * 1000).toLocaleString(undefined, {
+    weekday: "short",
+    day: "numeric",
+    month: "short",
+    hour: "numeric",
+    minute: "2-digit",
+    timeZoneName: "short",
+  });
+// Next opening as the contract sees it at the read block, when reason 3 still
+// holds there; undefined when the read block is already inside the hours.
+export function reopenAt(
+  settings: any,
+  blockTime: bigint | undefined,
+): bigint | undefined {
+  if (!settings || blockTime === undefined) return undefined;
+  const from = BigInt(settings.hoursFrom),
+    to = BigInt(settings.hoursTo),
+    dst = BigInt(settings.dst);
+  if (inside(blockTime, from, to, dst)) return undefined;
+  return nextOpening(blockTime, from, dst);
+}
 // Reason 3 (Hours) and 14 (Freshness) in words; computed like the contract from
 // settings() and the latest block timestamp, never the browser time zone.
+// now = the read block time plus the seconds since that read.
 export function closedWords(
   reason: number,
   settings: any,
   blockTime: bigint | undefined,
+  now = blockTime,
 ): string | undefined {
   if (!settings) return undefined;
   if (reason === 14)
     return `Deposits are closed until stock prices update (at least ${settings.freshCount} must have updated in the last ${settings.freshHours} hour(s), e.g. a US market holiday); no set time. Redemptions are always open.`;
-  if (reason !== 3 || blockTime === undefined) return undefined;
+  if (reason !== 3 || blockTime === undefined || now === undefined)
+    return undefined;
+  // Status and block read on different blocks at the boundary.
+  const t = reopenAt(settings, blockTime);
+  if (t === undefined || now >= t) return mayBeOpen;
   const from = BigInt(settings.hoursFrom),
     dst = BigInt(settings.dst);
-  const t = nextOpening(blockTime, from, dst);
-  const local = new Date(Number(t) * 1000).toLocaleString("en-GB");
-  return `Deposits reopen ${weekdayWords(from)} ${zoneWords(dst)} (${nyDate(t, dst)}, in ${countdown(t - blockTime)}; your time ${local}). On a US market holiday they reopen when prices update. Redemptions are always open.`;
+  const holiday =
+    BigInt(settings.freshCount) > 0n
+      ? " On a US market holiday they reopen when prices update."
+      : "";
+  return `Deposits reopen ${weekdayWords(from)} ${zoneWords(dst)} (${nyDate(t, dst)}, in ${countdown(t - now)}; your time ${localWords(t)}).${holiday} Redemptions are always open.`;
 }
+// Vault and Deposit pages: words only (the Owner page adds the raw seconds).
 export function hoursLine(settings: any): string {
-  if (!settings) return "unreadable";
-  const dst = BigInt(settings.dst);
-  const zone = dst === 0n ? "" : ` (${zoneWords(dst)})`;
-  return `${hoursWords(settings)}${zone}; ${settings.hoursFrom}-${settings.hoursTo}`;
+  return hoursWords(settings);
+}
+// The vault clock now, re-rendered when the countdown's minute changes; once
+// the reopen time passes, the vault is read again (as Refresh vault does).
+function useVaultClock(s: Snapshot, closedForHours: boolean) {
+  const [, tick] = useState(0);
+  const refreshed = useRef<bigint | undefined>(undefined);
+  const now =
+    s.blockTime === undefined
+      ? undefined
+      : s.blockTime +
+        BigInt(
+          Math.max(
+            0,
+            Math.floor((Date.now() - (s.blockReadAt ?? s.loadedAt)) / 1000),
+          ),
+        );
+  const opening = closedForHours
+    ? reopenAt(s.globals.settings, s.blockTime)
+    : undefined;
+  useEffect(() => {
+    if (opening === undefined || now === undefined) return;
+    const left = opening - now;
+    if (left <= 0n) {
+      // One automatic re-read per reopen time; then the words ask for Refresh.
+      if (refreshed.current !== opening) {
+        refreshed.current = opening;
+        s.retry?.();
+      }
+      return;
+    }
+    // The minutes shown change once left drops below a whole minute.
+    const next = (left % 60n) + 1n;
+    const wait = left < next ? left : next;
+    const timer = setTimeout(() => tick((x) => x + 1), Number(wait) * 1000);
+    return () => clearTimeout(timer);
+  });
+  return now;
 }
 export function DepositState({ snapshot: s }: { snapshot: Snapshot }) {
   const r = s.status;
+  const reason = r?.ok && !s.loading ? Number(r.value[0]) : undefined;
+  const now = useVaultClock(s, reason === 3);
   const closed =
-    r?.ok && !s.loading
-      ? closedWords(Number(r.value[0]), s.globals.settings, s.blockTime)
+    reason !== undefined
+      ? closedWords(reason, s.globals.settings, s.blockTime, now)
       : undefined;
   return (
     <div className="deposit-state">
@@ -64,7 +143,7 @@ export function DepositState({ snapshot: s }: { snapshot: Snapshot }) {
               ? "Every stock is closed. The owner must reopen a stock before deposits."
               : !r || !r.ok
                 ? "unreadable — Retry vault"
-                : (reasons[Number(r.value[0])] ?? "unreadable")}
+                : reasonWords(Number(r.value[0]), s.globals.settings)}
       </p>
       {r?.ok && r.value[1] !== zeroAddress && (
         <p>
@@ -83,24 +162,23 @@ export function DepositState({ snapshot: s }: { snapshot: Snapshot }) {
   );
 }
 export function VaultPage({ snapshot: s }: { snapshot: Snapshot }) {
-  const [search, setSearch] = useState("");
   const nav = navOf(s.assets, s.complete),
     supply = s.globals.totalSupply as bigint | undefined;
   return (
     <>
-      <div className="vault-hero">
-        <PageTitle
-          eyebrow="Stock Tokens. One basket."
-          title="A basket of stocks."
-        >
-          Meet Basket (BASK): your share of the Stock Tokens in this vault.
-        </PageTitle>
-        <div className="clerk-panel">
-          <span className="burst">WOW!</span>
-          <img className="character-picture" src="./art/character/vault.webp" width="606" height="1000" alt="Cheerful store worker beside a produce crate" />
-          <p className="speech-bubble">I was hoping you would come through my aisle</p>
-        </div>
-      </div>
+      <PageTitle
+        title="A basket of stocks."
+        character={{
+          kind: "vault",
+          src: "./art/character/vault.webp",
+          width: 606,
+          height: 1000,
+          alt: "Cheerful store worker beside a produce crate",
+          line: "I was hoping you would come through my aisle",
+        }}
+      >
+        Meet Basket (BASK): your share of the Stock Tokens in this vault.
+      </PageTitle>
       <section className="panel">
         <div className="section-heading">
           <h2>Inside the basket</h2>
@@ -156,23 +234,639 @@ export function VaultPage({ snapshot: s }: { snapshot: Snapshot }) {
           </div>
         </div>
       </section>
-      <section className="panel stock-section">
-        <div className="section-heading">
-          <h2>Stock shelves</h2>
-          <span className="burst small">Fresh!</span>
+      <StockShelves snapshot={s} />
+    </>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Stock shelves: shelf-edge labels on a store shelf unit (display only; the
+// snapshot is read exactly as before, nothing here reads, checks or sends).
+// Two groups: "In the basket" (held, or held amount unreadable: full labels,
+// biggest share first) and "On the shelf, not held" (held 0: compact labels,
+// listing order; their held amount and share are in the details drawer).
+// ---------------------------------------------------------------------------
+type ShelfFilter = "all" | "open" | "closed" | "held";
+const shelfFilters: [ShelfFilter, string][] = [
+  ["all", "All"],
+  ["open", "Open"],
+  ["closed", "Closed"],
+  ["held", "Held"],
+];
+const isHeld = (a: Asset) => a.managed !== undefined && a.managed > 0n;
+function inShelfFilter(a: Asset, f: ShelfFilter) {
+  if (f === "open") return !a.retired && a.open;
+  if (f === "closed") return a.retired || !a.open;
+  if (f === "held") return isHeld(a);
+  return true;
+}
+// The price reason words come from reasonWords(reason, settings) (v9 F12: reason
+// 12 names the vault's poolWindow and poolDeviation), as on the rest of the site;
+// `settings` is the snapshot's settings() read, passed down from StockShelves.
+// Plain-words status. Closed = the owner or guardian closed it to deposits
+// (redemptions still pay it out). An OPEN stock whose price reason is not OK
+// cannot be deposited right now: "Open · not taking deposits", never "Closed".
+type ShelfKind = "open" | "paused" | "closed" | "retired" | "unknown";
+function shelfStatus(a: Asset, settings: any): { kind: ShelfKind; more?: string } {
+  if (a.retired) return { kind: "retired", more: "Retired: removed from the basket." };
+  if (!a.open)
+    return {
+      kind: "closed",
+      more: "Closed by the owner or guardian: no new deposits of this stock. Redemptions still pay it out.",
+    };
+  if (a.reason === 0) return { kind: "open" };
+  if (a.reason === undefined)
+    return { kind: "unknown", more: "Open, but its price reason is unreadable." };
+  return {
+    kind: "paused",
+    more: `Open, but deposits of this stock are blocked right now: ${reasonWords(a.reason, settings)}.`,
+  };
+}
+// The slim chip under the status: the price reason words when it is not OK.
+function reasonChip(a: Asset, kind: ShelfKind, settings: any) {
+  if (a.reason === 0) return undefined;
+  const words = reasonWords(a.reason, settings);
+  return kind === "paused" ? words : `price reason: ${words}`;
+}
+// Warnings printed on the label itself (white on red).
+function shelfFlags(a: Asset): string[] {
+  const flags: string[] = [];
+  if (!pairingMatches(a.symbol, a.description)) flags.push("check this pairing");
+  if (!a.balanceReadable) flags.push("Balance check: unreadable");
+  else if (a.short) flags.push("Balance check: vault short of this stock");
+  return flags;
+}
+// A label with a chip (a price reason or a warning), and a compact label that
+// is closed (room for the stamp), is double width: its extra words fit without
+// making its shelf row taller.
+const hasChip = (a: Asset) => a.reason !== 0 || shelfFlags(a).length > 0;
+const isWide = (a: Asset, mini: boolean) => hasChip(a) || (mini && !a.retired && !a.open);
+const feedPrice18 = (a: Asset) =>
+  a.answer === undefined
+    ? undefined
+    : (a.answer * 10n ** 18n) / 10n ** BigInt(a.feedDecimals);
+const priceReadable = (a: Asset) => a.answer !== undefined && a.answer > 0n;
+// reason 9 only (feed price missing or too old): its last price is shown dimmed
+// with an "old price" tag. Reasons 10 (band) and 11 (issuer pause) come after the
+// feed's age check, so their price is fresh: shown normally, the chip says why.
+const staleFeed = (a: Asset) => a.reason === 9;
+// Money on the labels is the site's usd(): cut to the cent, the same rule as the
+// NAV figure above (one rule site-wide). The flyer price only prints usd()'s
+// cents in two digits ("$669.5" shows as $669 and 50 cents).
+// age() as today, but on the labels under 1 minute reads "just now" (the long
+// words wrapped and made the row taller; the drawer keeps age()'s full words)
+// and 48 hours or more reads in days ("4 days ago")
+function shelfAge(a: Asset): string {
+  const t = age(a.updatedAt);
+  if (!t.endsWith(" ago") || a.updatedAt === undefined) return t;
+  const s = Math.floor(Date.now() / 1000 - Number(a.updatedAt));
+  return s < 60 ? "just now" : s >= 2 * 86400 ? `${Math.floor(s / 86400)} days ago` : t;
+}
+function ShelfPrice({ a, stale }: { a: Asset; stale: boolean }) {
+  if (!priceReadable(a)) return <p className="sa-price is-unreadable">price unreadable</p>;
+  const t = usd(feedPrice18(a)),
+    m = /^\$([\d,]+)(?:\.(\d{1,2}))?$/.exec(t);
+  // flyer price: big dollars, small raised cents (the dot stays for screen readers and copying)
+  return (
+    <p className={stale ? "sa-price is-stale" : "sa-price"}>
+      {m ? (
+        <>
+          <span className="sa-cur">$</span>
+          {m[1]}
+          <span className="sa-cents">
+            <span className="sa-sr">.</span>
+            {(m[2] ?? "").padEnd(2, "0")}
+          </span>
+        </>
+      ) : (
+        t
+      )}
+    </p>
+  );
+}
+function PriceAge({ a, stale }: { a: Asset; stale: boolean }) {
+  const t = shelfAge(a);
+  return (
+    <p className={stale ? "sa-age is-stale" : "sa-age"}>
+      {stale && <span className="sa-old">old price</span>}
+      {stale && " "}
+      {t.endsWith(" ago") || t === "just now" ? (
+        <>
+          {/* narrower labels show a small clock (or nothing) instead of the words; still read out */}
+          <span className="sa-upd">price updated </span>
+          <span className="sa-when">
+            <span className="sa-clock" aria-hidden="true" />
+            {t.charAt(0).toLowerCase() + t.slice(1)}
+          </span>
+        </>
+      ) : (
+        `price time: ${t}`
+      )}
+    </p>
+  );
+}
+function shareText(value: bigint | undefined, nav: bigint | undefined) {
+  return nav === undefined || value === undefined
+    ? "unreadable"
+    : nav === 0n
+      ? "—"
+      : fmt((value * 10000n) / nav, 2, 2) + "%";
+}
+// Today's pool check branching, unchanged.
+function poolCheck(a: Asset): string {
+  const feedPrice = feedPrice18(a);
+  const gap =
+    a.poolPrice && feedPrice
+      ? Number(((a.poolPrice - feedPrice) * 10000n) / feedPrice) / 100
+      : undefined;
+  return [9, 10, 11].includes(a.reason ?? -1)
+    ? "not run"
+    : a.poolPrice === undefined
+      ? "unreadable"
+      : a.pool === zeroAddress
+        ? "No pool; feed-age check"
+        : a.poolPrice === 0n
+          ? "Failed · poolPrice 0"
+          : `${usd(a.poolPrice)} · ${gap === undefined ? "gap unreadable" : `${gap > 0 ? "+" : ""}${gap}% vs feed`}`;
+}
+// One-time "restocking": the first time a shelf row is about a third in view,
+// its labels swing once on their clips, left to right (rows that come into view
+// together follow one another). Each label starts and ends at rest, so nothing
+// is ever hidden or blinks; every label is fully visible if this never runs.
+// Off under reduced motion; stops for good once the visitor filters or searches.
+const swingFrames: Keyframe[] = [
+  { transform: "none" },
+  { transform: "translateY(-12px) rotate(-6deg)", offset: 0.2 },
+  { transform: "translateY(2px) rotate(3.5deg)", offset: 0.46 },
+  { transform: "translateY(0) rotate(-1.8deg)", offset: 0.68 },
+  { transform: "translateY(0) rotate(0.7deg)", offset: 0.86 },
+  { transform: "none" },
+];
+function useRestock(ref: RefObject<HTMLDivElement | null>, ready: boolean) {
+  const stopped = useRef(false),
+    io = useRef<IntersectionObserver | undefined>(undefined);
+  useEffect(() => {
+    const box = ref.current;
+    if (
+      !ready ||
+      stopped.current ||
+      !box ||
+      typeof IntersectionObserver === "undefined" ||
+      typeof box.animate !== "function" ||
+      matchMedia("(prefers-reduced-motion: reduce)").matches
+    )
+      return;
+    const swing = (hit: HTMLElement[]) => {
+      const rows = [...new Set(hit.map((li) => Number(li.dataset.row)))].sort((x, y) => x - y);
+      for (const li of hit) {
+        obs.unobserve(li);
+        (li.firstElementChild as HTMLElement | null)?.animate(swingFrames, {
+          duration: 640,
+          easing: "ease-out",
+          delay: Math.min(rows.indexOf(Number(li.dataset.row)), 3) * 120 + Number(li.dataset.col) * 45,
+        });
+      }
+    };
+    const obs = new IntersectionObserver(
+      (entries) => {
+        const hit = entries.filter((e) => e.isIntersecting).map((e) => e.target as HTMLElement);
+        if (hit.length && !stopped.current) swing(hit);
+      },
+      { threshold: 0.35 },
+    );
+    io.current = obs;
+    for (const li of box.querySelectorAll<HTMLElement>(".sa-slot[data-row]")) obs.observe(li);
+    return () => obs.disconnect();
+  }, [ready, ref]);
+  return () => {
+    stopped.current = true;
+    io.current?.disconnect();
+  };
+}
+// How many labels fit in a row: the CSS grid decides (auto-fill), this reads it
+// so the details drawer can open right under the tapped label's row. The count
+// follows the list's own width (a ResizeObserver on it), so it also updates when
+// the panel changes width without a window resize.
+function useGridCols(ref: RefObject<HTMLUListElement | null>) {
+  const [cols, setCols] = useState(1);
+  useLayoutEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const measure = () =>
+      setCols(Math.max(1, getComputedStyle(el).gridTemplateColumns.split(" ").length));
+    measure();
+    // (a browser without ResizeObserver keeps the first count)
+    if (typeof ResizeObserver === "undefined") return;
+    const ro = new ResizeObserver(measure);
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, [ref]);
+  return cols;
+}
+function ShelfLabel({
+  a,
+  nav,
+  settings,
+  mini,
+  row,
+  col,
+  span,
+  open,
+  onToggle,
+}: {
+  a: Asset;
+  nav: bigint | undefined;
+  settings: any;
+  mini: boolean;
+  row: number;
+  col: number;
+  span: number;
+  open: boolean;
+  onToggle: () => void;
+}) {
+  const value = assetValue(a),
+    st = shelfStatus(a, settings),
+    stale = staleFeed(a),
+    chip = reasonChip(a, st.kind, settings),
+    flags = shelfFlags(a),
+    pct = nav && value ? Number((value * 10000n) / nav) / 100 : 0;
+  const more = (
+    <button
+      type="button"
+      className="sa-more"
+      id={`sa-more-${a.token}`}
+      aria-expanded={open}
+      aria-controls={open ? "sa-drawer" : undefined}
+      onClick={onToggle}
+    >
+      <span className={mini ? "sa-sr" : undefined}>Details</span>
+      <span className="sa-sr"> for {a.symbol}</span>
+      <span className="sa-chev" aria-hidden="true" />
+    </button>
+  );
+  // the rubber stamp repeats the plain "Closed" words, so screen readers skip it
+  const stamp = st.kind === "closed" && (
+    <span className="sa-stamp" aria-hidden="true">
+      Closed
+    </span>
+  );
+  return (
+    <li
+      className="sa-slot"
+      data-row={row}
+      data-col={col}
+      style={span > 1 ? { gridColumn: `span ${span}` } : undefined}
+    >
+      <article
+        className={`sa-label sa-label--${st.kind} sa-label--${mini ? "mini" : "full"}${chip || flags.length ? " sa-label--chip" : ""}${open ? " is-open" : ""}`}
+        aria-labelledby={`sa-t-${a.token}`}
+      >
+        <span className="sa-clip" aria-hidden="true" />
+        {/* sa-main / sa-figs only group the lines for the two-column wide label */}
+        <div className="sa-main">
+          <div className="sa-top">
+            <h4 id={`sa-t-${a.token}`}>
+              <bdi>{a.symbol}</bdi>
+            </h4>
+            {stamp}
+            <ShelfPrice a={a} stale={stale} />
+            <PriceAge a={a} stale={stale} />
+          </div>
+          <p className="sa-st">
+            <span className="sa-stw">
+              <span className="sa-mark" aria-hidden="true" />
+              {st.kind === "retired" ? (
+                <b>Retired</b>
+              ) : st.kind === "closed" ? (
+                <b>
+                  Closed<span className="sa-wide"> to deposits</span>
+                </b>
+              ) : (
+                <b>Open</b>
+              )}
+              {st.kind === "paused" && (
+                <>
+                  {" · "}
+                  <b className="sa-warn">not taking deposits</b>
+                </>
+              )}
+            </span>
+            {mini && more}
+          </p>
+          {chip && <p className="sa-chip">{chip}</p>}
+          {flags.map((f) => (
+            <p className="sa-flag" key={f}>
+              {f}
+            </p>
+          ))}
         </div>
-        <StoreShelf />
-        {!!s.assets.length && (
-          <label className="stock-search">
-            Search stocks
-            <input
-              type="search"
-              value={search}
-              onChange={(e) => setSearch(e.target.value)}
-            />
-          </label>
+        {!mini && (
+          <>
+            <div className="sa-figs">
+              <div className="sa-share">
+                <b className={value === 0n ? "sa-pct is-zero" : "sa-pct"}>{shareText(value, nav)}</b>
+                <span className="sa-meter">
+                  <span className="sa-of">
+                    <span className="sa-wide">of basket</span>
+                    <span className="sa-narrow">share</span>
+                  </span>
+                  <span className="sa-bar" aria-hidden="true">
+                    <i style={{ width: value ? `max(3px, ${Math.min(pct, 100)}%)` : 0 }} />
+                  </span>
+                </span>
+              </div>
+              <p className="sa-kv sa-kv--value">
+                <span>Value</span> <b>{usd(value)}</b>
+              </p>
+              <p className="sa-kv">
+                <span>Held</span>{" "}
+                <b>
+                  {fmt(a.managed, a.tokenDecimals)}
+                  <span className="sa-wide">
+                    {" "}
+                    <bdi>{a.symbol}</bdi>
+                  </span>
+                </b>
+              </p>
+            </div>
+            <div className="sa-foot">
+              {more}
+              <span className="sa-barcode" aria-hidden="true" />
+            </div>
+          </>
         )}
-        {!s.assets.length ? (
+      </article>
+    </li>
+  );
+}
+function ShelfDrawer({
+  a,
+  nav,
+  settings,
+  at,
+  cols,
+  onClose,
+}: {
+  a: Asset;
+  nav: bigint | undefined;
+  settings: any;
+  at: number;
+  cols: number;
+  onClose: () => void;
+}) {
+  const st = shelfStatus(a, settings),
+    head = useRef<HTMLHeadingElement>(null);
+  useEffect(() => {
+    head.current?.focus({ preventScroll: true });
+    head.current?.scrollIntoView({ block: "nearest" });
+  }, [a.token]);
+  return (
+    <li
+      className="sa-drawer"
+      id="sa-drawer"
+      style={{ "--sa-at": at, "--sa-cols": cols } as CSSProperties}
+      onKeyDown={(e) => e.key === "Escape" && onClose()}
+    >
+      <div className="sa-drawer-top">
+        <h5 ref={head} tabIndex={-1}>
+          <bdi>{a.symbol}</bdi> details
+        </h5>
+        <button type="button" onClick={onClose}>
+          Close
+        </button>
+      </div>
+      {st.more && <p className="sa-drawer-status">{st.more}</p>}
+      <dl>
+        <div>
+          <dt>Feed</dt>
+          <dd className="chain-text">
+            <bdi>{a.description}</bdi>
+          </dd>
+        </div>
+        <div>
+          <dt>Feed price / age</dt>
+          <dd>
+            {a.answer === undefined || a.answer <= 0n
+              ? "unreadable / invalid feed"
+              : "$" + fmt(a.answer, a.feedDecimals)}{" "}
+            <small>{age(a.updatedAt)}</small>
+          </dd>
+        </div>
+        <div>
+          <dt>Pool check</dt>
+          <dd>{poolCheck(a)}</dd>
+        </div>
+        <div>
+          <dt>Held (managed)</dt>
+          <dd>{fmt(a.managed, a.tokenDecimals)}</dd>
+        </div>
+        <div>
+          <dt>Share of basket</dt>
+          <dd>{shareText(assetValue(a), nav)}</dd>
+        </div>
+        <div>
+          <dt>Owed</dt>
+          <dd>{fmt(a.totalOwed, a.tokenDecimals)}</dd>
+        </div>
+      </dl>
+      <dl className="sa-addrs">
+        <div>
+          <dt>Stock Token</dt>
+          <dd>
+            <AddressLink value={a.token} />
+          </dd>
+        </div>
+        <div>
+          <dt>Price feed</dt>
+          <dd>
+            <AddressLink value={a.feed} />
+          </dd>
+        </div>
+      </dl>
+    </li>
+  );
+}
+// One group of shelves. Labels fill rows left to right; a double-width label
+// that does not fit at the end of a row starts the next one. Empty slots keep
+// the red shelf edge running, and the open drawer goes under its label's row.
+function ShelfGroup({
+  items,
+  mini,
+  nav,
+  settings,
+  rowBase,
+  openToken,
+  onToggle,
+  onClose,
+}: {
+  items: Asset[];
+  mini: boolean;
+  nav: bigint | undefined;
+  settings: any;
+  rowBase: number;
+  openToken: string | undefined;
+  onToggle: (token: string) => void;
+  onClose: (token: string) => void;
+}) {
+  const ref = useRef<HTMLUListElement>(null);
+  const cols = useGridCols(ref);
+  const cells: ReactNode[] = [];
+  let row = 0,
+    col = 0,
+    open: { a: Asset; row: number; at: number } | undefined;
+  const endRow = () => {
+    for (; col < cols; col++)
+      cells.push(<li key={`e${row}-${col}`} className="sa-slot sa-slot--empty" aria-hidden="true" />);
+    const o = open;
+    if (o && o.row === row)
+      cells.push(
+        <ShelfDrawer
+          key="drawer"
+          a={o.a}
+          nav={nav}
+          settings={settings}
+          at={o.at}
+          cols={cols}
+          onClose={() => onClose(o.a.token)}
+        />,
+      );
+    row++;
+    col = 0;
+  };
+  for (const a of items) {
+    // double width; a compact one takes a whole row when a row holds 3 or fewer (phones)
+    const span = !isWide(a, mini) ? 1 : mini && cols <= 3 ? cols : Math.min(2, cols);
+    if (col + span > cols) endRow();
+    cells.push(
+      <ShelfLabel
+        key={a.token}
+        a={a}
+        nav={nav}
+        settings={settings}
+        mini={mini}
+        row={rowBase + row}
+        col={col}
+        span={span}
+        open={openToken === a.token}
+        onToggle={() => onToggle(a.token)}
+      />,
+    );
+    if (openToken === a.token) open = { a, row, at: col + (span - 1) / 2 };
+    col += span;
+    if (col === cols) endRow();
+  }
+  if (col > 0) endRow();
+  return (
+    <ul ref={ref} role="list" className={`sa-shelves sa-shelves--${mini ? "mini" : "full"}`}>
+      {cells}
+    </ul>
+  );
+}
+function ShelfSign({ name, count, children }: { name: string; count: number; children: ReactNode }) {
+  return (
+    <div className="sa-signrow">
+      <h3 className="sa-sign">
+        {name} <span className="sa-n">{count}</span>
+      </h3>
+      <p className="sa-sub">{children}</p>
+    </div>
+  );
+}
+function StockShelves({ snapshot: s }: { snapshot: Snapshot }) {
+  const [search, setSearch] = useState("");
+  const [filter, setFilter] = useState<ShelfFilter>("all");
+  const [openToken, setOpenToken] = useState<string>();
+  const unit = useRef<HTMLDivElement>(null);
+  const ready = s.assets.length > 0;
+  const stopRestock = useRestock(unit, ready);
+  const nav = navOf(s.assets, s.complete).nav;
+  const q = search.trim().toLowerCase();
+  const visible = s.assets.filter(
+    (a) =>
+      inShelfFilter(a, filter) &&
+      (a.symbol.toLowerCase().includes(q) || a.token.toLowerCase().includes(q)),
+  );
+  // In the basket (held, or held amount unreadable): biggest share first
+  // (unreadable values last, ties in listing order). On the shelf, not held
+  // (held amount 0): listing order.
+  const held = visible
+    .filter((a) => a.managed !== 0n)
+    .sort((x, y) => {
+      const vx = assetValue(x) ?? -1n,
+        vy = assetValue(y) ?? -1n;
+      return vy > vx ? 1 : vy < vx ? -1 : x.index - y.index;
+    });
+  const rest = visible.filter((a) => a.managed === 0n).sort((x, y) => x.index - y.index);
+  const emptyBasket = s.assets.every((a) => a.managed === 0n);
+  // a new filter or search closes the drawer (it never comes back unasked)
+  const show = (f: ShelfFilter, text: string) => {
+    stopRestock();
+    setOpenToken(undefined);
+    setFilter(f);
+    setSearch(text);
+  };
+  // a filter or a search (extra spaces ignored) is on: offer the way back to every
+  // stock (when nothing matches, the "No stocks match" line has its own Show all)
+  const narrowed = (filter !== "all" || q !== "") && visible.length > 0;
+  const toggle = (token: string) => setOpenToken(openToken === token ? undefined : token);
+  const close = (token: string) => {
+    setOpenToken(undefined);
+    requestAnimationFrame(() => document.getElementById(`sa-more-${token}`)?.focus());
+  };
+  const group = { nav, settings: s.globals.settings, openToken, onToggle: toggle, onClose: close };
+  return (
+    <section className="panel stock-section sa-section">
+      <div className="section-heading">
+        <h2>Stock shelves</h2>
+        <span className="burst small">Fresh!</span>
+      </div>
+      {ready && (
+        <>
+          <div className="sa-toolbar">
+            <div className="sa-filters" role="group" aria-label="Show stocks">
+              {shelfFilters.map(([f, name]) => (
+                <button
+                  key={f}
+                  type="button"
+                  aria-pressed={filter === f}
+                  onClick={() => show(f, search)}
+                >
+                  {name}{" "}
+                  <span className="sa-count">
+                    {s.assets.filter((a) => inShelfFilter(a, f)).length}
+                  </span>
+                </button>
+              ))}
+            </div>
+            <label className="sa-search">
+              Search stocks
+              <input
+                type="search"
+                value={search}
+                placeholder="Ticker or address"
+                onChange={(e) => show(filter, e.target.value)}
+              />
+            </label>
+          </div>
+          <p className="sa-note">
+            <span role="status">
+              Showing {visible.length} of {s.assets.length}
+            </span>
+            {narrowed && (
+              <>
+                {" · "}
+                <button type="button" className="sa-reset" onClick={() => show("all", "")}>
+                  Show all
+                </button>
+              </>
+            )}
+            {" · tap a label for its details"}
+          </p>
+        </>
+      )}
+      <div className="sa-unit" ref={unit}>
+        <StoreShelf />
+        {!ready ? (
           <Empty
             title={
               s.loading
@@ -188,120 +882,44 @@ export function VaultPage({ snapshot: s }: { snapshot: Snapshot }) {
                 ? "Deposits start after the owner finishes setup."
                 : "Retry the vault for current data."}
           </Empty>
+        ) : !visible.length ? (
+          <p className="sa-none">
+            No stocks match{q ? ` "${search.trim()}"` : ""} here.{" "}
+            <button type="button" onClick={() => show("all", "")}>
+              Show all
+            </button>
+          </p>
         ) : (
-          <div className="stock-grid">
-            {s.assets
-              .filter(
-                (a) =>
-                  a.symbol.toLowerCase().includes(search.toLowerCase()) ||
-                  a.token.toLowerCase().includes(search.toLowerCase()),
+          <>
+            {emptyBasket ? (
+              <ShelfSign name="In the basket" count={0}>
+                <b className="sa-emptyline">
+                  Nothing is in the basket yet.
+                  {s.globals.genesisFinalized === false &&
+                    " Deposits start after the owner finishes setup."}
+                </b>
+              </ShelfSign>
+            ) : (
+              held.length > 0 && (
+                <>
+                  <ShelfSign name="In the basket" count={held.length}>
+                    biggest share first
+                  </ShelfSign>
+                  <ShelfGroup items={held} mini={false} rowBase={0} {...group} />
+                </>
               )
-              .map((a) => {
-                const value = assetValue(a),
-                  feedPrice =
-                    a.answer === undefined
-                      ? undefined
-                      : (a.answer * 10n ** 18n) / 10n ** BigInt(a.feedDecimals);
-                const gap =
-                  a.poolPrice && feedPrice
-                    ? Number(((a.poolPrice - feedPrice) * 10000n) / feedPrice) /
-                      100
-                    : undefined;
-                return (
-                  <article className="stock-card" key={a.token}>
-                    <div className="stock-top">
-                      <h3>
-                        <bdi>{a.symbol}</bdi>
-                      </h3>
-                      <span className="badge">
-                        {a.retired ? "Retired" : a.open ? "Open" : "Closed"}
-                      </span>
-                    </div>
-                    {!pairingMatches(a.symbol, a.description) && (
-                      <p className="pairing-warning">check this pairing</p>
-                    )}
-                    <dl>
-                      <div>
-                        <dt>Held (managed)</dt>
-                        <dd>{fmt(a.managed, a.tokenDecimals)}</dd>
-                      </div>
-                      <div>
-                        <dt>Share of NAV</dt>
-                        <dd>
-                          {nav.nav === undefined || value === undefined
-                            ? "unreadable"
-                            : nav.nav === 0n
-                              ? "—"
-                              : fmt((value * 10000n) / nav.nav, 2, 2) + "%"}
-                        </dd>
-                      </div>
-                      {a.reason !== 0 && (
-                        <div>
-                          <dt>Price reason</dt>
-                          <dd>
-                            {a.reason === undefined
-                              ? "unreadable"
-                              : reasons[a.reason]}
-                          </dd>
-                        </div>
-                      )}
-                      {(!a.balanceReadable || a.short) && (
-                        <div>
-                          <dt>Balance check</dt>
-                          <dd>
-                            {!a.balanceReadable
-                              ? "unreadable"
-                              : a.short
-                                ? "vault short of this stock"
-                                : "Readable; no shortfall"}
-                          </dd>
-                        </div>
-                      )}
-                    </dl>
-                    <details>
-                      <summary>Details</summary>{" "}
-                      <p className="chain-text">
-                        <bdi>{a.description}</bdi>
-                      </p>
-                      <dl>
-                        {" "}
-                        <div>
-                          <dt>Feed price / age</dt>
-                          <dd>
-                            {a.answer === undefined || a.answer <= 0n
-                              ? "unreadable / invalid feed"
-                              : "$" + fmt(a.answer, a.feedDecimals)}
-                            <small>{age(a.updatedAt)}</small>
-                          </dd>
-                        </div>
-                        <div>
-                          <dt>Pool check</dt>
-                          <dd>
-                            {[9, 10, 11].includes(a.reason ?? -1)
-                              ? "not run"
-                              : a.poolPrice === undefined
-                                ? "unreadable"
-                                : a.pool === zeroAddress
-                                  ? "No pool; feed-age check"
-                                  : a.poolPrice === 0n
-                                    ? "Failed · poolPrice 0"
-                                    : `${usd(a.poolPrice)} · ${gap === undefined ? "gap unreadable" : `${gap > 0 ? "+" : ""}${gap}% vs feed`}`}
-                          </dd>
-                        </div>
-                        <div>
-                          <dt>Owed</dt>
-                          <dd>{fmt(a.totalOwed, a.tokenDecimals)}</dd>
-                        </div>
-                      </dl>
-                      <AddressLink value={a.token} />
-                      <AddressLink value={a.feed} />
-                    </details>
-                  </article>
-                );
-              })}
-          </div>
+            )}
+            {rest.length > 0 && (
+              <>
+                <ShelfSign name="On the shelf, not held" count={rest.length}>
+                  listing order
+                </ShelfSign>
+                <ShelfGroup items={rest} mini rowBase={100} {...group} />
+              </>
+            )}
+          </>
         )}
-      </section>
-    </>
+      </div>
+    </section>
   );
 }
diff --git a/web/src/chain.ts b/web/src/chain.ts
index 214bcfc..24be1d1 100644
--- a/web/src/chain.ts
+++ b/web/src/chain.ts
@@ -190,10 +190,41 @@ export const reasons = [
   "feed price missing or too old",
   "price outside its band",
   "paused by its issuer",
-  "pool check failed (over 3% off, unreadable, under its floor or quote feed bad)",
+  "pool check failed (pool price too far off the feed, unreadable, under its floor or quote feed bad)",
   "no pool and feed older than noPoolAge",
   "too few fresh prices",
 ];
+// Symbols and settings from the latest vault read. Used only to word errors and
+// reasons; never an input to a transaction.
+const labels: { symbols: Record<string, string>; settings?: any } = {
+  symbols: {},
+};
+export function rememberLabels(
+  assets: { token: Address; symbol: string }[],
+  settings: any,
+) {
+  labels.symbols = Object.fromEntries(
+    assets.map((a) => [a.token.toLowerCase(), a.symbol]),
+  );
+  labels.settings = settings;
+}
+export function knownSymbol(a: Address): string {
+  const s = labels.symbols[String(a).toLowerCase()];
+  return s && s !== "unreadable" ? s : a;
+}
+// poolDeviation is in basis points, poolWindow in seconds.
+export const percentOf = (bps: bigint) => `${Number(bps) / 100}%`;
+export const minutesOf = (seconds: bigint) => `${Number(seconds) / 60}-minute`;
+// Reason words; reason 12 states the vault's own pool window and deviation.
+export function reasonWords(
+  reason: number | undefined,
+  settings: any = labels.settings,
+): string {
+  if (reason === undefined) return "unreadable";
+  if (reason === 12 && settings)
+    return `pool check failed (${minutesOf(BigInt(settings.poolWindow))} pool price over ${percentOf(BigInt(settings.poolDeviation))} off the feed, unreadable, under its floor or quote feed bad)`;
+  return reasons[reason] ?? `Unknown reason ${reason}`;
+}
 // Ordinals match the pinned BaskVault.Kind exactly.
 export const proposalKinds = [
   "List",
@@ -235,9 +266,22 @@ export const errorWords: Record<string, string> = {
   ZeroNAV: "The vault has shares but zero NAV. Deposits cannot proceed.",
   InsufficientBalance: "Your balance is too low for this amount.",
   InsufficientAllowance: "The BASK allowance is too low for this transfer.",
+  MathOverflow: "This amount is outside the supported range.",
+  InvalidTick: "The pool price is outside its supported range.",
 };
-export async function explainAction(e: unknown, _spec: Spec): Promise<string> {
-  return explain(e);
+// Errors that carry the stock at fault; their words start with its symbol.
+const stockErrors = ["PaymentFailed", "BalanceUnreadable"];
+export async function explainAction(e: unknown, spec: Spec): Promise<string> {
+  const message = explain(e);
+  const parsed = revertError(e);
+  const batch =
+    spec.functionName === "claim"
+      ? ((spec.args?.[0] as Address[] | undefined) ?? [])
+      : [];
+  // One failing stock reverts a whole Claim all batch; say which one blocked it.
+  if (parsed && stockErrors.includes(parsed.errorName) && batch.length > 1)
+    return `${message} ${knownSymbol((parsed.args as [Address])[0])} blocked this batch, so nothing in it was claimed. The other stocks can be claimed with their own Claim buttons.`;
+  return message;
 }
 function revertData(e: any): Hex | undefined {
   if (!e || typeof e !== "object") return undefined;
@@ -245,24 +289,33 @@ function revertData(e: any): Hex | undefined {
     return e.data;
   return revertData(e.cause) ?? revertData(e.error) ?? revertData(e.data);
 }
+function revertError(e: unknown) {
+  const data = revertData(e);
+  if (!data) return undefined;
+  try {
+    return decodeErrorResult({ abi: vaultAbi, data });
+  } catch {
+    return undefined;
+  }
+}
 export function explain(
   e: unknown,
-  symbol: (a: Address) => string = (a) => a,
+  symbol: (a: Address) => string = knownSymbol,
   readFailure = false,
 ): string {
   if (e instanceof InputError) return e.message;
-  const data = revertData(e);
-  if (data)
-    try {
-      const parsed = decodeErrorResult({ abi: vaultAbi, data });
-      if (parsed.errorName === "DepositUnavailable") {
-        const [reason, asset] = parsed.args as [number, Address];
-        return `${reasons[reason] ?? `Unknown reason ${reason}`}. Stock at fault: ${asset === zeroAddress ? "none" : symbol(asset)}.`;
-      }
-      return errorWords[parsed.errorName] ?? parsed.errorName;
-    } catch {
-      /* Keep the rest of the page usable even for unknown revert data. */
+  const parsed = revertError(e);
+  // Keep the rest of the page usable even for unknown revert data.
+  if (parsed) {
+    if (parsed.errorName === "DepositUnavailable") {
+      const [reason, asset] = parsed.args as [number, Address];
+      return `${reasonWords(Number(reason))}. Stock at fault: ${asset === zeroAddress ? "none" : symbol(asset)}.`;
     }
+    const words = errorWords[parsed.errorName] ?? parsed.errorName;
+    return stockErrors.includes(parsed.errorName)
+      ? `${symbol((parsed.args as [Address])[0])}: ${words}`
+      : words;
+  }
   if (readFailure) return "Preview: unreadable. Retry the preview.";
   const err = e as { shortMessage?: string; message?: string; code?: number };
   if (
diff --git a/web/src/components.tsx b/web/src/components.tsx
index 4e0d375..c0dbcb7 100644
--- a/web/src/components.tsx
+++ b/web/src/components.tsx
@@ -75,16 +75,43 @@ export function PageTitle({
   eyebrow,
   title,
   children,
+  character,
 }: {
-  eyebrow: string;
+  eyebrow?: string;
   title: string;
   children: ReactNode;
+  character?: {
+    kind: "vault" | "deposit" | "redeem";
+    src: string;
+    width: number;
+    height: number;
+    alt: string;
+    line: string;
+  };
 }) {
   return (
-    <div className="page-title">
-      <p className="eyebrow">{eyebrow}</p>
+    <div
+      className={
+        character
+          ? `page-title has-character character-${character.kind}`
+          : "page-title"
+      }
+    >
+      {eyebrow && <p className="eyebrow">{eyebrow}</p>}
       <h1 tabIndex={-1}>{title}</h1>
       <p>{children}</p>
+      {character && (
+        <div className="title-character">
+          <img
+            className="character-picture"
+            src={character.src}
+            width={character.width}
+            height={character.height}
+            alt={character.alt}
+          />
+          <p className="speech-bubble">{character.line}</p>
+        </div>
+      )}
     </div>
   );
 }
@@ -225,7 +252,7 @@ export function Receiver({
         <p>
           {claim
             ? "Existing claims belong to your connected wallet. Any stocks still owed stay with that wallet."
-            : "A different receiver must connect to claim any stocks still owed to it."}
+            : "A different receiver must connect here to claim any stocks still owed to it."}
         </p>
       )}
     </div>
diff --git a/web/src/governance.ts b/web/src/governance.ts
index 1821f1e..fd8a4ec 100644
--- a/web/src/governance.ts
+++ b/web/src/governance.ts
@@ -9,10 +9,11 @@ import {
   zeroAddress,
   InputError,
   proposalKinds,
+  minutesOf,
+  VAULT,
 } from "./chain";
 import {
   address,
-  recipient,
   amount,
   uint,
   same,
@@ -71,15 +72,59 @@ export const settingBounds = [
   "20,000–500,000",
   "20,000–500,000",
   "20,000–500,000",
-  "20,000–500,000",
-  "20,000–500,000",
+  "20,000–500,000 gas, and the vault's combined rules: maxAssets × (balanceGas + 60,000) ≤ 28,000,000 and directLimit × (balanceGas + payGas + 70,000) ≤ 28,000,000",
+  "20,000–500,000 gas, and the vault's combined rule: directLimit × (balanceGas + payGas + 70,000) ≤ 28,000,000",
   "At least assetCount; maxAssets × (balanceGas + 60,000) ≤ 28,000,000",
   "directLimit × (balanceGas + payGas + 70,000) ≤ 28,000,000; zero disables direct attempts",
 ];
+// BaskVault._changedSettings refuses maxAssets > 28,000,000 / (balanceGas + 60,000)
+// and directLimit > 28,000,000 / (balanceGas + payGas + 70,000) (whole-number
+// division), so BalanceGas (12) and PayGas (13) have a current maximum.
+const GAS_BUDGET = 28_000_000n;
+export function gasMaximum(key: number, s: any): bigint | undefined {
+  if (!s || (key !== 12 && key !== 13)) return undefined;
+  const maxAssets = BigInt(s.maxAssets),
+    directLimit = BigInt(s.directLimit),
+    other = BigInt(key === 12 ? s.payGas : s.balanceGas);
+  let max = 500_000n;
+  if (key === 12 && maxAssets > 0n && GAS_BUDGET / maxAssets - 60_000n < max)
+    max = GAS_BUDGET / maxAssets - 60_000n;
+  if (
+    directLimit > 0n &&
+    GAS_BUDGET / directLimit - 70_000n - other < max
+  )
+    max = GAS_BUDGET / directLimit - 70_000n - other;
+  return max;
+}
+const grouped = (n: unknown) => BigInt(n as bigint).toLocaleString("en-US");
+// The bounds line; BalanceGas and PayGas add the maximum under current settings().
+export function settingBoundsWords(key: number, s: any): string {
+  if (key !== 12 && key !== 13) return settingBounds[key];
+  if (!s) return `${settingBounds[key]}. Current maximum unreadable — Retry vault.`;
+  const max = gasMaximum(key, s)!;
+  const from =
+    key === 12
+      ? `maxAssets ${grouped(s.maxAssets)}, directLimit ${grouped(s.directLimit)}, payGas ${grouped(s.payGas)}`
+      : `directLimit ${grouped(s.directLimit)}, balanceGas ${grouped(s.balanceGas)}`;
+  return max < 20_000n
+    ? `${settingBounds[key]}. With the current ${from}, no value fits: lower ${key === 12 ? "MaxAssets or DirectLimit" : "DirectLimit"} first.`
+    : `${settingBounds[key]}. Current maximum ${grouped(max)} (with the current ${from}).`;
+}
+// minLiquidity is compared with a 128-bit pool liquidity, so it is limited to
+// 128 bits like the listing parser (a larger floor would refuse every pool).
+function minLiquidityOf(v: string) {
+  try {
+    return uint(v, 128);
+  } catch {
+    throw new InputError(
+      "Minimum raw pool liquidity: enter an unsigned 128-bit whole number.",
+    );
+  }
+}
 export function poolValues(v: Record<string, string>) {
   const p = address(v.pool, true),
     q = address(v.quoteFeed, true),
-    l = uint(v.minLiquidity);
+    l = minLiquidityOf(v.minLiquidity);
   if (same(p, zeroAddress) && (!same(q, zeroAddress) || l !== 0n))
     throw new InputError(
       "No pool requires zero quote feed and zero liquidity.",
@@ -113,23 +158,57 @@ const empty: Action = {
   value2: 0n,
   setting: 0,
 };
+// Under Dst 0 (US rule) New York skips Sunday 2:00-2:59 am on the
+// spring-forward Sunday, so a start in that hour has no clean reopen time.
+export const SPRING_FORWARD_START =
+  "Sunday 2:00-2:59 am New York is skipped on the spring-forward Sunday; choose another start.";
+export function springForwardStart(from: bigint, dst: bigint) {
+  return dst === 0n && from >= 7200n && from < 10800n;
+}
+// settings: the current settings(); its Dst decides the spring-forward refusal
+// (unreadable counts as Dst 0, the stricter case).
 export function settingValues(
   v: Record<string, string>,
+  settings?: any,
 ): [number, bigint, bigint] {
   const key = Number(v.setting ?? "0");
   if (!settingNames[key]) throw new InputError("Choose a setting.");
   if (key === 5) {
     const [from, to] = parseHours(v.from ?? "", v.to ?? "");
+    if (springForwardStart(from, settings ? BigInt(settings.dst) : 0n))
+      throw new InputError(SPRING_FORWARD_START);
     return [key, from, to];
   }
   const value = uint(v.value || "0");
   if (key === 6 && value > 2n) throw new InputError("Dst is 0, 1 or 2.");
   return [key, value, 0n];
 }
+// The vault can never act as owner or guardian, so neither may be the vault.
+export function newOwner(v: string): Address {
+  const next = address(v);
+  if (same(next, VAULT))
+    throw new InputError("The new owner must not be the vault.");
+  return next;
+}
+function newGuardian(v: string): Address {
+  const next = address(v);
+  if (same(next, VAULT))
+    throw new InputError("The new guardian must not be the vault.");
+  return next;
+}
+// BaskVault refuses the vault itself as fee recipient (InvalidAddress).
+function feeRecipient(v: string): Address {
+  const target = address(v);
+  if (same(target, VAULT))
+    throw new InputError("The fee recipient must not be the vault.");
+  return target;
+}
 // Fields per kind follow the Action comment in BaskVault.sol; unused fields are zero.
+// settings: the current settings(), used only to refuse a spring-forward Hours start.
 export function proposalAction(
   kind: number,
   v: Record<string, string>,
+  settings?: any,
 ): Action {
   const a: Action = { ...empty, kind };
   switch (kind) {
@@ -156,23 +235,28 @@ export function proposalAction(
       return { ...a, token: address(v.token), pool, quoteFeed, value };
     }
     case 7:
-      return { ...a, target: address(v.next) };
+      return { ...a, target: newGuardian(v.next) };
     case 8:
       return { ...a, value: amount(v.cap) };
     case 9:
-      return { ...a, target: recipient(v.recipient) };
+      return { ...a, target: feeRecipient(v.recipient) };
     case 10: {
-      const [setting, value, value2] = settingValues(v);
+      const [setting, value, value2] = settingValues(v, settings);
       return { ...a, setting, value, value2 };
     }
     default:
       throw new InputError("Choose a proposal kind.");
   }
 }
-export function proposalSpec(kind: number, v: Record<string, string>) {
-  return vault("propose", [proposalAction(kind, v)]);
+export function proposalSpec(
+  kind: number,
+  v: Record<string, string>,
+  settings?: any,
+) {
+  return vault("propose", [proposalAction(kind, v, settings)]);
 }
-export function proposalWords(a: Action) {
+// settings: the current settings(), for the Hours zone and the FreshHours window.
+export function proposalWords(a: Action, settings?: any) {
   try {
     switch (Number(a.kind)) {
       case 0:
@@ -198,8 +282,8 @@ export function proposalWords(a: Action) {
       case 10: {
         const k = Number(a.setting);
         return k === 5
-          ? `hoursFrom / hoursTo = ${a.value} / ${a.value2}; ${settingWords(k, a.value, a.value2)}`
-          : `${settingFields[k]} = ${a.value}; ${settingWords(k, a.value)}`;
+          ? `hoursFrom / hoursTo = ${a.value} / ${a.value2}; ${settingWords(k, a.value, a.value2, settings)}`
+          : `${settingFields[k]} = ${a.value}; ${settingWords(k, a.value, 0n, settings)}`;
       }
       default:
         return "Unknown action. Retry.";
@@ -228,6 +312,8 @@ export type Pairing = Listing & {
   gapBps?: bigint;
   poolPrice?: bigint;
   warning?: string;
+  // settings().poolWindow (seconds) the liquidity was measured over.
+  poolWindow?: bigint;
 };
 export async function inspectListing(row: Listing): Promise<Pairing> {
   // asset() reverts for an unlisted token: decide "listed" from assetTokens().
@@ -302,7 +388,7 @@ export async function inspectListing(row: Listing): Promise<Pairing> {
       poolPrice > feedPrice ? poolPrice - feedPrice : feedPrice - poolPrice;
     gapBps = (difference * 10000n) / feedPrice;
     if (liquidity < row.minLiquidity)
-      error = `${window / 60n}-minute pool liquidity is under minLiquidity.`;
+      error = `${minutesOf(window)} pool liquidity is under minLiquidity.`;
     if (difference > (feedPrice * BigInt(settings.poolDeviation)) / 10000n)
       error =
         (error ? error + " " : "") + "Pool-vs-feed gap is over poolDeviation.";
@@ -334,22 +420,35 @@ export async function inspectListing(row: Listing): Promise<Pairing> {
     quoteName,
     listed,
     marked: row.ticker !== symbol || !pairingMatches(symbol, cleaned),
+    poolWindow: BigInt(settings.poolWindow),
   };
 }
 export { proposalKinds };
 
-export function settingWords(key: number, n: bigint, n2 = 0n) {
+const hoursOf = (n: bigint) => `${n} hour${n === 1n ? "" : "s"}`;
+// FreshCount in words; hours is the current FreshHours when readable.
+export function freshWords(count: bigint, hours?: bigint) {
+  if (count === 0n) return "off: deposits stay open when prices stop";
+  return `at least ${count} listed stock price${count === 1n ? "" : "s"} updated within the last ${hours === undefined ? "FreshHours hours" : hoursOf(hours)}; deposits close when prices stop (US market holidays) until one updates`;
+}
+// settings: the current settings(), when readable. Hours (5) are written in
+// its Dst zone (New York time, UTC-5 or UTC-4); FreshCount (3) uses its FreshHours.
+export function settingWords(key: number, n: bigint, n2 = 0n, settings?: any) {
   if (key === 0) return `centre /${n} to ×${n}`;
   if ([1, 2, 7].includes(key)) return `${Number(n) / 3600} hours (${n} s)`;
   if (key === 8) return `${Number(n) / 100}% (${n} basis points)`;
-  if (key === 5) return hoursWordsOf(n, n2);
+  if (key === 5)
+    return hoursWordsOf(n, n2, settings ? BigInt(settings.dst) : 0n);
   if (key === 6) return dstWords[Number(n)] ?? "unknown daylight rule";
   if (key === 15)
     return `With at most ${n} held stocks, every leg is tried now; with more, every leg is owed for claims. Zero disables direct attempts.`;
   if (key === 3)
-    return `${n} listed stock prices must have updated within the last FreshHours; deposits close when prices stop (US market holidays) until one updates`;
+    return freshWords(
+      n,
+      settings ? BigInt(settings.freshHours) : undefined,
+    );
   if (key === 4)
-    return `${n} hours; deposits need FreshCount prices updated within this window, so they close when prices stop (US market holidays) until one updates`;
+    return `${hoursOf(n)}; deposits need FreshCount prices updated within this window, so they close when prices stop (US market holidays) until one updates`;
   if (key >= 9 && key <= 13) return `${n} gas`;
   return `${n} stocks`;
 }
diff --git a/web/src/main.tsx b/web/src/main.tsx
index ed4d4f4..1828dc1 100644
--- a/web/src/main.tsx
+++ b/web/src/main.tsx
@@ -256,7 +256,6 @@ function App() {
         <div>
           <BasketIcon />
           <strong>Basket Protocol</strong>
-          <span>Stock Tokens. One basket.</span>
           <span className="footer-links">
             <a
               href="#owner"
diff --git a/web/src/model.ts b/web/src/model.ts
index fc04339..dbcc89e 100644
--- a/web/src/model.ts
+++ b/web/src/model.ts
@@ -9,9 +9,10 @@ import {
   VAULT,
   InputError,
   client,
+  rememberLabels,
   type ReadResult,
 } from "./chain";
-import { hoursWordsOf } from "./newYork";
+import { dateWords, hoursWordsOf } from "./newYork";
 export type Asset = {
   token: Address;
   feed: Address;
@@ -57,6 +58,8 @@ export type Snapshot = {
   status?: ReadResult;
   // Latest block timestamp, the clock the vault's hours and freshness use.
   blockTime?: bigint;
+  // Browser clock (ms) when that block arrived; countdowns add the time since.
+  blockReadAt?: number;
   loadedAt: number;
   loading?: boolean;
   retry?: () => void;
@@ -72,11 +75,18 @@ export const initial: Snapshot = {
 export async function loadSnapshot(): Promise<Snapshot> {
   const errors: string[] = [],
     globals: Globals = {};
+  let blockReadAt: number | undefined;
   const [gs, all, status, block] = await Promise.all([
     many(globalNames.map((n) => vault(n))),
     safe(vault("allAssets")),
     safe(vault("depositStatus", [[]])),
-    client.getBlock({ blockTag: "latest" }).catch(() => undefined),
+    client
+      .getBlock({ blockTag: "latest" })
+      .then((b) => {
+        blockReadAt = Date.now();
+        return b;
+      })
+      .catch(() => undefined),
   ]);
   if (!block) errors.push("latest block: unreadable");
   gs.forEach((r, i) => {
@@ -158,6 +168,7 @@ export async function loadSnapshot(): Promise<Snapshot> {
       : "unreadable";
     if (!s.ok || !d.ok) errors.push(`${a.token}: label unreadable`);
   });
+  rememberLabels(assets, globals.settings);
   return {
     assets,
     globals,
@@ -166,6 +177,7 @@ export async function loadSnapshot(): Promise<Snapshot> {
     aggregate: all.ok,
     status,
     blockTime: block?.timestamp,
+    blockReadAt: block ? blockReadAt : undefined,
     loadedAt: Date.now(),
   };
 }
@@ -310,14 +322,22 @@ export function fmt(n: bigint | undefined, decimals = 18, digits = 4): string {
 export const exact = (n: bigint, d = 18) => formatUnits(n, d);
 export const usd = (n: bigint | undefined) =>
   n === undefined ? "unreadable" : "$" + fmt(n, 18, 2);
-export const date = (n: bigint | undefined) =>
-  n === undefined
-    ? "unreadable"
-    : n === 0n
-      ? "Not set"
-      : new Date(Number(n) * 1000).toLocaleString("en-GB", {
-          timeZone: "UTC",
-        }) + " UTC";
+// "Sun 11 Oct 2026, 04:40 UTC (00:40 New York)"; never a numeric date. The words show whole minutes, rounded so
+// a waiting window never looks longer than it is: a start ("executable from", "Wait until", a loss's recognition
+// date) is rounded up to the next whole minute, an end ("until just before") down.
+export function date(n: bigint | undefined, edge: "start" | "end" = "start") {
+  if (n === undefined) return "unreadable";
+  if (n === 0n) return "Not set";
+  try {
+    const t = BigInt(n),
+      minute = (edge === "start" ? t + 59n : t) / 60n;
+    // Past year 9999 is no calendar date (and would stall the New York rule).
+    if (minute * 60n > 253402300799n) return "unreadable";
+    return dateWords(minute * 60n);
+  } catch {
+    return "unreadable";
+  }
+}
 export function age(n: bigint | undefined, now = Date.now() / 1000) {
   if (n === undefined || n === 0n) return "unreadable";
   const s = Math.floor(now - Number(n));
@@ -349,5 +369,7 @@ export function pairingMatches(symbol: string, description: string) {
   );
 }
 export function hoursWords(s: any) {
-  return !s ? "unreadable" : hoursWordsOf(s.hoursFrom, s.hoursTo);
+  return !s
+    ? "unreadable"
+    : hoursWordsOf(BigInt(s.hoursFrom), BigInt(s.hoursTo), BigInt(s.dst));
 }
diff --git a/web/src/newYork.ts b/web/src/newYork.ts
index 669261b..3ee0a1c 100644
--- a/web/src/newYork.ts
+++ b/web/src/newYork.ts
@@ -70,10 +70,11 @@ export function weekdayWords(s: bigint): string {
   if (s === WEEK) return "Saturday 24:00";
   return `${weekdays[Number(s / DAY)]} ${clockWords(s % DAY)}`;
 }
-export function hoursWordsOf(from: bigint, to: bigint): string {
+// Under Dst 1 or 2 the vault clock is a fixed UTC-5 or UTC-4, not New York time.
+export function hoursWordsOf(from: bigint, to: bigint, dst = 0n): string {
   return from === 0n && to === 0n
     ? "always open"
-    : `${weekdayWords(from)} to ${weekdayWords(to)} New York time`;
+    : `${weekdayWords(from)} to ${weekdayWords(to)} ${zoneWords(dst)}`;
 }
 export const dstWords = [
   "US daylight saving rule",
@@ -94,6 +95,32 @@ export function nyDate(t: bigint, dst: bigint): string {
     year: "numeric",
   });
 }
+const months = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec",
+];
+const two = (n: number) => String(n).padStart(2, "0");
+// A timestamp in words, never dd/mm: "Sun 11 Oct 2026, 04:40 UTC (00:40 New
+// York)". New York follows the US rule; its weekday is added when it differs.
+export function dateWords(t: bigint): string {
+  const utc = new Date(Number(t) * 1000),
+    ny = new Date(Number(t - offset(t, 0n)) * 1000);
+  const day = (d: Date) => weekdays[d.getUTCDay()].slice(0, 3);
+  const clock = (d: Date) =>
+    `${two(d.getUTCHours())}:${two(d.getUTCMinutes())}`;
+  const nyDay = ny.getUTCDay() === utc.getUTCDay() ? "" : `${day(ny)} `;
+  return `${day(utc)} ${utc.getUTCDate()} ${months[utc.getUTCMonth()]} ${utc.getUTCFullYear()}, ${clock(utc)} UTC (${nyDay}${clock(ny)} New York)`;
+}
 export function countdown(seconds: bigint): string {
   const total = seconds < 0n ? 0n : seconds;
   return `${total / 3600n} h ${(total % 3600n) / 60n} min`;
diff --git a/web/src/styles.css b/web/src/styles.css
index 73d2611..90f7de6 100644
--- a/web/src/styles.css
+++ b/web/src/styles.css
@@ -385,21 +385,6 @@ main {
   letter-spacing: 1px;
   margin-bottom: 12px;
 }
-.vault-hero {
-  display: grid;
-  grid-template-columns: minmax(0, 1fr) 380px;
-  gap: 20px;
-  align-items: stretch;
-}
-.clerk-panel {
-  position: relative;
-  display: flex;
-  align-items: flex-end;
-  background: var(--sun);
-  border: 6px solid var(--red);
-  margin: 28px 0;
-  overflow: hidden;
-}
 .burst {
   display: flex;
   align-items: center;
@@ -436,15 +421,6 @@ main {
 
   flex-shrink: 0;
 }
-.clerk-panel .burst {
-  position: absolute;
-  right: 2px;
-  top: 2px;
-  background: var(--paper);
-  width: 85px;
-  height: 85px;
-  z-index: 1;
-}
 .burst.small {
   width: 70px;
   height: 70px;
@@ -790,7 +766,7 @@ footer strong {
 }
 @media (prefers-reduced-motion: no-preference) {
   .marquee-track {
-    animation: shop-scroll 180s linear infinite;
+    animation: shop-scroll calc(var(--k) * var(--per)) linear infinite;
   }
   button {
     transition:
@@ -817,9 +793,6 @@ footer strong {
   .roles {
     grid-template-columns: 1fr;
   }
-  .vault-hero {
-    grid-template-columns: minmax(0, 1fr) 320px;
-  }
   .brand {
     font-size: 64px;
   }
@@ -916,10 +889,6 @@ footer strong {
   h3 {
     font-size: 24px;
   }
-  .vault-hero {
-    display: block;
-    position: relative;
-  }
   .panel {
     padding: 18px 14px;
     border-width: 5px;
@@ -1027,21 +996,90 @@ footer strong {
   margin-top: 12px;
 }
 
-/* Only the slogan track moves; overflow clipping also paints correctly on iOS. */
+/* Only the slogan track moves; overflow clipping also paints correctly on iOS. Each half shows k whole slogan
+   lines (one line is 720 px), k = the fewest lines that cover the screen, so the loop never shows a blank stretch.
+   The moving block stays small and has no will-change, so iOS keeps painting it. Same speeds as before: 16 px/s,
+   64 px/s on phones (--per is the time for one line). */
 .marquee-track {
   display: flex;
   width: max-content;
-  will-change: transform;
 }
 .marquee-half {
   display: flex;
   flex: none;
-  min-width: 100vw;
 }
 .marquee-half > span {
   flex: none;
   white-space: pre;
 }
+.marquee {
+  --k: 1;
+  --per: 45s;
+}
+.marquee-half > span:nth-child(n + 2) {
+  display: none;
+}
+@media (max-width: 660px) {
+  .marquee {
+    --per: 11.25s;
+  }
+}
+@media (min-width: 721px) {
+  .marquee {
+    --k: 2;
+  }
+  .marquee-half > span:nth-child(2) {
+    display: block;
+  }
+}
+@media (min-width: 1441px) {
+  .marquee {
+    --k: 3;
+  }
+  .marquee-half > span:nth-child(3) {
+    display: block;
+  }
+}
+@media (min-width: 2161px) {
+  .marquee {
+    --k: 4;
+  }
+  .marquee-half > span:nth-child(4) {
+    display: block;
+  }
+}
+@media (min-width: 2881px) {
+  .marquee {
+    --k: 5;
+  }
+  .marquee-half > span:nth-child(5) {
+    display: block;
+  }
+}
+@media (min-width: 3601px) {
+  .marquee {
+    --k: 6;
+  }
+  .marquee-half > span:nth-child(6) {
+    display: block;
+  }
+}
+@media (min-width: 4321px) {
+  .marquee {
+    --k: 7;
+  }
+  .marquee-half > span:nth-child(7) {
+    display: block;
+  }
+}
+@media (min-width: 5041px) {
+  .marquee {
+    --k: 8;
+  }
+  .marquee-half > span:nth-child(8) {
+    display: block;
+  }
+}
 button.primary:hover:not(:disabled),
 button.primary:focus-visible:not(:disabled),
 button.primary:active:not(:disabled) {
@@ -1133,9 +1171,6 @@ summary {
   }
 }
 @media (max-width: 660px) {
-  .marquee-track {
-    animation-duration: 45s;
-  }
   .header-inner {
     padding: 12px 14px;
   }
@@ -1279,23 +1314,6 @@ summary {
   object-fit: contain;
   object-position: 50% 100%;
 }
-.clerk-panel {
-  padding-top: 150px;
-}
-.clerk-panel .character-picture { height: 300px; }
-.vault-hero .page-title {
-  display: flex;
-  flex-direction: column;
-}
-.vault-hero .page-title:after { margin-top: auto; }
-.picture-stage {
-  container-type: inline-size;
-  position: relative;
-  padding-top: 16px;
-  background: var(--sun);
-  border: 4px solid var(--red);
-  margin-bottom: 24px;
-}
 .speech-bubble {
   position: absolute;
   top: 12px;
@@ -1331,41 +1349,6 @@ summary {
   background: var(--ink);
   clip-path: polygon(0 0, 100% 100%, 0 85%);
 }
-.clerk-panel .speech-bubble {
-  top: 94px;
-  left: auto;
-  right: 8px;
-  width: 140px;
-}
-.clerk-panel .speech-bubble:before,
-.redeem-picture .speech-bubble:before {
-  left: -24px;
-  right: auto;
-  clip-path: polygon(100% 0, 0 100%, 100% 85%);
-}
-.clerk-panel .speech-bubble:after,
-.redeem-picture .speech-bubble:after {
-  left: -16px;
-  right: auto;
-  clip-path: polygon(100% 0, 0 100%, 100% 75%);
-}
-.redeem-picture .speech-bubble {
-  left: auto;
-  right: 8px;
-  width: min(155px, calc(50% - 82px));
-}
-.clerk-panel .speech-bubble:before { top: 68px; }
-.clerk-panel .speech-bubble:after { top: 70px; }
-@media (min-width: 661px) and (max-width: 960px) {
-  .character-picture,
-  .clerk-panel .character-picture { height: 260px; }
-  .clerk-panel { padding-top: 150px; }
-  .clerk-panel .speech-bubble { width: 126px; }
-  .clerk-panel .speech-bubble:before { top: 68px; }
-  .clerk-panel .speech-bubble:after { top: 70px; }
-  .deposit-picture .speech-bubble { width: min(155px, calc(50% - 57px)); }
-  .redeem-picture .speech-bubble { width: min(155px, calc(50% - 67px)); }
-}
 @media (max-width: 660px) {
   .store-shelf {
     --food-size: 22px;
@@ -1375,42 +1358,1237 @@ summary {
     height: 50px;
   }
   .shelf-row { padding-block: 0 var(--plank-size); }
-  .character-picture { height: 240px; }
-  .clerk-panel .character-picture { height: 200px; }
-  .speech-bubble { font-size: 15px; padding: 8px; }
-  .clerk-panel { padding-top: 144px; }
-  .clerk-panel .speech-bubble:before { top: 48px; }
-  .clerk-panel .speech-bubble:after { top: 50px; }
-  .clerk-panel .speech-bubble { width: 124px; }
-  .deposit-picture .speech-bubble { width: calc(50% - 54px); }
-  .redeem-picture .speech-bubble { width: calc(50% - 57px); }
-  .picture-stage .speech-bubble:before { top: 10px; }
-  .picture-stage .speech-bubble:after { top: 12px; }
 }
 
-/* Narrow aside frames reserve space above the bag, keeping the bubble whole. */
-@media (min-width: 661px) {
-@container (max-width: 270px) {
-  .redeem-picture .character-picture { margin-top: 150px; }
-  .redeem-picture .speech-bubble {
-    left: 12px;
-    right: auto;
-    width: 155px;
-  }
-  .redeem-picture .speech-bubble:before {
-    left: 100px;
-    top: auto;
-    bottom: -26px;
-    clip-path: polygon(0 0, 100% 100%, 100% 0);
-  }
-  .redeem-picture .speech-bubble:after {
-    left: 103px;
-    top: auto;
-    bottom: -18px;
-    clip-path: polygon(0 0, 100% 100%, 100% 0);
+/* Look update: speech bubbles break only between words, never inside a word. */
+.speech-bubble {
+  overflow-wrap: normal;
+  word-break: normal;
+  hyphens: none;
+}
+/* Look update: the wallet hint keeps a clear gap from its button; on narrow screens the button wraps below. */
+.wallet-help {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px 16px;
+  text-wrap: pretty;
+}
+/* A title panel with a character and no eyebrow (Vault): the heading takes the eyebrow's auto top margin, so the
+   heading and the sentence stay centred beside her; on phones the text follows below her as before. */
+.page-title.has-character > h1:first-child {
+  margin-top: auto;
+}
+@media (max-width: 660px) {
+  .page-title.has-character > h1:first-child {
+    margin-top: 0;
   }
 }
+
+/* Pop-out title character, shared by Vault, Deposit and Redeem.
+   She stands on the title panel's checker strip at its right end; her head (and the Vault wave)
+   rises above the panel's top edge. Her bubble sits beside her head, its tail aimed at her mouth. */
+.page-title.has-character {
+  --h: 390px;                                  /* picture height */
+  --w: calc(var(--h) * var(--ratio));          /* picture width (natural ratio) */
+  --pop: 48px;                                 /* picture top above the panel's outer top edge */
+  --stand: 13px;                               /* soles on the strip's yellow line */
+  --bd: 7px;                                   /* panel border (yellow frame) */
+  --pad: 28px;                                 /* panel padding */
+  --bubble-font: 20px;
+  --bw-vault: 170px;                           /* Vault's bubble width (also the reference for Redeem's heading cap) */
+  --zone: calc(var(--w) * var(--bx) + var(--bw));
+  --zone-vault: calc(var(--h) * 0.38481 + var(--bw-vault));   /* Vault's zone: 0.606 x 0.635 x h + bubble */
+  --gutter: 28px;
+  --h1-max: 96px;                              /* one-line heading cap */
+  --h2-max: 64px;                              /* two-line heading cap */
+  position: relative;
+  overflow: visible;
+  container-type: inline-size;
+  display: flex;
+  flex-direction: column;
+  min-height: calc(var(--stand) + var(--h) + var(--bd) - var(--pop));
+  margin-top: calc(12px + var(--pop));
+  padding-right: calc(var(--pad) + var(--zone) + var(--gutter));
+}
+.page-title.has-character:after {
+  margin: 22px calc(-1 * (var(--pad) + var(--zone) + var(--gutter))) calc(-1 * var(--pad)) calc(-1 * var(--pad));
+}
+.page-title.has-character > .eyebrow { margin-top: auto; }
+.page-title.has-character > p:last-of-type { margin-bottom: auto; font-size: 18px; }
+.page-title.has-character h1 {
+  /* One line that fills the column, or, when that would be small, two balanced lines up to --h2-max. */
+  font-size: clamp(
+    40px,
+    max(min(100cqi / var(--em1), var(--h1-max)), min(100cqi / var(--em2), var(--h2-max))),
+    var(--h1-max)
+  );
+}
+
+/* Per page: picture ratio, bubble left edge (share of picture width), tail tip x (share of width,
+   just outside the cheek), mouth height (share of picture height), bubble width, heading width in em
+   on one line (em1) and its longer line when balanced over two (em2). */
+.page-title.character-vault   { --ratio: 0.606; --bx: 0.635; --tx: 0.50;  --mouth: 0.176; --bw: var(--bw-vault); --em1: 8.1;  --em2: 4.45; }
+.page-title.character-deposit { --ratio: 0.313; --bx: 0.94;  --tx: 0.675; --mouth: 0.168; --bw: 124px; --em1: 8.78; --em2: 5.6; }
+.page-title.character-redeem  { --ratio: 0.484; --bx: 0.93;  --tx: 0.775; --mouth: 0.18;  --bw: 226px; --em1: 5.34; --em2: 3.1; --h1-max: 108px; --h2-max: 56px; }
+
+/* "Redeem BASK" is short, so filling its column would make it far bigger than the other pages'
+   headings. Cap it at 1.2x the size the Vault heading has on a panel of the same width
+   (--vault-col is the Vault text column at this width; 8.1 / 4.45 / 96px / 64px are Vault's values). */
+.page-title.character-redeem h1 {
+  --vault-col: calc(100cqi + var(--zone) - var(--zone-vault));
+  font-size: clamp(
+    40px,
+    min(
+      max(min(100cqi / var(--em1), var(--h1-max)), min(100cqi / var(--em2), var(--h2-max))),
+      1.2 * max(min(var(--vault-col) / 8.1, 96px), min(var(--vault-col) / 4.45, 64px))
+    ),
+    var(--h1-max)
+  );
+}
+
+.page-title .title-character {
+  --gx: 0px;
+  --img-top: 0px;
+  --tail: calc(var(--w) * (var(--bx) - var(--tx)) + 3px);
+  position: absolute;
+  z-index: 1;
+  right: var(--pad);
+  bottom: var(--stand);
+  width: var(--zone);
+  height: var(--h);
+}
+.page-title .title-character .character-picture {
+  position: absolute;
+  left: var(--gx);
+  bottom: 0;
+  width: var(--w);
+  height: var(--h);
+  object-fit: contain;
+  object-position: 50% 100%;
+}
+.page-title .title-character .speech-bubble {
+  /* Tail: its tip sits just outside her cheek at mouth height (+ --tip-drop); the bubble's top edge
+     is --drop below the tip; the tail's base runs down the bubble's left side from --base1 to --base2
+     (measured from the inner top edge). --fill-* shape the white inside of the tail. */
+  --tip-drop: 9px;
+  --drop: 6px;
+  --base1: 12px;
+  --base2: 36px;
+  --fill-x: 7px;
+  --fill-y: 6px;
+  --fill-b1: 3.5px;
+  --fill-b2: 5px;
+  top: calc(var(--img-top) + var(--h) * var(--mouth) + var(--tip-drop) + var(--drop));
+  left: calc(var(--gx) + var(--w) * var(--bx));
+  right: auto;
+  width: var(--bw);
+  padding: 6px 12px;
+  font-size: var(--bubble-font);
+  line-height: 1.2;
+  text-wrap: balance;
+  text-align: center;
+}
+.page-title .title-character .speech-bubble:before,
+.page-title .title-character .speech-bubble:after {
+  top: calc(-9px - var(--drop));
+  right: auto;
+  left: calc(-1 * var(--tail));
+  width: calc(var(--tail) + 3px);
+  height: calc(var(--drop) + var(--base2) + 11px);
+}
+.page-title .title-character .speech-bubble:before {
+  clip-path: polygon(
+    0 6px,
+    calc(100% - 3px) calc(var(--drop) + 9px + var(--base1)),
+    calc(100% - 3px) calc(var(--drop) + 9px + var(--base2))
+  );
+}
+.page-title .title-character .speech-bubble:after {
+  clip-path: polygon(
+    var(--fill-x) calc(6px + var(--fill-y)),
+    100% calc(var(--drop) + 9px + var(--base1) + var(--fill-b1)),
+    100% calc(var(--drop) + 9px + var(--base2) - var(--fill-b2))
+  );
+}
+/* Vault: the crate's greens sit right under her bubble, so it stays higher, with a flatter tail. */
+.page-title.character-vault .speech-bubble {
+  --tip-drop: 3px;
+  --drop: -5px;
+  --fill-y: 4px;
+  --fill-b1: 3px;
+  --fill-b2: 4px;
+}
+
+/* Middle widths: smaller picture; the heading may take two lines. */
+@media (max-width: 999px) {
+  .page-title.has-character {
+    --h: 340px;
+    --pop: 42px;
+    --bubble-font: 18px;
+    --gutter: 22px;
+    --bw-vault: 158px;
+  }
+  .page-title.has-character > p:last-of-type { font-size: 16px; }
+  .page-title.character-vault .speech-bubble { --drop: -9px; }
+  .page-title.character-deposit .speech-bubble { --drop: 2px; --tip-drop: 7px; }
+  .page-title.character-deposit { --bw: 114px; }
+  .page-title.character-redeem { --bw: 150px; }
+}
+
+/* Phones: she stands on her own shelf at the top of the panel, popping over its top edge.
+   Vault: the title text follows below her. Deposit and Redeem: the eyebrow and heading stand
+   beside her legs, the sentence follows below. */
+@media (max-width: 660px) {
+  .page-title.has-character {
+    --h: 300px;
+    --pop: 34px;
+    --bd: 5px;
+    --pad: 14px;
+    --bubble-font: 16px;
+    --gutter: 0px;
+    --bw-vault: 170px;
+    --stage: calc(var(--h) - var(--pop) - var(--bd) - var(--pad));
+    min-height: 0;
+    margin-top: calc(16px + var(--pop));
+    padding-right: var(--pad);
+  }
+  .page-title.has-character:after {
+    margin: 20px calc(-1 * var(--pad)) calc(-1 * var(--pad));
+  }
+  .page-title.has-character > .eyebrow { margin-top: 0; }
+  .page-title.has-character > p:last-of-type { margin-bottom: 0; }
+  .page-title.has-character h1 { font-size: 36px; }
+  .page-title .title-character {
+    --gx: max(0px, calc((100% - var(--zone)) / 2));
+    --img-top: calc(-1 * (var(--pop) + var(--bd) + var(--pad)));
+    position: relative;
+    order: -1;
+    right: auto;
+    bottom: auto;
+    width: auto;
+    height: var(--stage);
+    margin: 0 0 17px;
+  }
+  /* Her shelf: from the left frame to just past her (and the Vault crate). */
+  .page-title .title-character:after {
+    content: "";
+    position: absolute;
+    left: calc(-1 * var(--pad));
+    width: calc(var(--pad) + var(--gx) + var(--w) + 12px);
+    bottom: -3px;
+    height: 3px;
+    background: var(--sun);
+  }
+  .page-title.has-character .title-character .speech-bubble {
+    --tip-drop: 0px;
+    --drop: -9px;
+    --base2: 32px;
+    --fill-x: 6px;
+    --fill-y: 2.5px;
+    --fill-b1: 3px;
+    --fill-b2: 3px;
+    padding: 6px 10px;
+    line-height: 1.15;
+  }
+  .page-title.character-deposit { --bw: 150px; }
+  .page-title.character-redeem { --bw: 160px; }
+
+  .page-title.character-deposit,
+  .page-title.character-redeem {
+    --col-gap: 12px;
+    display: grid;
+    grid-template-columns: calc(var(--w) + var(--col-gap)) minmax(0, 1fr);
+    grid-template-rows: minmax(0, 1fr) auto auto auto auto;
+  }
+  .page-title.character-deposit .title-character,
+  .page-title.character-redeem .title-character {
+    --gx: 0px;
+    grid-area: 1 / 1 / 4 / 3;
+  }
+  .page-title.character-deposit > .eyebrow,
+  .page-title.character-redeem > .eyebrow { grid-area: 2 / 2; }
+  .page-title.character-deposit h1,
+  .page-title.character-redeem h1 { grid-area: 3 / 2; margin-bottom: 17px; }
+  .page-title.character-deposit > p:last-of-type,
+  .page-title.character-redeem > p:last-of-type { grid-area: 4 / 1 / 5 / 3; }
+  .page-title.character-deposit:after,
+  .page-title.character-redeem:after { grid-area: 5 / 1 / 6 / 3; }
+}
+/* Smallest phones: a slightly smaller picture. Redeem keeps the side-by-side layout: its eyebrow
+   wraps to two lines beside her and the column gap shrinks so "REDEEM" fits. */
+@media (max-width: 359px) {
+  .page-title.has-character { --h: 270px; --pop: 26px; --bw-vault: 146px; }
+  .page-title.has-character.character-vault .speech-bubble { --drop: -12px; }
+  .page-title.character-deposit { --bw: 140px; }
+  .page-title.character-redeem { --bw: 138px; --col-gap: 8px; }
+}
+
+/* ---------------------------------------------------------------------------
+   Stock shelves, option A: shelf-edge labels. Yellow labels clip onto red shelf
+   edges in a store shelf unit, in two groups under small flyer shelf signs:
+   "In the basket" (full labels) and "On the shelf, not held" (compact labels).
+   New class names only (sa-*).
+   --------------------------------------------------------------------------- */
+.sa-section {
+  --sa-gap: 14px;
+  --sa-rail: 18px;
+  --sa-lip: 5px;
+  --sa-wall: #c4e7ff;
+  --sa-muted: #33405a;
+  --sa-stale: #525d75;
+}
+.sa-sr,
+.sa-age.is-stale .sa-upd {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  overflow: hidden;
+  clip-path: inset(50%);
+  white-space: nowrap;
+}
+/* Toolbar: quick filters + search */
+.sa-toolbar {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px 24px;
+}
+.sa-filters {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+.sa-filters button {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  padding: 6px 10px 6px 14px;
+  font-size: 15px;
+}
+.sa-filters button[aria-pressed="true"] {
+  background: var(--royal);
+  border-color: var(--royal);
+  color: var(--paper);
+}
+.sa-count {
+  min-width: 2.2ch;
+  padding: 0 5px;
+  background: var(--sun);
+  color: var(--ink);
+  font: 22px/1.05 Pixel, monospace;
+  text-align: center;
+  border-radius: 2px;
+}
+.sa-filters button[aria-pressed="false"] .sa-count {
+  background: var(--subtle);
+}
+.sa-search {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  flex: 0 1 380px;
+  margin: 0;
+  font-size: 15px;
+  white-space: nowrap;
+}
+.sa-search input:not([type="checkbox"]) {
+  flex: 1;
+  min-width: 0;
+  min-height: 44px;
+  padding: 8px 10px;
+}
+.sa-note {
+  margin: 10px 0 12px;
+  font-size: 14px;
+  color: var(--sa-muted);
+}
+/* "Show all" while a filter or search is on: a link-style button, 44 px tall
+   for taps without making the line taller */
+.sa-reset {
+  min-height: 44px;
+  margin: -12px 0;
+  padding: 0 2px;
+  border: 0;
+  border-radius: 0;
+  background: none;
+  color: var(--royal);
+  font-size: inherit;
+  font-weight: 700;
+  line-height: 1.2;
+  text-decoration: underline;
+  text-decoration-thickness: 2px;
+  text-underline-offset: 3px;
+  vertical-align: baseline;
+}
+.sa-reset:hover:not(:disabled) {
+  background: none;
+}
+.sa-reset:focus-visible {
+  outline-offset: 0;
+  box-shadow: inset 0 0 0 3px var(--sun);
+}
+/* The shelf unit: light back wall between two blue uprights */
+.sa-unit {
+  --sa-post: 10px;
+  position: relative;
+  padding: 0 var(--sa-post) 16px;
+  background: var(--sa-wall);
+  border: 3px solid var(--ink);
+  box-shadow:
+    inset var(--sa-post) 0 0 var(--royal),
+    inset calc(-1 * var(--sa-post)) 0 0 var(--royal),
+    inset 0 -10px 0 var(--ink);
+}
+.sa-unit .store-shelf {
+  height: auto;
+  margin: 0;
+}
+.sa-unit .shelf-row + .shelf-row {
+  display: none;
+}
+.sa-unit .empty {
+  margin: 16px 6px 6px;
+}
+/* Group signs: small flyer shelf signs on the back wall */
+.sa-signrow {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 6px 14px;
+  padding: 16px calc(var(--sa-gap) / 2 + 2px) 2px;
+}
+.sa-sign {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  margin: 0;
+  padding: 4px 5px 3px 10px;
+  background: var(--red);
+  color: var(--paper);
+  font: 20px/1.1 Flyer, Impact, sans-serif;
+  letter-spacing: 0.03em;
+  text-transform: uppercase;
+  border: 2px solid var(--ink);
+  border-radius: 2px;
+  box-shadow: 3px 3px 0 var(--ink);
+  transform: rotate(-1deg);
+}
+.sa-n {
+  min-width: 2ch;
+  padding: 1px 5px 0;
+  background: var(--sun);
+  color: var(--ink);
+  font: 22px/1 Pixel, monospace;
+  letter-spacing: 0;
+  text-align: center;
+  border-radius: 2px;
+}
+.sa-sub {
+  margin: 0;
+  font-size: 14px;
+  line-height: 1.35;
+  color: var(--sa-muted);
+}
+.sa-emptyline {
+  color: var(--ink);
+  font-size: 15px;
+}
+/* The shelves: the grid decides how many labels fit in a row */
+.sa-shelves {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(max(140px, 18%), 1fr));
+  column-gap: var(--sa-gap);
+  row-gap: 18px;
+  margin: 0;
+  padding: 14px calc(var(--sa-gap) / 2) 0;
+  list-style: none;
+}
+.sa-shelves--mini {
+  grid-template-columns: repeat(auto-fill, minmax(max(102px, 12.5%), 1fr));
+}
+.sa-slot {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+  padding-top: 7px;
+  container: sa-slot / inline-size;
+}
+/* each slot draws its piece of the red shelf edge (ink edges, then the shelf
+   lip shadow the labels hang from) as one gradient, so overlapping pieces join
+   without seams */
+.sa-slot::before {
+  content: "";
+  position: absolute;
+  top: 0;
+  left: calc(var(--sa-gap) / -2 - 2px);
+  right: calc(var(--sa-gap) / -2 - 2px);
+  height: calc(var(--sa-rail) + var(--sa-lip));
+  background: linear-gradient(
+    var(--ink) 0 2px,
+    var(--red) 2px calc(var(--sa-rail) - 2px),
+    var(--ink) calc(var(--sa-rail) - 2px) var(--sa-rail),
+    #88a8c5 var(--sa-rail)
+  );
+}
+.sa-slot--empty {
+  min-height: 40px;
+}
+/* The shelf-edge label (labels in one row share its height) */
+.sa-label {
+  position: relative;
+  z-index: 1;
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  min-width: 0;
+  margin: 0 3px;
+  padding: 10px 10px 0;
+  background: var(--sun);
+  color: var(--ink);
+  border: 2px solid var(--ink);
+  border-radius: 3px;
+  box-shadow: 0 3px 0 rgba(20, 44, 84, 0.3);
+  transform-origin: 50% -8px;
+}
+.sa-label--mini {
+  gap: 1px;
+  margin: 0;
+  padding: 9px 7px 6px;
+}
+.sa-clip {
+  position: absolute;
+  top: -10px;
+  left: 50%;
+  width: 26px;
+  height: 13px;
+  margin-left: -13px;
+  background: #e8eef6;
+  border: 2px solid var(--ink);
+  border-radius: 2px;
+}
+.sa-main,
+.sa-figs {
+  display: contents;
+}
+.sa-top {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 0 8px;
+}
+.sa-label h4 {
+  flex: 1 1 auto;
+  margin: 0;
+  font: 24px/1.15 Flyer, Impact, sans-serif;
+  letter-spacing: 0.01em;
+  text-transform: uppercase;
+  overflow-wrap: anywhere;
+}
+.sa-label--mini h4 {
+  font-size: 21px;
+}
+/* flyer price in red (large text, 3.5:1 on the label) with small raised dollar
+   sign and cents in the darker flyer red (5.9:1, small text) */
+.sa-price {
+  margin: 0;
+  font: 28px/1.1 Flyer, Impact, sans-serif;
+  letter-spacing: 0.01em;
+  color: var(--red);
+  white-space: nowrap;
+}
+.sa-label--mini .sa-price {
+  font-size: 26px;
+}
+.sa-cur,
+.sa-cents {
+  display: inline-block;
+  font-size: max(14px, 0.56em);
+  line-height: 1;
+  vertical-align: top;
+  margin-top: 0.2em;
+  color: var(--error);
 }
-@media (max-width: 360px) {
-  .clerk-panel .speech-bubble { width: 110px; }
+.sa-cur {
+  margin-right: 1px;
+}
+.sa-cents {
+  margin-left: 2px;
+  text-decoration: underline;
+  text-decoration-thickness: 2px;
+  text-underline-offset: 2px;
+}
+.sa-price.is-stale,
+.sa-price.is-stale span {
+  color: var(--sa-stale);
+}
+.sa-label .sa-price.is-unreadable {
+  flex-basis: 100%;
+  font: 700 14px/1.4 Arial, Helvetica, sans-serif;
+  color: var(--ink);
+  white-space: normal;
+}
+.sa-age {
+  flex-basis: 100%;
+  margin: 0;
+  font-size: 14px;
+  line-height: 1.35;
+  text-align: end;
+  color: var(--sa-muted);
+}
+/* compact labels: price on its own line under the ticker, then the time */
+.sa-label--mini:not(.sa-label--chip) .sa-price {
+  flex-basis: 100%;
+}
+.sa-label--mini:not(.sa-label--chip) .sa-age {
+  text-align: start;
+}
+.sa-old {
+  display: inline-block;
+  margin-right: 2px;
+  padding: 0 5px;
+  background: var(--paper);
+  border: 2px solid var(--error);
+  border-radius: 2px;
+  color: var(--error);
+  font-size: 13px;
+  font-weight: 700;
+  line-height: 1.3;
+}
+.sa-age.is-stale .sa-when {
+  color: var(--error);
+  font-weight: 700;
+  white-space: nowrap;
+}
+/* small drawn clock (no numbers) that stands for "price updated" */
+.sa-clock {
+  display: none;
+  position: relative;
+  width: 13px;
+  height: 13px;
+  margin-right: 5px;
+  vertical-align: -2px;
+  border: 2px solid currentColor;
+  border-radius: 50%;
+}
+.sa-clock::before,
+.sa-clock::after {
+  content: "";
+  position: absolute;
+  background: currentColor;
+}
+.sa-clock::before {
+  left: 3.5px;
+  top: 1px;
+  width: 2px;
+  height: 4.5px;
+}
+.sa-clock::after {
+  left: 4.5px;
+  top: 3.5px;
+  width: 3.5px;
+  height: 2px;
+}
+.sa-age.is-stale .sa-clock {
+  display: inline-block;
+}
+.sa-narrow {
+  display: none;
+}
+/* status in plain words; on compact labels the details button sits at its end */
+.sa-st {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 2px 6px;
+  margin: 3px 0 0;
+  font-size: 14px;
+  line-height: 1.35;
+}
+.sa-label--mini .sa-st {
+  margin-top: auto;
+  padding-top: 2px;
+}
+.sa-warn {
+  color: var(--error);
+}
+.sa-mark {
+  display: inline-block;
+  width: 11px;
+  height: 11px;
+  margin-right: 6px;
+  vertical-align: -1px;
+  background: var(--royal);
+  border-radius: 50%;
+}
+.sa-label--closed .sa-mark {
+  background: var(--error);
+  border-radius: 1px;
+}
+.sa-label--paused .sa-mark {
+  width: 0;
+  height: 0;
+  background: none;
+  border-radius: 0;
+  border-inline: 6px solid transparent;
+  border-bottom: 11px solid var(--error);
+}
+.sa-label--retired .sa-mark {
+  background: transparent;
+  border: 2px solid var(--ink);
+}
+.sa-label--unknown .sa-mark {
+  background: var(--ink);
+  border-radius: 1px;
+  transform: rotate(45deg) scale(0.85);
+}
+.sa-label--closed,
+.sa-label--paused {
+  border-color: var(--error);
+  box-shadow:
+    inset 0 5px 0 var(--error),
+    0 3px 0 rgba(20, 44, 84, 0.3);
+}
+.sa-label--closed .sa-stw > b {
+  color: var(--error);
+}
+.sa-label--retired {
+  background: #e4e9f0;
+}
+/* red rubber stamp on a closed label (the plain words say it too) */
+.sa-stamp {
+  flex: none;
+  align-self: center;
+  padding: 2px 6px 1px 7px;
+  background: var(--paper);
+  color: var(--red);
+  border: 2px solid var(--red);
+  border-radius: 4px;
+  box-shadow:
+    inset 0 0 0 1px var(--paper),
+    inset 0 0 0 2px var(--red);
+  font: 15px/1.2 Flyer, Impact, sans-serif;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  transform: rotate(-7deg);
+  margin-block: -4px;
+}
+/* the price reason words in one slim chip */
+.sa-chip {
+  align-self: flex-start;
+  max-width: 100%;
+  margin: 1px 0 0;
+  padding: 0 8px;
+  background: var(--paper);
+  color: var(--error);
+  border: 2px solid var(--error);
+  border-radius: 12px;
+  font-size: 14px;
+  font-weight: 700;
+  line-height: 1.25;
+}
+.sa-flag {
+  margin: 3px 0 0;
+  padding: 1px 6px;
+  background: var(--error);
+  color: var(--paper);
+  font-size: 14px;
+  font-weight: 700;
+  line-height: 1.35;
+  border-radius: 2px;
+}
+/* share of the basket: a flyer sticker with the %, the bar beside it */
+.sa-share {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin: 8px 0 3px;
+}
+.sa-pct {
+  flex: none;
+  padding: 4px 7px 3px;
+  font: 21px/1 Flyer, Impact, sans-serif;
+  font-weight: 400;
+  letter-spacing: 0.02em;
+  background: var(--royal);
+  color: var(--paper);
+  border: 2px solid var(--ink);
+  border-radius: 2px;
+  box-shadow: 2px 2px 0 var(--ink);
+  transform: rotate(-3deg);
+}
+.sa-pct.is-zero {
+  background: var(--paper);
+  color: var(--ink);
+}
+.sa-meter {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+}
+.sa-of {
+  font-size: 14px;
+  line-height: 1.2;
+  color: var(--sa-muted);
+  white-space: nowrap;
+}
+.sa-bar {
+  height: 13px;
+  overflow: hidden;
+  background: var(--paper);
+  border: 2px solid var(--ink);
+  border-radius: 2px;
+}
+.sa-bar i {
+  display: block;
+  height: 100%;
+  background: var(--royal);
+}
+.sa-kv {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 0 6px;
+  margin: 0;
+  font-size: 14px;
+  line-height: 1.4;
+}
+.sa-kv > span {
+  color: var(--sa-muted);
+}
+.sa-kv b {
+  margin-left: auto;
+  text-align: end;
+}
+.sa-kv--value b {
+  font-size: 15px;
+}
+.sa-foot {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  margin-top: auto;
+  padding: 5px 0 5px;
+}
+.sa-more {
+  min-height: 0;
+  padding: 2px 0;
+  border: 0;
+  border-radius: 0;
+  background: none;
+  color: var(--royal);
+  font-size: 14px;
+  font-weight: 700;
+  line-height: 1.35;
+  text-decoration: underline;
+  text-underline-offset: 3px;
+  white-space: nowrap;
+}
+.sa-more:hover:not(:disabled) {
+  background: none;
+}
+.sa-chev {
+  display: inline-block;
+  margin-left: 5px;
+  border-inline: 5px solid transparent;
+  border-top: 6px solid currentColor;
+  vertical-align: 2px;
+}
+.sa-more[aria-expanded="true"] .sa-chev {
+  border-top: 0;
+  border-bottom: 6px solid currentColor;
+}
+/* compact labels: a small round details button at the end of the status line */
+.sa-label--mini .sa-more {
+  flex: none;
+  display: inline-grid;
+  place-items: center;
+  width: 22px;
+  height: 22px;
+  margin-left: auto;
+  padding: 0;
+  border: 2px solid var(--royal);
+  border-radius: 50%;
+  background: var(--paper);
+}
+.sa-label--mini .sa-more:hover:not(:disabled) {
+  background: var(--paper);
+}
+.sa-label--mini .sa-chev {
+  margin: 1px 0 0;
+}
+.sa-label--mini .sa-more[aria-expanded="true"] .sa-chev {
+  margin: 0 0 1px;
+}
+/* the whole label is the tap target for its details */
+.sa-more::after {
+  content: "";
+  position: absolute;
+  inset: -12px -2px -2px;
+  z-index: 2;
+  border-radius: 3px;
+}
+.sa-more:focus-visible {
+  outline: none;
+  box-shadow: none;
+}
+.sa-more:focus-visible::after {
+  outline: 3px solid var(--ink);
+  outline-offset: 2px;
+  box-shadow: 0 0 0 2px var(--paper);
+}
+.sa-barcode {
+  width: 44px;
+  height: 14px;
+  flex: none;
+  background: repeating-linear-gradient(
+    90deg,
+    var(--ink) 0 2px,
+    transparent 2px 4px,
+    var(--ink) 4px 5px,
+    transparent 5px 7px,
+    var(--ink) 7px 10px,
+    transparent 10px 11px,
+    var(--ink) 11px 12px,
+    transparent 12px 15px
+  );
+  opacity: 0.8;
+}
+.sa-label.is-open {
+  outline: 3px solid var(--royal);
+  outline-offset: 3px;
+}
+/* wide labels (full labels on computers, double-width compact labels): the
+   price sits beside the ticker; a full label's stamp sits where its barcode was */
+@container sa-slot (min-width: 190px) {
+  .sa-label--full .sa-stamp {
+    position: absolute;
+    right: 9px;
+    bottom: 7px;
+  }
+  .sa-label--full.sa-label--closed .sa-barcode {
+    visibility: hidden;
+  }
+}
+/* a double-width full label with a chip: words on the left, share, value and
+   held on the right, so its row does not grow */
+@container sa-slot (min-width: 360px) {
+  .sa-label--full.sa-label--chip {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    grid-template-rows: 1fr auto;
+    column-gap: 18px;
+  }
+  .sa-label--chip .sa-main,
+  .sa-label--chip .sa-figs {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+    min-width: 0;
+  }
+  .sa-label--chip .sa-figs .sa-share {
+    margin-top: 2px;
+  }
+  .sa-label--chip .sa-foot {
+    grid-column: 1 / -1;
+  }
+}
+/* narrow labels: price under the ticker, a clock instead of "price updated" */
+@container sa-slot (max-width: 189.98px) {
+  .sa-price {
+    flex-basis: 100%;
+  }
+  .sa-age {
+    text-align: start;
+  }
+  .sa-wide {
+    display: none;
+  }
+  .sa-narrow {
+    display: inline;
+  }
+  .sa-clock {
+    display: inline-block;
+  }
+  .sa-upd {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+  }
+  .sa-pct {
+    padding: 3px 5px 2px;
+    font-size: 18px;
+  }
+}
+/* the narrowest compact labels (3 a row on phones): the time alone, no clock */
+@container sa-slot (max-width: 117.98px) {
+  .sa-age:not(.is-stale) .sa-clock {
+    display: none;
+  }
+}
+/* Details drawer: opens under the shelf row of the tapped label */
+.sa-drawer {
+  position: relative;
+  grid-column: 1 / -1;
+  margin: 2px 0 4px;
+  padding: 12px 16px 6px;
+  background: var(--paper);
+  border: 3px solid var(--royal);
+  box-shadow: 0 4px 0 rgba(20, 44, 84, 0.25);
+}
+.sa-drawer::before {
+  content: "";
+  position: absolute;
+  top: -15px;
+  left: calc(
+    (var(--sa-at) * 2 + 1) * 100% / (2 * var(--sa-cols)) +
+      (var(--sa-at) * 2 - var(--sa-cols) + 1) * var(--sa-gap) / (2 * var(--sa-cols)) - 12px
+  );
+  border: 12px solid transparent;
+  border-top: 0;
+  border-bottom: 12px solid var(--royal);
+}
+.sa-drawer-top {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+}
+.sa-drawer h5 {
+  margin: 0;
+  font: 24px/1.15 Flyer, Impact, sans-serif;
+  letter-spacing: 0.01em;
+  text-transform: uppercase;
+}
+.sa-drawer-status {
+  margin: 8px 0 0;
+  padding: 8px 10px;
+  background: var(--warning);
+  border-left: 4px solid var(--error);
+  font-size: 14px;
+}
+.sa-drawer dl {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+  gap: 0 24px;
+  margin: 4px 0 0;
+}
+.sa-drawer .sa-addrs {
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 340px), 1fr));
+  margin: 0 0 4px;
+}
+.sa-drawer .sa-addrs > div {
+  border-bottom: 0;
+}
+.sa-drawer dl > div {
+  display: block;
+  padding: 8px 0;
+  border-bottom: 1px solid #c2ccdc;
+}
+.sa-drawer dt {
+  font-size: 14px;
+  color: var(--sa-muted);
+}
+.sa-drawer dd {
+  max-width: none;
+  margin: 2px 0 0;
+  text-align: left;
+}
+.sa-drawer .sa-addrs dd {
+  font-weight: 400;
+}
+.sa-drawer .address[href] {
+  padding-block: 6px;
+}
+.sa-none {
+  margin: 0;
+  padding: 18px 8px 4px;
+  font-weight: 700;
+}
+.sa-none button {
+  margin-left: 8px;
+}
+@media (max-width: 660px) {
+  .sa-section {
+    --sa-gap: 8px;
+    --sa-rail: 14px;
+    --sa-lip: 4px;
+  }
+  .sa-toolbar {
+    display: block;
+  }
+  .sa-filters {
+    display: grid;
+    grid-template-columns: repeat(4, minmax(0, 1fr));
+    gap: 6px;
+  }
+  .sa-filters button {
+    flex-direction: column;
+    justify-content: center;
+    gap: 0;
+    padding: 3px 2px;
+    font-size: 14px;
+    line-height: 1.15;
+  }
+  .sa-count {
+    font-size: 20px;
+    line-height: 1;
+    background: none !important;
+    color: inherit;
+  }
+  .sa-search {
+    margin-top: 10px;
+    font-size: 14px;
+  }
+  .sa-unit {
+    --sa-post: 4px;
+    border-width: 2px;
+    padding-bottom: 12px;
+    box-shadow:
+      inset var(--sa-post) 0 0 var(--royal),
+      inset calc(-1 * var(--sa-post)) 0 0 var(--royal),
+      inset 0 -8px 0 var(--ink);
+  }
+  .sa-signrow {
+    padding-top: 14px;
+  }
+  .sa-sign {
+    font-size: 18px;
+  }
+  .sa-n {
+    font-size: 20px;
+  }
+  .sa-shelves {
+    row-gap: 12px;
+    padding-top: 12px;
+  }
+  .sa-label {
+    margin: 0;
+    padding: 9px 7px 0;
+  }
+  .sa-label--mini {
+    padding: 9px 7px 6px;
+  }
+  .sa-drawer {
+    padding: 10px 12px 4px;
+  }
+  .sa-drawer h5 {
+    font-size: 21px;
+  }
+  .sa-drawer dl {
+    grid-template-columns: repeat(auto-fit, minmax(112px, 1fr));
+    gap: 0 14px;
+  }
+}
+/* phones: the shelf unit uses the panel's side padding, 3 compact labels a row */
+@media (max-width: 539px) {
+  .sa-section {
+    --sa-gap: 6px;
+  }
+  .sa-unit {
+    margin-inline: -10px;
+  }
+  .sa-shelves {
+    padding-inline: 3px;
+  }
+  .sa-shelves--mini {
+    grid-template-columns: repeat(auto-fill, minmax(96px, 1fr));
+  }
+  .sa-label {
+    padding: 9px 6px 0;
+  }
+  .sa-label--mini {
+    padding: 8px 5px 5px;
+  }
+  .sa-label h4 {
+    font-size: 21px;
+  }
+  .sa-label--mini h4 {
+    font-size: 20px;
+  }
+  .sa-price {
+    font-size: 26px;
+  }
+  .sa-label--mini .sa-price {
+    font-size: 24px;
+  }
+  .sa-signrow {
+    gap: 4px 10px;
+    padding: 12px 5px 0;
+  }
+  .sa-sign {
+    gap: 6px;
+    padding: 3px 4px 2px 8px;
+    font-size: 17px;
+    letter-spacing: 0.02em;
+  }
+  .sa-shelves {
+    padding-top: 11px;
+  }
+  .sa-label--full {
+    gap: 1px;
+  }
+  .sa-share {
+    margin: 6px 0 2px;
+  }
+  .sa-foot {
+    padding: 3px 0 4px;
+  }
+}
+/* Motion: one restocking swing per shelf row (Vault.tsx, Web Animations, skipped
+   under reduced motion) and a small lift; nothing moves under reduced motion */
+@media (prefers-reduced-motion: no-preference) {
+  .sa-label {
+    transition:
+      transform 0.15s ease-out,
+      box-shadow 0.15s ease-out;
+  }
+  .sa-label:active,
+  .sa-label.is-open {
+    transform: translateY(-4px);
+  }
+  .sa-label:has(.sa-more:focus-visible) {
+    transform: translateY(-4px);
+  }
+  .sa-drawer {
+    animation: sa-open 160ms ease-out;
+  }
+}
+@media (prefers-reduced-motion: no-preference) and (hover: hover) {
+  .sa-label:hover {
+    transform: translateY(-4px);
+    box-shadow: 0 7px 0 rgba(20, 44, 84, 0.25);
+  }
+}
+@keyframes sa-open {
+  from {
+    opacity: 0;
+    transform: translateY(-6px);
+  }
+}
+@media (forced-colors: active) {
+  .sa-label,
+  .sa-drawer,
+  .sa-pct,
+  .sa-sign,
+  .sa-stamp,
+  .sa-chip {
+    border: 2px solid CanvasText;
+  }
+  .sa-slot::before,
+  .sa-bar i,
+  .sa-mark {
+    background: CanvasText;
+  }
 }
diff --git a/web/src/wallet.tsx b/web/src/wallet.tsx
index 946fa06..b257e4e 100644
--- a/web/src/wallet.tsx
+++ b/web/src/wallet.tsx
@@ -27,6 +27,14 @@ declare global {
   }
 }
 export type ActionProgress = { message: string; hash?: Hex; detail?: string };
+// A send whose nonce was used by a cancel or a different transaction in the
+// wallet: the receipt belongs to that other transaction, so nothing of this
+// action happened.
+export class TransactionCancelled extends InputError {}
+// Shown when a saved listing transaction that was reported pending is mined or
+// replaced.
+export const LISTING_FINISHED =
+  "The earlier transaction is finished (confirmed or replaced). Press Resume listing.";
 type PendingTx = {
   hash: Hex;
   account: Address;
@@ -49,16 +57,34 @@ export function useWallet(refresh: () => Promise<Snapshot>) {
   const [connecting, setConnecting] = useState(false);
   const [progress, setProgress] = useState<Record<string, ActionProgress>>({});
   const pendingRef = useRef<PendingTx | undefined>(savedPending());
+  // True while a "still pending" listing message (or a receipt timeout, or a
+  // transaction saved before a reload) may be on screen.
+  const pendingShown = useRef(!!pendingRef.current);
   function report(key: string, value: ActionProgress) {
     setProgress((old) => ({ ...old, [key]: value }));
     setMessage(value.message);
   }
+  // Replace a status everywhere (action status and the top bar), link included.
+  function notice(key: string, message: string) {
+    setProgress((old) => ({ ...old, [key]: { message } }));
+    setMessage(message);
+    setHash(undefined);
+  }
+  // A saved transaction was found mined or replaced: clear the stale pending
+  // text and its link and say so. Returns true.
+  function finished() {
+    if (pendingShown.current) notice("listing", LISTING_FINISHED);
+    pendingShown.current = false;
+    return true;
+  }
   function fail(key: string, message: string) {
     setProgress((old) => ({ ...old, [key]: { ...old[key], message } }));
   }
-  async function listingPending(waitForReceipt = false) {
-    if (!account) return;
+  // Resolves true when a saved transaction was found mined or replaced.
+  async function listingPending(waitForReceipt = false): Promise<boolean> {
+    if (!account) return false;
     const pending = pendingRef.current;
+    let done = false;
     if (pending && same(pending.account, account)) {
       try {
         const receipt = await client.getTransactionReceipt({
@@ -67,6 +93,7 @@ export function useWallet(refresh: () => Promise<Snapshot>) {
         if (receipt) {
           pendingRef.current = undefined;
           sessionStorage.removeItem(pendingKey);
+          done = finished();
         }
       } catch {
         // A mined Speed up/Cancel consumes the original transaction's nonce.
@@ -81,8 +108,10 @@ export function useWallet(refresh: () => Promise<Snapshot>) {
           pendingRef.current = undefined;
           sessionStorage.removeItem(pendingKey);
           setHash(undefined);
+          done = finished();
         } else if (!waitForReceipt) {
           setHash(pending.hash);
+          pendingShown.current = true;
           report("listing", {
             message:
               "A transaction is still pending. Wait for its receipt before resuming listing.",
@@ -102,6 +131,7 @@ export function useWallet(refresh: () => Promise<Snapshot>) {
       throw new InputError(
         "A transaction is still pending. Wait until the owner's pending and latest nonce match, then resume listing.",
       );
+    return done;
   }
   async function waitPending() {
     // Reconcile a replacement before waiting on a hash that cannot get a receipt.
@@ -269,10 +299,16 @@ export function useWallet(refresh: () => Promise<Snapshot>) {
         message: `${label}: Submitted. Waiting for confirmation…`,
         hash: tx,
       });
+      // A Speed up (repriced) still runs this call; a cancel or a different
+      // transaction on the same nonce (cancelled/replaced) does not.
+      let replaced: string | undefined;
       const receipt = await client.waitForTransactionReceipt({
         hash: tx,
         timeout: 180_000,
         pollingInterval: 3000,
+        onReplaced: (r) => {
+          replaced = r.reason;
+        },
       });
       settled = true;
       pendingRef.current = undefined;
@@ -281,6 +317,12 @@ export function useWallet(refresh: () => Promise<Snapshot>) {
       } catch {
         /* storage unavailable */
       }
+      if (replaced === "cancelled" || replaced === "replaced")
+        throw new TransactionCancelled(
+          replaced === "cancelled"
+            ? "The transaction was cancelled in the wallet; it did not run. Refresh the vault before retrying."
+            : "The transaction was replaced in the wallet by a different one; it did not run. Refresh the vault before retrying.",
+        );
       if (receipt.status !== "success")
         throw new Error(
           "The transaction reverted. Refresh the data before retrying.",
@@ -307,7 +349,7 @@ export function useWallet(refresh: () => Promise<Snapshot>) {
             .find((l) => l?.eventName === "Proposed");
           if (!event) throw new Error("Proposal event unreadable");
           const { id, executableAt, expiresAt } = event.args as any;
-          detail = `Proposal ${id}; executable from ${date(executableAt)} until ${date(expiresAt)} (exclusive), from the Proposed event.`;
+          detail = `Proposal ${id}; executable from ${date(executableAt)} until just before ${date(expiresAt, "end")}, from the Proposed event.`;
         }
         if (["redeem", "claim"].includes(s.functionName)) {
           const creditor =
@@ -338,11 +380,18 @@ export function useWallet(refresh: () => Promise<Snapshot>) {
       report(key, { message: `${label}: Confirmed.`, hash: tx, detail });
       return receipt;
     } catch (e) {
+      if (e instanceof TransactionCancelled) {
+        // No link: the submitted transaction never ran.
+        notice(key, e.message);
+        throw e;
+      }
       const message = await explainAction(e, s);
       const status =
         sent && !settled
           ? "Receipt timed out or unreadable. This transaction may still be pending. Wait for its receipt before retrying."
           : message;
+      if (sent && !settled && s.functionName === "listGenesis")
+        pendingShown.current = true;
       report(key, { message: status, hash: sent });
       throw new InputError(status);
     } finally {
@@ -356,6 +405,7 @@ export function useWallet(refresh: () => Promise<Snapshot>) {
     progress,
     report,
     fail,
+    notice,
     listingPending,
     waitPending,
     chainId,
diff --git a/web/validation/README.md b/web/validation/README.md
index 2cf0059..a8a563c 100644
--- a/web/validation/README.md
+++ b/web/validation/README.md
@@ -4,7 +4,7 @@ Run from `web/` after the production build. `../artifacts/validation.md` is the
 
 - `npm run validate`: ABI, decimal arithmetic, reason/error wording, inputs, encodings and live read-only verification.
 - `node scripts/check-preservation.mjs`: protected files, current integration invariants, obsolete integration scan and file budget. This supersedes the obsolete call-expression equality check.
-- `npx tsx scripts/run-browser.mjs`: bounded isolated Anvil fork plus Playwright browser. It creates only disposable fork fixtures, runs actual production UI sends against the original vault bytecode and records screenshots and decoded arguments. Requires an empty, unfinalized fork state. `BASKET_RPC`, `BASKET_FORK_BLOCK`, `SOLC` and `PLAYWRIGHT_MODULE` can select local verification tools/endpoints.
+- `npx tsx scripts/run-browser.mjs`: bounded isolated Anvil fork plus Playwright browser. It creates only disposable fork fixtures, runs actual production UI sends against the original vault bytecode and records screenshots and decoded arguments. Requires an empty, unfinalized fork state, so it forks block 83,874,298 by default (vault 6 empty and not finalized, same code as today; the live vault is listed and may be finalized). It reads that block from the archive RPC `https://robinhood.api.pocket.network` through its own read-only proxy, which passes read methods only and retries busy reads. `BASKET_FORK_BLOCK` and `BASKET_RPC` override the block and the archive RPC; `SOLC` and `PLAYWRIGHT_MODULE` select local tools.
 - `node scripts/inspect-export.mjs`: subpath export, all pages at four widths, fonts, overflow, keyboard and reduced-motion checks.
 - `node scripts/check-guards.mjs`: injected account/chain/code/simulation failures; no transaction broadcast.
 
@@ -14,11 +14,11 @@ Playwright, Chromium and WebKit are external verification tools, not runtime dep
 
 Design review uses the pinned Better Interface guide (Jakub Krehel, MIT) and Impeccable documentation method (Paul Bakaus, Apache-2.0). Both copyright notices and license texts are in `DESIGN-GUIDANCE-LICENSE`; review coverage and source locations are in the artifact report.
 
-Additional checks: `npx tsx scripts/check-interface.ts` verifies line-numbered refusals, exact balances and pool/setting arithmetic; `node scripts/check-motion.mjs` checks scrolling geometry and repeated-strip coverage in Linux Chromium at DPR 1/1.25/1.5. This is not native Windows display-scaling validation. The fork walkthrough covers 25 listing rows, decline/resume, an accelerated receipt timeout, pending transaction and reload, plus every transaction control. Screenshots wait for read/layout stability and use JPEG quality 40 to meet the submission budget.
+Additional checks: `npx tsx scripts/check-interface.ts` verifies line-numbered refusals, exact balances and pool/setting arithmetic; `node scripts/check-motion.mjs` checks scrolling geometry, repeated-strip coverage and the Stock shelves' one-time swing (one iteration within 2 s, nothing moving afterwards or on scrolling back) in Linux Chromium at DPR 1/1.25/1.5. This is not native Windows display-scaling validation. The fork walkthrough covers 25 listing rows, decline/resume, an accelerated receipt timeout, pending transaction and reload, plus every transaction control. Screenshots wait for read/layout stability and use JPEG quality 36 (40 before the v9 update) to meet the submission budget.
 
-- `node scripts/check-art.mjs`: manifest SHA-256/size inventory in public and dist, square full shelf rows, exact speech and contained picture geometry, Chromium/WebKit overflow checks, and both slogan loops at 375/2560px. Extra review captures stay in disposable scratch.
+- `node scripts/check-art.mjs`: manifest SHA-256/size inventory in public and dist, square full shelf rows (the Stock shelves unit on Vault shows its first food row only), the Stock shelves (one shelf-edge label per listed stock with ticker, price, status and Details, inside the shelf unit, labels, filters and search at least 44px, no old stock cards, still under reduced motion), the three title characters (exact lines, picture inside the panel with her head above it, bubble clear of face, hands and held items, tail at the mouth, title text centred beside her and clear of her, at 12 widths and in a 320-2560px sweep), no tagline anywhere and no Vault eyebrow while the other pages keep theirs, the footer layout, Chromium/WebKit overflow checks, and the slogan strip rule at 23 widths from 320 to 5,760px: each half shows the fewest whole 720px lines that cover the window, no blank space at eight loop positions, the gap at every join and at the seam equals the word gap, the track is at most two screens plus two lines wide, no `will-change`, k × 45 s per loop (k × 11.25 s at 660px and below) and still under reduced motion. Extra review captures stay in disposable scratch.
 - `node scripts/check-fixes.mjs`: actual wallet hook and Claims component with deterministic missing receipts, advanced/non-advanced nonces, forgotten hashes, legacy nonce lookup, queued transactions, Retry vault and complete/incomplete owed states.
 
 The 2026-10-09 pass uses only temporary external browser/compiler tooling; no tool packages, browser archives or system libraries are delivered. The three-stock fork deposit uses FIG/OAT/S01, leaving PEA empty for the original retirement/removal walkthrough. No check was removed when extending the deposit fixture.
 
-`node scripts/check-calldata.mjs` compares guarded call expressions and protected integration files with task-start Git source. `node scripts/check-bundle.mjs` includes tracked lib files and all delivered assets in the 8 MiB budget. Set `BASKET_SOURCE_ROOT` to the repository when running either from a disposable copy. `BASKET_BASELINE_DIST=/absolute/previous/dist node scripts/check-visibility.mjs` compares the six phone routes with no wallet and a read-only owner connection.
+`node scripts/check-calldata.mjs` compares the source with task-start Git source (HEAD): frozen files byte for byte; main and Scenery once their one documented edit is put back; in every source file the vault/token/feed/read calls, argument parsers, encoders and sends equal HEAD apart from the listed fix changes; every wallet send or raw provider request equals HEAD with no exception, and Vault, Scenery, main and Docs have none; Vault.tsx makes no read, check or send call, and its controls (the Stock shelves' included) and the shelves' handlers equal their pinned text; the changed Owner actions and the governance argument builders equal HEAD once their listed pieces are put back and the new refusal helpers equal their pinned text; HEAD's and the current encoders give the same calldata on the same inputs (deadline under fixed clocks), with only the listed new refusals. `node scripts/check-bundle.mjs` includes tracked lib files and all delivered assets in the 8 MiB budget and allows only the v9 file scope (in `web/public` only `favicon.svg`, which must be the chosen icon in `web/public` and `dist`). Set `BASKET_SOURCE_ROOT` to the repository when running either from a disposable copy. `BASKET_BASELINE_DIST=/absolute/previous/dist node scripts/check-visibility.mjs` compares the six phone routes with no wallet and a read-only owner connection.