diff --git a/docs/PRODUCT-ROADMAP.md b/docs/PRODUCT-ROADMAP.md
index e0a1948a..a95edaf9 100644
--- a/docs/PRODUCT-ROADMAP.md
+++ b/docs/PRODUCT-ROADMAP.md
@@ -52,6 +52,7 @@ instead (see subsystem F).
 | M | Windows around the tools: Overview, Guests, Money, Checklist, Sync & history, palette | E, L | ⬜ planned — master plan, phase 2 |
 | N | Day-of binder and vendor links | E, J | ⬜ planned — master plan, phase 3 |
 | O | One live document: tools stop keeping copies; real-time sync | — | ⬜ planned — master plan, phase 4 |
+| P | The toolbox, and travel, ceremony, boxes and bar | L, O | ✅ **built** — [spec](superpowers/specs/2026-09-29-toolbox-and-new-tools-design.md), plans for [the toolbox](superpowers/plans/2026-09-29-toolbox.md), [travel and calendars](superpowers/plans/2026-09-29-timeline-travel-and-calendars.md), [the cast and Ceremony](superpowers/plans/2026-09-29-cast-and-ceremony.md), [Boxes](superpowers/plans/2026-09-29-boxes.md) and [the Bar](superpowers/plans/2026-09-29-bar.md), 2026-09-29; the proposals joining tools to each other wait on the maintainer |
 
 ## Decisions log
 
diff --git a/docs/superpowers/plans/2026-09-29-bar.md b/docs/superpowers/plans/2026-09-29-bar.md
new file mode 100644
index 00000000..6ce37f0a
--- /dev/null
+++ b/docs/superpowers/plans/2026-09-29-bar.md
@@ -0,0 +1,146 @@
+# Bar Implementation Plan
+
+**Goal:** A couple buying their own drinks — a marquee, a barn, a venue that
+charges corkage — learn how much of each to buy, in the units a UK shop sells
+it in, and what it will roughly cost. Every figure is on screen, can be
+changed, and can be put back.
+
+**Architecture:** A slice of its own, `bar`, holding only what the couple
+chose: the kind of bar, the crowd, and each figure they changed from its
+default. Nothing the calculator works out is stored: who is coming is read
+live from the guest list, and the amounts are worked out from that and the
+figures every time, so a guest saying no changes the wine. Merged as one part,
+as Ceremony is. Built as Boxes was: pure sums, a page that reads and writes the
+wedding on its one history, a tool off until added.
+
+**Tech Stack:** TypeScript, the suite's kit, pdf-lib for the shopping list.
+**No new dependencies.**
+
+**Spec:** [Phase 4 of the toolbox spec](../specs/2026-09-29-toolbox-and-new-tools-design.md#phase-4--bar)
+
+## The sum
+
+1. **Who.** The people coming are the guests who have not said no, or a
+   number the couple types instead (and the page says so while it is typed).
+   Evening-only guests are added for the evening. A share of everyone is not
+   drinking alcohol — children, drivers, anyone who does not — and drinks soft
+   drinks instead, at the same rate.
+2. **Four parts of the day**, each drinks per head of those drinking:
+   the drinks reception (hours × drinks an hour), the toast (glasses),
+   the meal (glasses of wine), the evening bar (hours × drinks an hour).
+   A part the couple is not buying for — a venue's paying evening bar — is
+   set to nothing.
+3. **What is poured in each part.** The toast is fizz and the meal is wine,
+   split red and white. The reception and the evening pour a mix — fizz,
+   wine, beer, spirits — as shares, set by the kind of bar and each one
+   changeable.
+4. **A lighter or heavier crowd** takes a fifth off or puts a fifth on, except
+   the toast, which is one glass whoever is raising it.
+5. **Into what a shop sells**: glasses to 75cl bottles by the glass size, beer
+   and cider one bottle or can a drink in cases of 24, spirits to 70cl
+   bottles by the measure, mixers and soft drinks to litres, ice to kilos.
+6. **Less what they already have**, then rounded up to whole cases when they
+   are buying on sale or return (fizz and wine in sixes, beer in 24s).
+7. **The spend**: each line priced by the couple, per bottle, case, litre or
+   kilo; the lines with no price are left out of the estimate and it says so.
+
+## The kinds of bar
+
+| Kind | Reception | Evening |
+|---|---|---|
+| Full bar | fizz 70%, beer 30% | beer 40%, wine 40%, spirits 20% |
+| Beer and wine | fizz 70%, beer 30% | beer 50%, wine 50% |
+| Signature cocktails, beer and wine | cocktails 70%, beer 30% | beer 40%, wine 40%, cocktails 20% |
+| No and low | as beer and wine, every line alcohol-free, no spirits | |
+
+A cocktail is bought as a spirit measure and a mixer. Choosing a kind puts the
+mix back to that kind's; it is one step on the history.
+
+## The defaults
+
+**Agreed by the maintainer, 2026-09-29, before building**, as they stand:
+
+| Figure | Default | Why |
+|---|---|---|
+| Not drinking alcohol | 20% of guests | Roughly one UK adult in five does not drink, and children and drivers are in the count. |
+| Evening-only guests | 0 | Typed by the couple. |
+| Drinks reception | 2 hours × 1.5 an hour = 3 each | UK guidance: two in the first hour, one an hour after. |
+| Toast | 1 glass | Universal. |
+| The meal | 2 glasses of wine (175ml) — just under half a bottle | "Half a bottle a head" is the UK rule of thumb. |
+| Evening bar | 4 hours × 1 an hour | "One drink an hour" after the first. |
+| Red of the wine | 50% | |
+| Fizz glass | 125ml — 6 to a bottle | |
+| Wine glass | 175ml | The UK's standard medium glass. |
+| Spirit measure | 25ml — 28 to a 70cl bottle | The UK's single measure. |
+| Mixer | 150ml a spirit or cocktail | |
+| Soft drink | 250ml | |
+| Ice | 1kg a person | UK ice suppliers: 1kg a head for drinks, 1.5kg to chill bottles too. |
+| Crowd | Usual; lighter −20%, heavier +20% | |
+| Whole cases | On | Sale or return costs nothing to round up. |
+| Where bought | Fizz and wine: wine merchant. Beer and spirits: cash and carry. Mixers, soft drinks, ice: supermarket. | |
+| Prices | None until typed | Prices date quickly and differ by shop. |
+
+For 100 coming with the defaults: 42 bottles of fizz, 36 white and 36 red,
+9 cases of beer, 3 bottles of spirits, 10 litres of mixers, 50 of soft drinks,
+100kg of ice.
+
+## 4a — The sum and the page
+
+- [x] `bar` joins the contract's slices: `{ kind, crowd, people, figures,
+  mix, lines, wholeCases }`, only what the couple chose. Merged as one part.
+- [x] Pure sums (`lib/bar/sum.ts`): who, the parts, the lines, the spend;
+  every default in one table (`lib/bar/defaults.ts`).
+- [x] Pure actions: change a figure, put it back, choose a kind (resets the
+  mix), a line's price, what they have, where it is bought.
+- [x] The page, `/bar`: the figures on the left, what to buy on the right.
+  Each changed figure shows its default and puts it back. Registered as a
+  tool, off until added. The example wedding has a bar.
+- [x] The front page's area: what is bought for how many, and the estimate.
+
+## 4b — On paper
+
+- [x] The shopping list, grouped by where each thing is bought, as a PDF and
+  as CSV. It joins the wedding pack.
+
+## 4c — Planners
+
+- [x] The library keeps bar settings: the kind, the crowd, the figures, the
+  mix, the prices and where each is bought — no guest count and nothing a
+  couple already has. Using it replaces the wedding's settings. A migration
+  widens the database's kinds, proved against PGlite.
+
+## Not in this phase
+
+The proposals in the spec that join Bar to other tools — hours from the
+Timeline's blocks, the spend in Money, "buy the drinks" on the Checklist,
+crates as Boxes — each wait for the maintainer to accept them.
+
+## Status
+
+**Complete — 4a, 4b and 4c, 2026-09-29.** 1,865 suite tests and 116 in the
+contract package, typecheck and build clean, all 109 Playwright tests green.
+No new dependencies. **One migration**, `20260929000006_library_bar`, widening
+the library's kinds again: apply it, with Phases 2 and 3's, before deploying.
+
+**What executing it found.**
+
+- The guest list does not say who is invited for the evening only, which a UK
+  wedding's evening bar depends on, so evening-only guests are a figure of the
+  Bar's, typed, drinking in the evening and not before.
+- The amounts exist for every wedding with guests, whether or not it uses the
+  Bar, so the wedding pack prints the drinks only while the Bar is shown —
+  otherwise every pack would have gained a page nobody asked for.
+- A figure's field and a price's needed decimals the whole-number field did
+  not allow; it became one `NumberInput` with a step, used by Money, Boxes,
+  the Timeline's journeys and the Bar, rather than a second field.
+- Putting a figure back and changing it shared a label, and the history
+  folds same-labelled edits made within 700ms into one step, so undoing the
+  one undid both; putting back is its own step now.
+- The panel headings came before any heading of their level; the figures
+  have a heading of their own, as What to buy does.
+- The page, the shopping list and the CSV say "42 bottles, 7 cases of 6" from
+  one function, so they cannot disagree.
+- As built, where it differs from the spec: the toast is fizz and the meal
+  wine, with only the reception and the evening pouring a mix; a cocktail is
+  bought as a spirit measure and a mixer; prices start empty; and "no and
+  low" is a kind of bar, naming every drink alcohol-free.
diff --git a/docs/superpowers/plans/2026-09-29-boxes.md b/docs/superpowers/plans/2026-09-29-boxes.md
new file mode 100644
index 00000000..c1c5dc01
--- /dev/null
+++ b/docs/superpowers/plans/2026-09-29-boxes.md
@@ -0,0 +1,75 @@
+# Boxes Implementation Plan
+
+**Goal:** The couple pack for the day in boxes: what is in each, found in a
+moment ("where are my shoes?"), and each box tied to the part of the day it is
+needed for — "this box has my shoes in it and needs to be at the house for 9".
+
+**Architecture:** A slice of its own, `boxes`, merged box by box as guests and
+jobs are, since two people pack at once. A box's where and when are its
+block's — the location and the resolved start — read from the Timeline, never
+typed onto the box, so moving the block moves the box. Who takes it is people
+from the crew, named as Delegation names them. Built as Ceremony was: pure
+actions, a page that reads and writes the wedding on its one history, a tool
+off until added.
+
+**Tech Stack:** TypeScript, the suite's kit, pdf-lib for the labels and the
+list. **No new dependencies.**
+
+**Spec:** [Phase 3 of the toolbox spec](../specs/2026-09-29-toolbox-and-new-tools-design.md#phase-3--boxes)
+
+## 3a — The boxes
+
+- [x] `boxes` joins the contract's slices: `{ boxes: Box[] }`, a box being a
+  number, a name, items (a label, how many, packed or not), the block it is
+  needed for or none, who takes it, and notes. Merged per box.
+- [x] Pure actions: add, change, remove a box; add, change, tick, remove and
+  move an item to another box. Numbers go on from the highest.
+- [x] *Add the usual boxes*, UK first, matched by name so it never doubles up:
+  the rings and paperwork, getting ready, the day's odds and ends, overnight.
+- [x] Finding: one search over every box's items and names.
+- [x] Checks. What is left: a box needed for a block the day no longer has;
+  things still to pack in the last week. The page: a box nobody is taking, and
+  somebody taking it who has left the crew.
+- [x] The page, `/boxes`, and the front page's area. Registered as a tool, off
+  until added. The example wedding packs for its day.
+
+## 3b — On paper
+
+- [x] A label for each box, four to a sheet: the number large, the name, where
+  and by when, who is taking it, and what is in it.
+- [x] The packing list, every box and every item with a box to tick, as a PDF
+  and as CSV. The list joins the wedding pack.
+
+## 3c — Planners
+
+- [x] The library keeps a set of boxes: their names and what goes in each,
+  without who takes them or when they are needed. The database's kinds are
+  widened by a migration, proved against PGlite.
+
+## Status
+
+**Complete — 3a, 3b and 3c, 2026-09-29.** 1,840 suite tests and 113 in the
+contract package, typecheck and build clean, all 103 Playwright tests green.
+No new dependencies. **One migration**, `20260929000005_library_boxes`,
+widening the library's kinds again: apply it, with Phase 2's, before
+deploying.
+
+**What executing it found.**
+
+- A box's where and when are its block's, read through `dayPlaces` — the
+  timeline's blocks with their resolved starts — so nothing about a place or
+  a time is stored on a box, and a block moved moves every box needed at it.
+- What is left had a local `places` of its own (the room's space names), which
+  the new helper's first name shadowed; the compiler said so, and the helper
+  is `dayPlaces`.
+- "Nobody is taking it" is a problem only for a box with somewhere to be; the
+  honeymoon bag, not for the day, is the couple's own.
+- Delegation named a crew member who is a guest by the guest list, inline;
+  Boxes needed the same rule, so it is one `personName` both use.
+- The slice merges box by box, as guests and jobs do, proved by two people
+  ticking in two boxes and both ticks surviving the merge.
+- As built, where it differs from the spec: a thing moves to another box from
+  a menu on its row rather than by dragging — reachable from a keyboard, and
+  one way to do it; items have no notes of their own, the box has them; and a
+  library set of boxes adds what a wedding has none of by name, as the usual
+  boxes and the checklist do, rather than replacing its boxes.
diff --git a/docs/superpowers/plans/2026-09-29-cast-and-ceremony.md b/docs/superpowers/plans/2026-09-29-cast-and-ceremony.md
new file mode 100644
index 00000000..bf9d1301
--- /dev/null
+++ b/docs/superpowers/plans/2026-09-29-cast-and-ceremony.md
@@ -0,0 +1,90 @@
+# One Cast, and Ceremony Implementation Plan
+
+**Goal:** The people a wedding is built around — the couple, their parents
+and grandparents, their wedding parties, and roles of the couple's own
+devising — are recorded once and shared by Group shots and a new Ceremony tool,
+which plans the processional: who walks, in what order, how, and to what music.
+
+**Architecture:** The cast leaves the `shots` slice for a slice of its own,
+`cast`, since two tools now edit it and a tool writes only its own slice. It is
+moved by the load-time pass that already converts older shapes, and read from
+either place until then, so a document the server reads before any browser
+has loaded it still has its cast. Ceremony is built as Group shots was: a
+slice, `ceremony`; pure actions over it; a page that reads and writes the
+wedding directly, on its one history. A processional group's members are the
+same kinds a shot's are, resolved by the same code.
+
+**Tech Stack:** TypeScript, the suite's kit, pdf-lib for the page. **No new
+dependencies.**
+
+**Spec:** [Phase 2 of the toolbox spec](../specs/2026-09-29-toolbox-and-new-tools-design.md#phase-2--one-cast-and-ceremony)
+
+## 2a — One cast
+
+- [x] `cast` joins the contract's slices. `CastSlice { roles: Cast; customRoles }`.
+- [x] `readCast(doc)`: the `cast` slice, or — for a document not yet converted —
+  the cast and custom roles still inside `shots`, old role names included.
+  `Shots` keeps only its sections.
+- [x] The load-time pass writes the cast to its own slice and takes it out of
+  `shots`, silently, as it converts "bride" and "groom".
+- [x] Each partner's grandparents join the fixed roles, as a party role.
+- [x] Group shots reads and writes the cast there; "Who's who" edits `cast`.
+  Readiness, the front page, the prints and the validator follow.
+
+## 2b — Ceremony
+
+- [x] `ceremony` joins the contract's slices: `{ processional: WalkGroup[] }`,
+  a group being a label, members (the shot's member kinds), how they walk
+  (alone, in pairs, in threes), which side they go to, and a cue — the music,
+  and when it changes.
+- [x] Pure actions: add, change, move, remove a group; add and remove members.
+- [x] *Suggest an order* from the cast: the officiant, grandparents, parents,
+  the wedding parties, then the couple — a starting point, every part of it
+  editable, and nothing in it assuming who walks with whom.
+- [x] Checks: somebody walking who has declined; a role nobody has been cast
+  in. What is left and the front page say so, when Ceremony is shown.
+- [x] The page, `/ceremony`: the order on the left, the picked group on the
+  right, with the member picker Group shots uses (moved to be shared).
+  Registered as a tool, off until added.
+- [x] The example wedding gets a processional, since it shows every tool.
+- Not done, on purpose: a tour chapter. The tour is held to under thirty steps
+  and has twenty-nine; Ceremony's list carries the anchor one would point at
+  (`ceremony.order`) for when a chapter elsewhere is trimmed.
+- The resolver both tools use moved to `lib/cast/resolve` as `resolveMembers`,
+  taking any group with a label and members; its words no longer say "shot".
+
+## 2c — Paper, and planners
+
+- [x] One page for the officiant and whoever runs the day, and the order as
+  plain text to paste into an email. The page joins the wedding pack.
+- [x] The library keeps a processional: its groups, roles and cues, with no
+  guest named.
+
+## Status
+
+**Complete — 2a, 2b and 2c, 2026-09-29.** 1,816 suite tests and 110 in the
+contract package, typecheck and build clean, all 96 Playwright tests green.
+No new dependencies. **One migration**, `20260929000004_library_processional`,
+widening the library's kinds: apply it before deploying, as every migration.
+
+**What executing it found.**
+
+- The cast is read from either place, not only after the load pass has
+  moved it, because the planner's Weddings page runs What is left on the
+  server over stored documents nobody has opened since.
+- After parsing, the contract fills an absent slice with `{}`, so "this
+  wedding has its own cast" is decided by what the slice holds, not by its
+  being there.
+- Group shots' resolver was already the right shape for a processional — a
+  label and members — so it moved to `lib/cast/resolve` rather than being
+  copied; "Who's in it" became one `MemberPicker`; Money's nullable number
+  had already gone to the kit in Phase 1, and the guest picker went to
+  `components/cast`.
+- The processional's page and its email text are made from one list of rows,
+  so they cannot disagree.
+- The library's kinds are fixed in the database as well as in the code; the
+  migration test proves a processional is kept and an unknown kind still is
+  not.
+- The officiant is words ("The officiant", "The registrar") rather than a
+  crew member: nothing yet needs the link, and words were already a member
+  kind.
diff --git a/docs/superpowers/plans/2026-09-29-timeline-travel-and-calendars.md b/docs/superpowers/plans/2026-09-29-timeline-travel-and-calendars.md
new file mode 100644
index 00000000..e79d2eeb
--- /dev/null
+++ b/docs/superpowers/plans/2026-09-29-timeline-travel-and-calendars.md
@@ -0,0 +1,99 @@
+# Timeline: Travel and Calendars Implementation Plan
+
+**Goal:** The couple types how long it takes to get between two places, and
+the Timeline says when somebody is due somewhere before they could get there.
+The day, or one supplier's part of it, downloads as a calendar file.
+
+**Architecture:** One new field on Cadence's own document, `travel`, beside
+`tagDetails`. One walk over the resolved day finds every *move* — a tag at one
+place, then its next block somewhere else — and both the new advisory and the
+new panel read it, so what is checked and what is listed cannot disagree. The
+calendar is written in the browser from the resolved day, as the PDFs are.
+
+**Tech Stack:** TypeScript, Cadence's core and store, the suite's field kit.
+**No new dependencies.**
+
+**Spec:** [Phase 1 of the toolbox spec](../specs/2026-09-29-toolbox-and-new-tools-design.md#phase-1--timeline-travel-between-places-and-calendars)
+
+## Decided while planning, from the code
+
+- **Who moves is a tag, not a lane.** The spec said "a lane or a tag". The
+  example wedding says otherwise: its *Suppliers* lane holds the florist, the
+  caterer and the band, and *Transport* holds the cars and the guest coach —
+  a lane is a kind of activity, not a party, and checking a lane would say the
+  coach cannot get from where the cars were. Tags are already who is where:
+  the double-booking check reads them and nothing else, so the couple is only
+  ever caught being in two places at once if their blocks carry a tag. Travel
+  follows the same rule, and the panel says so: tag your own blocks — "couple"
+  — to have your own journeys checked.
+- **A block ends where the run sheet says it does**, `contentEndMin`, before
+  its contingency buffer. Hair and make-up printed as ending at 13:00, with the
+  first look at 13:05 and fifteen minutes away, is ten minutes short; measured
+  from after a buffer, it would read as an overlap and be skipped.
+- **Overlaps are not travel's to report.** A tag in two places at once is
+  already a double booking.
+- **Places match as the couple would**: trimmed, and regardless of case.
+- **A calendar is refused while the day has clashes**, for the reason the PDFs
+  are. The travel advisory never blocks anything.
+- **A calendar is on the wedding's date, in the venue's local time.** Found
+  while building task 4, so recorded here and in the spec: the timeline's own
+  date is a placeholder (20 June 2026) until the wedding has one, and its UTC
+  offset reads as British Summer Time until somebody sets it — the Day panel
+  shows that fallback as if it were chosen, and choosing it again changes
+  nothing. UTC built on that would put a winter wedding an hour out. Local
+  times with no zone are right whatever the offset.
+
+## Tasks
+
+- [x] **1. The field.** `Journey { between: [string, string]; minutes }` and
+  `TimelineDoc.travel`; `emptyDoc` gives `[]`; `readTimeline` coerces it,
+  dropping anything without two places and a positive time. Let the compiler
+  list every other place a `TimelineDoc` is built.
+- [x] **2. The walk and the check** (`core/schedule/travel.ts`): `moves`,
+  `journeyMinutes`, and the `no-travel-time` advisory, one per pair of blocks
+  naming every tag making that move. Joined into `conflicts()`, so the screen,
+  the warnings list and the announcer have it with no change of their own.
+- [x] **3. The panel.** *Travel*, after *Tags*: every pair of places the day
+  moves between, each with its minutes (blank: not checked), and journeys the
+  day no longer makes, to forget. One store action, `setJourney`, one undo
+  step.
+- [x] **4. Calendars** (`render/ics/calendar.ts`): RFC 5545 — CRLF, lines
+  folded at 75 octets without splitting a character, text escaped, times as
+  local times on the wedding's date (past midnight included), an end only
+  where there is a length, a UID stable per block and particular to the
+  wedding. The export bar gains the whole day or one tag, and *Download
+  calendar*.
+- [x] **5. End to end.** Type a journey, see the advisory; download a
+  calendar and read it.
+
+## Status
+
+**Complete — all 5 tasks, 2026-09-29.** 1,785 suite tests and 102 in the
+contract package, typecheck and build clean, all 90 Playwright tests green.
+No new dependencies.
+
+**What executing it found.**
+
+- The travel list and the advisory are one walk (`moves`), so the panel lists
+  exactly the journeys that are checked. On the example wedding it lists the
+  rooms the photographer and the caterer move between; a blank is right for
+  two rooms next door, and nothing is flagged until a time is typed.
+- Money already had the control the panel needed — a whole number or nothing,
+  written on leaving the field — as a private function. It moved to the kit as
+  `WholeNumberInput`, taking its styling from the caller, and both use it.
+- The compiler found the three places a `TimelineDoc` is built; a drift test
+  found the fourth, the sample day kept on disk beside `sampleDoc()`.
+- It also found a mistake in the previous commit: the font-engine guard used a
+  regular-expression flag the suite's target does not allow. The flag did
+  nothing — `[^;]` already crosses lines — and is gone; the guard was proved
+  again to fail with the old import put back.
+
+**Fixed after, at the maintainer's request: the clocks.** Reproduced first: a
+wedding with no offset, one block added in Timeline, and the event said 60 —
+`writeSlice` echoes the timeline's offset into `event` on every edit, and the
+timeline's offset was the BST fallback. The offset is now `number | null` in
+Cadence's day, the contract's published day and Delegation's reader, with no
+fallback anywhere; the Day panel offers *Not set*; `sunForDay` gives nothing
+without clocks, so no sunset or golden-hour advisory is worked out from a
+guess. The Binder's own rule — the phone's clock when the wedding has none —
+now gets to apply.
diff --git a/docs/superpowers/plans/2026-09-29-toolbox.md b/docs/superpowers/plans/2026-09-29-toolbox.md
new file mode 100644
index 00000000..fe42d6c5
--- /dev/null
+++ b/docs/superpowers/plans/2026-09-29-toolbox.md
@@ -0,0 +1,71 @@
+# The Toolbox Implementation Plan
+
+**Goal:** Let a wedding add and remove tools, the choice shared by everyone on
+it: the five on by default, each removable, and new tools added from a
+slide-over at the right edge.
+
+**Architecture:** One new slice, `tools` — `{ shown: string[] }` — in the
+contract, so it syncs and merges as a part of its own. The registry gains ids;
+one cached reader says which tools are shown; everything that listed the five
+lists the shown ones instead. Nothing a removed tool made is touched.
+
+**Tech Stack:** TypeScript, Next.js (suite), Zustand, the kit's `SlideOver`.
+**No new dependencies.**
+
+**Spec:** [docs/superpowers/specs/2026-09-29-toolbox-and-new-tools-design.md](../specs/2026-09-29-toolbox-and-new-tools-design.md)
+
+## Tasks
+
+- [x] **1. Contract.** `tools` joins `SLICE_NAMES` and `trousseauSchema` as a
+  `looseObject` slice, like `shots`. `envelope.test.ts` names it;
+  `preservation.test.ts` covers it through `SLICE_NAMES` unchanged.
+- [x] **2. Registry and reader.** `Tool` gains `id`. `lib/model/toolbox.ts`
+  has `shownTools(doc)` (cached per document; the five when nothing is stored;
+  unknown ids ignored) and `withTool(raw, id, shown)`, which writes the list
+  keeping ids this build does not know. Tests: default, order, unknown ids
+  kept on write, referential stability in `selectors.test.ts`.
+- [x] **3. Everything that listed the five.** The header's tabs; `overview`'s
+  areas; `readiness`'s items by where their fix is; the tour's walk; the
+  palette's pages. Tests on `overview`, `readiness` and `entries` with a tool
+  removed.
+- [x] **4. The panel.** `components/shell/ToolsPanel.tsx` on `SlideOver`,
+  opened by the header's **+** and by `?panel=tools`; Add and Remove, each one
+  labelled step on the history. `describe.ts` names the part for Sync &
+  history.
+- [x] **5. End to end.** Remove a tool: its tab goes, the change survives a
+  reload, undo brings it back. Axe on the open panel.
+
+## Status
+
+**Complete — all 5 tasks, 2026-09-29.** 1,752 suite tests and 102 in the
+contract package, typecheck and build clean, all 85 Playwright tests green —
+the 1024px header check included, with the **+** now in the row. No new
+dependencies.
+
+**What executing it found.** The compiler found nothing to change when the
+ninth slice arrived: nothing in the suite enumerated the slices except the
+merge, and the merge was already right about a slice absent from a stored
+document (no part, nothing invented). The work was entirely in the five places
+that listed the tools' work: the header and the palette, which read `TOOLS`;
+the front page's areas, What is left and the tour, each with its own list
+keyed by the same ids, which is why a tool's id is its address.
+
+Sync & history's open state and the new panel's were the same thirty lines, so
+the `?panel=` addressing moved into one factory, `addressablePanel`, which both
+use. The store refuses a write before the wedding is read, so the panel's
+buttons are off until then rather than silently doing nothing.
+
+**Second round, the same day** (spec decisions 16–19). Guests became the
+header's first tab and never leaves it; Money, Checklist and Binder became
+tools, off until added, and the menu under the wedding's name kept only
+Overview. `Tool` gained `defaultOn`. Four readiness tests and the fixture's
+front-page counts fell silent at once, which was the change working: a
+wedding without Money is not told about balances. They now show every tool
+explicitly, beside a test that pins the silence.
+
+Two things the gate found. The header test at 1024px, with the example
+wedding showing all eight tools, put four of Timeline's controls out of
+sight: measured, the tabs took 392px and left the controls 244 of 323. The
+controls now never shrink below what the tool put there, and the tabs scroll
+instead. And Binder, now a tool, has no header of its own to test, being a
+page for a phone.
diff --git a/docs/superpowers/specs/2026-09-28-expansion-master-plan.md b/docs/superpowers/specs/2026-09-28-expansion-master-plan.md
index 0d672caf..93aeaa2d 100644
--- a/docs/superpowers/specs/2026-09-28-expansion-master-plan.md
+++ b/docs/superpowers/specs/2026-09-28-expansion-master-plan.md
@@ -169,6 +169,12 @@ thing on a screen is the thing that needs a decision.
   controls (Timeline's zoom, Fit day and Present) do not fit and scroll out of
   sight inside it.
 
+  **Superseded 2026-09-29** by the
+  [toolbox spec](2026-09-29-toolbox-and-new-tools-design.md) (decisions 17–19):
+  Guests is the header's first tab, Money, Checklist and Binder are tools a
+  wedding adds from the toolbox, and only Overview stays under the wedding's
+  name.
+
 ## Signing in safely
 
 The rule: **nothing is replaced without a restorable copy, and nothing is
diff --git a/docs/superpowers/specs/2026-09-29-toolbox-and-new-tools-design.md b/docs/superpowers/specs/2026-09-29-toolbox-and-new-tools-design.md
new file mode 100644
index 00000000..1ee93171
--- /dev/null
+++ b/docs/superpowers/specs/2026-09-29-toolbox-and-new-tools-design.md
@@ -0,0 +1,265 @@
+# Trousseau — the toolbox, and four new pieces: travel, ceremony, boxes, bar
+
+Date: 2026-09-29
+Status: direction approved by the maintainer (answers recorded below). Phase 0
+is built with this spec; every later phase gets its own dated plan first.
+Scope: a way to add and remove tools, and four additions proposed by the
+"Modular Workspace" PRD — a processional planner, a bar calculator, a packing
+tool and a timeline collision checker.
+
+## Why
+
+The PRD proposed an opt-in workspace ("only the basics until you add more")
+and four modules. It was read against the suite before anything was designed,
+and a good part of it turned out to exist already.
+
+- **Reproduced** — shown in a test, a build or a real browser.
+- **Traced** — every caller read; not run.
+
+| # | Finding | How established |
+|---|---|---|
+| T1 | The PRD's "shared data bus", local-first storage and lazy loading all exist: one document with one owner per slice, IndexedDB with no account needed, and every tool behind `next/dynamic`, with dialogs mounted on first open. | Traced |
+| T2 | Module 4's "hard collision" is Timeline's `tag-double-booked`: the same supplier or party in two places at once. Buffers (`bufferMin`), slack and curfew are there too. **Missing:** travel time between locations, and a calendar file. There is no `.ics` anywhere. | Traced (`apps/cadence/core/schedule/conflicts.ts`); searched |
+| T3 | Module 3's assignment exists — Checklist tasks have `personIds`, `dueOn` and `status`, and people are linked to guests. Packing as the maintainer describes it does not: boxes, what is in each, and where and when each must be. | Traced |
+| T4 | Module 1's people exist: Group shots' cast (each partner, their parents, their wedding party, custom roles) mapped to guests. Grandparents, readers, ring bearer and flower party are not roles. | Traced (`lib/model/types.ts`) |
+| T5 | A top-level key the contract does not list survives a sync, but is assembled local-over-server with no conflict (`mergeCloudDocument.ts`, lines 107 and 163), so a partner's edit to it is silently lost on the next push. **Every new slice goes into `SLICE_NAMES`.** | Traced |
+| T6 | Every page loads the same 522 KB of gzipped JavaScript; a tool's own code adds 7 KB (Checklist) to 76 KB (Seating). 144 KB of the shared part is fontkit, reached statically from the store: `useTrousseauStore → documents/assets → portableAssets → plaque/syncAssets → plaque/sliceBridge → plaque/design → template/defaults → text/fit → text/measure`. The PRD's 100 KB per module is already met; the weight is underneath every module. | Reproduced — production build, each route loaded in Chromium and its JS summed; fontkit matched by its shaper tables against `node_modules/fontkit`; the chain traced by static imports |
+| T7 | Ctrl/⌘ K is the command palette. | Traced |
+
+## Decisions
+
+The maintainer's answers, 2026-09-29. Where the answer delegated the choice,
+the choice made is recorded with its reason.
+
+| # | Question | Decision |
+|---|---|---|
+| 1 | The PRD against the 2026-09-28 master plan | **The master plan wins.** The header, not a left sidebar; partners' names, not "bride"; one document, not micro-frontends. |
+| 2 | What is opt-in | **The five stay, on by default, and can be removed** by someone who really wants to. New tools are added from the toolbox. |
+| 3 | Where "which tools" lives | **In the wedding** — the partner and the planner see the same set. |
+| 4 | The toolbox | **A slide-over at the right edge, with Add.** No keyboard shortcut of its own. |
+| 5 | Public calculator pages for search | **Not intended.** Everything here is inside the planning app. |
+| 6 | Module 4 | **Timeline features.** Travel times are typed by the couple: no lookup, no new `connect-src`. |
+| 7 | Packing | **Its own tool**: boxes, what is in each, found easily, and each box tied to a part of the day — "this box has my shoes in it and needs to be at the house for 9". |
+| 8 | Processional and group shots | **They share their people.** |
+| 9 | Bar | **UK first, and every number adjustable.** |
+| 10 | Tools feeding each other | Delegated: **proposed below**, each for the maintainer to accept on its own. |
+| 11 | The wedding pack | **New printed pieces join it.** |
+| 12 | Planners | **New tools' work can be kept in the library.** |
+| 13 | Where the set is stored | Delegated: **a slice of its own, `tools`.** `event` is the wedding's who, where and when, and merges as one part: a list kept there would conflict whenever one partner changed the date while the other added a tool. A slice of its own merges on its own. |
+| 14 | What removing a tool does | Delegated: **hides it, deletes nothing.** Its tab, its area on the front page, its entries in What is left, its tour chapter and its palette entry go. Its work is kept, the removal is one undo step, and adding it back brings it back as it was. Its page still opens from its address. |
+| 15 | Where the shared people live | Delegated, for Phase 2: **a slice of their own, `cast`**, moved out of `shots` on load. A tool rewrites only its own slice; once two tools edit the cast, it is neither tool's. |
+
+The maintainer's second answers, the same day, after Phase 0 was built:
+
+| # | Question | Decision |
+|---|---|---|
+| 16 | Boxes as designed in Phase 3 | **Yes**: each box on a block of the day, its where and when the block's. |
+| 17 | Guests | **A tab of its own at the top**, first. Delegated: **never removable**, because every tool is built on the guest list, so it is not in the toolbox. |
+| 18 | Money, Checklist, Binder | **In the toolbox**, as tools. Delegated: **off until added** — the words were "in the tool box" against "a tab on the top", and a header of Guests and the five is the clean start the PRD asked for. This replaces the master plan's rule that the wedding's own pages sit under its name; only Overview is left there. |
+| 19 | Room in the header | Delegated: **the tool on screen keeps its controls; the tabs give way and scroll.** Measured at 1024px with every tool added: the tabs took 392px and left Timeline's controls 244 of the 323 they need. Denser tabs would have bought about 90px, enough today and not once Phase 1–4 add tools. |
+
+## Phase 0 — the toolbox
+
+**Built 2026-09-29**, with [its plan](../plans/2026-09-29-toolbox.md).
+
+- **The `tools` slice** is `{ shown: string[] }`. With nothing stored, the tools
+  marked `defaultOn` are shown — the five — which is every wedding today and
+  every new one; Money, Checklist and Binder wait in the toolbox. Once somebody
+  adds or removes a tool the list is stored as written, and it keeps ids this
+  build does not know: a tool a newer version added is never removed by an
+  older one writing its own change.
+- **The registry** (`lib/tools.ts`) gives each tool a stable `id`, which is
+  what is stored; an address could be renamed. `shownTools(doc)` gives the
+  shown tools in the registry's order, cached per document like every other
+  derived view.
+- **The header** shows Guests, always first, then the shown tools, and ends the
+  row with **+**, which opens
+  **Tools** (`?panel=tools`): every tool with what it is for, and Add or
+  Remove. A removal says the work is kept, and is one step on the wedding's
+  history ("Undo removing Seating").
+- **Not shown means out of sight everywhere at once**, whether removed or
+  never added: the header, the front page's areas, What is left (in
+  `readiness` itself, so the planner's Weddings page, which runs it on the
+  server, agrees), "Take a tour", and the palette's pages. Records in the
+  palette — a table, a block — still open where they live. So a wedding that
+  has not added Money hears nothing of balances falling due.
+- **The example wedding shows every tool**, held there by a test: it exists to
+  show what Trousseau does, and the tour and front page point at all of it.
+
+## Phase 1 — Timeline: travel between places, and calendars
+
+**Built 2026-09-29**, with [its plan](../plans/2026-09-29-timeline-travel-and-calendars.md).
+Two things below were corrected by the code before they were built, and are
+written here as built: who moves is a **tag**, not a lane; and calendar times
+are the **venue's clock**, not UTC.
+
+- **Travel times** the couple types: `timeline.travel`, a list of
+  `{ between: [placeA, placeB], minutes }`, the same either way. The panel lists
+  the pairs the day actually moves between (from the blocks' locations), so
+  there is nothing to invent, only blanks to fill.
+- **A new advisory, `no-travel-time`**: a tag that ends one block at one place
+  and starts its next somewhere else sooner than the typed time allows,
+  measured from where the run sheet says the block ends (before its
+  contingency buffer) — "Hair and make-up ends at 13:00 at the house; the first look starts
+  at 13:05 at the venue, 15 minutes away." A pair with no time typed is never
+  guessed at and never flagged. Advisory, because a person running is not a
+  print run that should stop. *Not a lane:* the example's Suppliers lane holds
+  the florist, the caterer and the band, and Transport the cars and the guest
+  coach — a lane is a kind of activity, and checking one would say the coach
+  cannot get from where the cars were. Tags are already who is where; the
+  panel tells a couple to tag their own blocks ("couple") to be checked.
+- **Calendar files**: the day as `.ics`, whole or for one supplier (a tag's
+  blocks), written in the browser, on the wedding's own date and refused
+  without one — the timeline's `day.date` is a placeholder, 20 June 2026, until
+  a date is set. Times are **local, with no zone**, so 13:30 at the venue is
+  13:30 on every phone, as in the Binder. Not UTC: that needs the day's offset,
+  and an offset nobody entered reads as British Summer Time in the Day panel,
+  indistinguishable from one chosen — a winter wedding would be an hour out in
+  every calendar. (This spec first said UTC would show "the venue's clock";
+  UTC shows the phone's.) Refused while the day has clashes, as the PDFs are.
+- **The clocks, fixed the same day.** The fallback went further than the Day
+  panel: every Timeline edit — renaming a block was enough — wrote it into the
+  wedding, where the Binder then trusted it over the phone's own clock
+  (reproduced in a test before the fix). The offset is now null until chosen,
+  in the timeline, the published day and Delegation's reader; the panel says
+  *Not set*, any choice is a change, and sunset and golden hour wait for it.
+
+## Phase 2 — one cast, and Ceremony
+
+**Built 2026-09-29**, with [its plan](../plans/2026-09-29-cast-and-ceremony.md).
+As built, where it differs from below: the suggested order ends with the
+couple walking in together, since who walks with whom is theirs to say; the
+officiant is words rather than a crew member; and there is no tour chapter,
+the tour being held under thirty steps.
+
+- **`cast`** takes Group shots' cast and custom roles, moved on load by the
+  existing load-time pass. The fixed roles gain each partner's grandparents
+  (a party role, as the wedding party is). Readers, ring bearer, flower party
+  and the like are custom roles, as "Me and my family" already is. Group shots
+  reads it exactly as before.
+- **Ceremony** (`/ceremony`, slice `ceremony`, added from the toolbox): the
+  processional as an ordered list of groups. Each group names who walks —
+  a role, a custom role, a guest, a family, a crew person (the officiant is
+  usually a supplier, not a guest) or free text — how they walk (alone, in
+  pairs, in threes), which side they go to (named after the partners), and a
+  cue: the music and the moment it changes.
+- **"Suggest an order"** from the cast, as Group shots' `propose` does: a
+  starting point in the usual UK order, entirely editable.
+- **Checks**: someone in the processional who has declined; a role nobody has
+  been cast in. Both through the cast's own resolver, as group shots do now.
+- **Prints**: one page for the officiant and whoever runs the day, and plain
+  text to paste into an email. The page joins the wedding pack.
+
+## Phase 3 — Boxes
+
+**Built 2026-09-29**, with [its plan](../plans/2026-09-29-boxes.md). As built,
+where it differs from below: a thing moves between boxes from a menu on its
+row rather than by dragging; items carry no notes of their own; a box not for
+the day needs nobody to take it; and the library adds boxes to a wedding
+rather than replacing its own.
+
+The maintainer's words: boxes, what is in each, "in a good intuitive way", and
+each box attached to a part of the day. The design below was confirmed as it
+stands (decision 16).
+
+```ts
+interface Box {
+  id: string;
+  /** Printed large on its label: "3". */
+  number: number;
+  name: string;               // "Getting ready — Alex"
+  items: Item[];
+  /** The part of the day it is needed for: where and when come from the block. */
+  blockId: string | null;     // null: not for the day — the honeymoon case
+  personIds: string[];        // who gets it there
+  notes: string;
+}
+interface Item { id: string; label: string; quantity: number; packed: boolean; notes: string }
+```
+
+- **Where and when are the block's.** "Needs to be at the house for 9" is a box
+  on the block "Getting ready", at the house, at 09:00; move the block and the
+  box moves with it. A drop-off that is not a block of its own is a moment
+  (a block with no length), which Timeline already has. One way to say where
+  and when, not a second one typed on the box.
+- **Finding things**: one search over every box ("shoes" → Box 3), items moved
+  between boxes by dragging, and each box's packed count on its card.
+- **Checks**: a box whose block is gone (as a job's can be); unpacked items
+  close to the day; a box nobody is taking.
+- **Prints**: a label per box — its number, name, where and when, and what is
+  in it — and a packing list, as PDF and CSV. The list joins the wedding pack.
+- **Starter boxes** are UK first: rings, the paperwork the ceremony needs,
+  supplier envelopes, the emergency kit, the guest book, and so on — a list to
+  edit, as "Add the usual tasks" is.
+
+## Phase 4 — Bar
+
+**Built 2026-09-29**, with [its plan](../plans/2026-09-29-bar.md), whose
+defaults the maintainer agreed before it was built. As built, where it differs
+from below: evening-only guests are a figure of the Bar's own, since the guest
+list does not say who is invited for the evening; the toast is fizz and the
+meal is wine, and only the reception and the evening pour a mix; and prices
+have no defaults.
+
+UK first, and every figure on screen, editable, and resettable to its default.
+
+- **Who is drinking**: the guests coming (`isComing`), live, less a share not
+  drinking. The count can be overridden, and says so while it is.
+- **By part of the day**, because a UK wedding drinks in parts: the drinks
+  reception, the toast, the meal's wine, and the evening bar. Each part has its
+  own hours and per-head rate.
+- **UK units**: wine and fizz in 75cl bottles, 125ml or 175ml glasses; beer in
+  330ml bottles, 500ml cans, cases of 24; spirits in 70cl bottles, 25ml
+  measures; soft drinks and mixers in litres; ice in kilos.
+- **Bar types**: full bar; beer and wine; signature cocktails with beer and
+  wine; low and no alcohol.
+- **Adjusting**: a lighter or heavier crowd; prices per bottle or case, giving
+  an estimated spend; "we already have" per line; round up to whole cases for
+  sale or return, which UK merchants commonly offer.
+- **The shopping list** grouped by where it is bought — supermarket, wine
+  merchant, cash and carry — editable.
+- **The defaults are the product's credibility**, and are agreed with the
+  maintainer in Phase 4's plan before they are built.
+
+## Tools feeding each other — proposals
+
+None of these is built without the maintainer accepting it. Each keeps the
+rule that a tool writes only its own slice and reads the others'.
+
+| From | To | What |
+|---|---|---|
+| Boxes | Delegation | A person taking a box sees "Box 3 to the house by 09:00" on their job sheet. Derived from the box, never stored as a job, so it follows the block. |
+| Boxes | Binder | Find a box or an item on the day: "where are the rings?" |
+| Ceremony | Timeline | The processional's cues shown inside the ceremony block, read-only. |
+| Ceremony | Binder | The order of walking, on the phone, on the day. |
+| Bar | Timeline | Reception, meal and evening hours read from the blocks the couple picks, rather than typed twice. |
+| Bar | Money | The estimated spend shown against the budget as planned, not paid. |
+| Bar | Checklist | "Buy the drinks" and "Collect the ice", dated back from the day. |
+| Bar | Boxes | Crates as boxes, attached to the bar's block. |
+| Timeline | Supplier links | Each supplier's calendar file on their own call sheet. |
+
+## Library
+
+A planner keeps, as the existing kinds are kept, without anything personal:
+a **processional** as roles and formations with no guest named; a **set of
+boxes** with their items and no people or blocks; **bar settings** — rates,
+units and prices — with no guest count.
+
+## Open questions
+
+1. **T6**: ~~take fontkit off every page~~ — **done 2026-09-29**: one constant,
+   `DEFAULT_FIT`, moved beside the other template defaults; 522 KB shared to
+   393 KB, and a test that walks both layouts' imports and names the chain if
+   the engine comes back. Still open: a CI check on each page's own JavaScript,
+   and its limit.
+2. **S18** (from the master plan), since the PRD says "zero tracking": remove
+   Vercel Analytics, or say in the Privacy Policy what it counts?
+3. **Cues on the day**: is the Ceremony → Timeline proposal wanted, or do the
+   cues stay in Ceremony?
+4. ~~**Order of phases**~~ — **all four built, 2026-09-29**, in the order
+   proposed: Timeline, Ceremony, Boxes, Bar.
+
+## Explicitly deferred
+
+- Public calculator pages for search (decision 5).
+- A keyboard shortcut for the toolbox (decision 4).
diff --git a/scripts/validate-wedding.mjs b/scripts/validate-wedding.mjs
index bc8afd3f..3a738a83 100644
--- a/scripts/validate-wedding.mjs
+++ b/scripts/validate-wedding.mjs
@@ -156,10 +156,15 @@ export function check(doc) {
       ...Object.keys(doc.seating?.groups ?? {}),
       ...Object.keys(doc.seating?.subgroups ?? {}),
     ]);
+    // The cast has a slice of its own, shared with Ceremony. A document written
+    // before it had one keeps it inside the shots, and is read from there.
+    const ownCast = isObj(doc.cast) && ("roles" in doc.cast || "customRoles" in doc.cast);
+    const castRoles = ownCast ? doc.cast.roles : doc.shots.cast;
+    const castCustomRoles = ownCast ? doc.cast.customRoles : doc.shots.customRoles;
     const customRoleIds = new Set(
-      (Array.isArray(doc.shots.customRoles) ? doc.shots.customRoles : []).filter(isObj).map((r) => r.id),
+      (Array.isArray(castCustomRoles) ? castCustomRoles : []).filter(isObj).map((r) => r.id),
     );
-    const cast = isObj(doc.shots.cast) ? doc.shots.cast : {};
+    const cast = isObj(castRoles) ? castRoles : {};
 
     for (const [role, ids] of Object.entries(cast)) {
       for (const id of Array.isArray(ids) ? ids : []) {
diff --git a/scripts/validate-wedding.test.mjs b/scripts/validate-wedding.test.mjs
index c919278a..32cd8720 100644
--- a/scripts/validate-wedding.test.mjs
+++ b/scripts/validate-wedding.test.mjs
@@ -183,6 +183,17 @@ describe("shots slice", () => {
     expect(check(doc).errors).toEqual([expect.stringContaining("bride")]);
   });
 
+  it("reads the cast from its own slice, and a custom role there names a shot's member", () => {
+    const doc = {
+      ...base,
+      cast: { roles: { "a-mother": ["ghost"] }, customRoles: [{ id: "crole-1", name: "Readers", guestIds: [] }] },
+      shots: {
+        sections: [{ id: "s1", name: "Family", shots: [{ id: "sh1", label: "x", members: [{ kind: "customRole", ref: "crole-1" }] }] }],
+      },
+    };
+    expect(check(doc).errors).toEqual([expect.stringContaining("a-mother")]);
+  });
+
   it("catches a shot member naming a custom role that does not exist", () => {
     const doc = {
       ...base,
diff --git a/src/day.test.ts b/src/day.test.ts
index 5812a672..730acbdd 100644
--- a/src/day.test.ts
+++ b/src/day.test.ts
@@ -37,6 +37,16 @@ describe("daySchema", () => {
     expect(daySchema.safeParse(future).success).toBe(true);
   });
 
+  it("takes a day whose clocks nobody has set", () => {
+    const parsed = daySchema.parse({
+      kind: "cadence.day",
+      version: 1,
+      day: { date: "", coupleNames: "", venueName: "", curfewMin: 0, utcOffsetMin: null },
+      blocks: [],
+    });
+    expect(parsed.day.utcOffsetMin).toBeNull();
+  });
+
   it("preserves unknown keys on the day, a block and a team", () => {
     const parsed = daySchema.parse({
       kind: "cadence.day",
diff --git a/src/day.ts b/src/day.ts
index 7e20610e..2fc8ce70 100644
--- a/src/day.ts
+++ b/src/day.ts
@@ -85,7 +85,12 @@ export const daySchema = z.looseObject({
     coupleNames: z.string(),
     venueName: z.string(),
     curfewMin: z.number(),
-    utcOffsetMin: z.number(),
+    /**
+     * The day's offset from UTC in minutes, or null until somebody enters it.
+     * Never filled in with a likely value: a guess here is a wedding an hour
+     * out in every clock that reads it.
+     */
+    utcOffsetMin: z.number().nullable(),
   }),
   lanes: stringList(),
   blocks: z.array(dayBlockSchema),
diff --git a/src/envelope.test.ts b/src/envelope.test.ts
index 2af0b322..6e2ba783 100644
--- a/src/envelope.test.ts
+++ b/src/envelope.test.ts
@@ -25,7 +25,7 @@ describe("emptyTrousseau", () => {
 });
 
 describe("SLICE_NAMES", () => {
-  it("lists exactly the eight publishable slices", () => {
+  it("lists exactly the thirteen publishable slices", () => {
     expect([...SLICE_NAMES]).toEqual([
       "event",
       "guests",
@@ -35,6 +35,11 @@ describe("SLICE_NAMES", () => {
       "stationery",
       "shots",
       "timeline",
+      "tools",
+      "cast",
+      "ceremony",
+      "boxes",
+      "bar",
     ]);
   });
 
diff --git a/src/envelope.ts b/src/envelope.ts
index e88f0712..8972e276 100644
--- a/src/envelope.ts
+++ b/src/envelope.ts
@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { daySchema } from "./day.js";
 import { eventSchema } from "./event.js";
-import { crewSchema, guestsSchema, seatingSchema, shotsSchema, stationerySchema, timelineSchema } from "./slices.js";
+import { barSchema, boxesSchema, castSchema, ceremonySchema, crewSchema, guestsSchema, seatingSchema, shotsSchema, stationerySchema, timelineSchema, toolsSchema } from "./slices.js";
 
 export const TROUSSEAU_KIND = "trousseau";
 export const TROUSSEAU_VERSION = 1;
@@ -20,6 +20,11 @@ export const SLICE_NAMES = [
   "stationery",
   "shots",
   "timeline",
+  "tools",
+  "cast",
+  "ceremony",
+  "boxes",
+  "bar",
 ] as const;
 
 export type SliceName = (typeof SLICE_NAMES)[number];
@@ -44,6 +49,11 @@ export const trousseauSchema = z.looseObject({
   stationery: stationerySchema,
   shots: shotsSchema,
   timeline: timelineSchema,
+  tools: toolsSchema,
+  cast: castSchema,
+  ceremony: ceremonySchema,
+  boxes: boxesSchema,
+  bar: barSchema,
   /** Native documents, keyed by app name. Present only in an exported file. */
   sources: z.record(z.string(), z.unknown()).default(() => ({})),
 });
diff --git a/src/index.ts b/src/index.ts
index 65d136db..4e33026c 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -22,18 +22,28 @@ export {
   type Trousseau,
 } from "./envelope.js";
 export {
+  barSchema,
+  boxesSchema,
+  castSchema,
+  ceremonySchema,
   crewSchema,
   guestsSchema,
   seatingSchema,
   shotsSchema,
   stationerySchema,
   timelineSchema,
+  toolsSchema,
+  type BarSlice,
+  type BoxesSlice,
+  type CastSlice,
+  type CeremonySlice,
   type Crew,
   type Guests,
   type Seating,
   type Shots,
   type Stationery,
   type TimelineSlice,
+  type Tools,
 } from "./slices.js";
 export {
   TROUSSEAU_EXTENSION,
diff --git a/src/slices.ts b/src/slices.ts
index 6cdd1ea3..11dd2a42 100644
--- a/src/slices.ts
+++ b/src/slices.ts
@@ -21,6 +21,24 @@ export const crewSchema = z.looseObject({}).default(() => ({}));
 export const stationerySchema = z.looseObject({}).default(() => ({}));
 export const shotsSchema = z.looseObject({}).default(() => ({}));
 export const timelineSchema = z.looseObject({}).default(() => ({}));
+/**
+ * Who is who — the couple, their families, their wedding parties — shared by
+ * every tool that names people by what they are to the couple rather than by
+ * name. Its own slice because more than one tool edits it.
+ */
+export const castSchema = z.looseObject({}).default(() => ({}));
+/** The ceremony: the processional, in the order it walks. Ceremony's own. */
+export const ceremonySchema = z.looseObject({}).default(() => ({}));
+/** What is packed in which box, and the part of the day each is needed for. Boxes' own. */
+export const boxesSchema = z.looseObject({}).default(() => ({}));
+/** What the couple chose for the drinks they buy: the kind of bar and every figure they changed. Bar's own. */
+export const barSchema = z.looseObject({}).default(() => ({}));
+/**
+ * Which tools the wedding shows. Owned by the launcher rather than any tool,
+ * as `event` is, and its own slice so that adding a tool never conflicts with
+ * a partner changing the date.
+ */
+export const toolsSchema = z.looseObject({}).default(() => ({}));
 
 export type Guests = z.infer<typeof guestsSchema>;
 export type Seating = z.infer<typeof seatingSchema>;
@@ -28,3 +46,8 @@ export type Crew = z.infer<typeof crewSchema>;
 export type Stationery = z.infer<typeof stationerySchema>;
 export type Shots = z.infer<typeof shotsSchema>;
 export type TimelineSlice = z.infer<typeof timelineSchema>;
+export type CastSlice = z.infer<typeof castSchema>;
+export type CeremonySlice = z.infer<typeof ceremonySchema>;
+export type BoxesSlice = z.infer<typeof boxesSchema>;
+export type BarSlice = z.infer<typeof barSchema>;
+export type Tools = z.infer<typeof toolsSchema>;
diff --git a/suite/app/(app)/(tools)/bar/BarClient.tsx b/suite/app/(app)/(tools)/bar/BarClient.tsx
new file mode 100644
index 00000000..79b93588
--- /dev/null
+++ b/suite/app/(app)/(tools)/bar/BarClient.tsx
@@ -0,0 +1,14 @@
+"use client";
+
+import dynamic from "next/dynamic";
+
+/**
+ * The Bar, split out of the main bundle, as Boxes is: this file exists only
+ * because `next/dynamic(..., { ssr: false })` is a Client Component API and
+ * `page.tsx` has to stay a Server Component to keep its `metadata`.
+ */
+const BarBoard = dynamic(() => import("@/components/bar/BarBoard").then((m) => m.BarBoard), { ssr: false });
+
+export function BarClient() {
+  return <BarBoard />;
+}
diff --git a/suite/app/(app)/(tools)/bar/page.tsx b/suite/app/(app)/(tools)/bar/page.tsx
new file mode 100644
index 00000000..f8a2c418
--- /dev/null
+++ b/suite/app/(app)/(tools)/bar/page.tsx
@@ -0,0 +1,11 @@
+import type { Metadata } from "next";
+import { BarClient } from "./BarClient";
+
+export const metadata: Metadata = {
+  title: "Bar",
+  description: "How much drink to buy, in bottles and cases, and roughly what it costs.",
+};
+
+export default function BarPage() {
+  return <BarClient />;
+}
diff --git a/suite/app/(app)/(tools)/boxes/BoxesClient.tsx b/suite/app/(app)/(tools)/boxes/BoxesClient.tsx
new file mode 100644
index 00000000..9428219e
--- /dev/null
+++ b/suite/app/(app)/(tools)/boxes/BoxesClient.tsx
@@ -0,0 +1,14 @@
+"use client";
+
+import dynamic from "next/dynamic";
+
+/**
+ * Boxes, split out of the main bundle, as Ceremony is: this file exists only
+ * because `next/dynamic(..., { ssr: false })` is a Client Component API and
+ * `page.tsx` has to stay a Server Component to keep its `metadata`.
+ */
+const BoxesBoard = dynamic(() => import("@/components/boxes/BoxesBoard").then((m) => m.BoxesBoard), { ssr: false });
+
+export function BoxesClient() {
+  return <BoxesBoard />;
+}
diff --git a/suite/app/(app)/(tools)/boxes/page.tsx b/suite/app/(app)/(tools)/boxes/page.tsx
new file mode 100644
index 00000000..3fbc4c5d
--- /dev/null
+++ b/suite/app/(app)/(tools)/boxes/page.tsx
@@ -0,0 +1,11 @@
+import type { Metadata } from "next";
+import { BoxesClient } from "./BoxesClient";
+
+export const metadata: Metadata = {
+  title: "Boxes",
+  description: "What is packed in which box, and where each has to be, by when.",
+};
+
+export default function BoxesPage() {
+  return <BoxesClient />;
+}
diff --git a/suite/app/(app)/(tools)/ceremony/CeremonyClient.tsx b/suite/app/(app)/(tools)/ceremony/CeremonyClient.tsx
new file mode 100644
index 00000000..2997a3ef
--- /dev/null
+++ b/suite/app/(app)/(tools)/ceremony/CeremonyClient.tsx
@@ -0,0 +1,16 @@
+"use client";
+
+import dynamic from "next/dynamic";
+
+/**
+ * Ceremony, split out of the main bundle, as Group shots is: this file exists
+ * only because `next/dynamic(..., { ssr: false })` is a Client Component API
+ * and `page.tsx` has to stay a Server Component to keep its `metadata`.
+ */
+const CeremonyBoard = dynamic(() => import("@/components/ceremony/CeremonyBoard").then((m) => m.CeremonyBoard), {
+  ssr: false,
+});
+
+export function CeremonyClient() {
+  return <CeremonyBoard />;
+}
diff --git a/suite/app/(app)/(tools)/ceremony/page.tsx b/suite/app/(app)/(tools)/ceremony/page.tsx
new file mode 100644
index 00000000..049366b6
--- /dev/null
+++ b/suite/app/(app)/(tools)/ceremony/page.tsx
@@ -0,0 +1,11 @@
+import type { Metadata } from "next";
+import { CeremonyClient } from "./CeremonyClient";
+
+export const metadata: Metadata = {
+  title: "Ceremony",
+  description: "The processional: who walks, in what order, how, and to what music.",
+};
+
+export default function CeremonyPage() {
+  return <CeremonyClient />;
+}
diff --git a/suite/apps/brigade/core/import/day.test.ts b/suite/apps/brigade/core/import/day.test.ts
new file mode 100644
index 00000000..781dfd26
--- /dev/null
+++ b/suite/apps/brigade/core/import/day.test.ts
@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { parseDay } from "./day";
+
+const day = (utcOffsetMin: unknown) =>
+  JSON.stringify({
+    kind: "cadence.day",
+    version: 1,
+    appVersion: "",
+    day: { date: "2028-12-12", coupleNames: "Alex & Sam", venueName: "", curfewMin: 1440, utcOffsetMin },
+    lanes: ["Main day"],
+    blocks: [],
+  });
+
+describe("reading the day's clocks", () => {
+  it("takes a day whose clocks nobody has set, as unset", () => {
+    const result = parseDay(day(null));
+    expect(result.error).toBeUndefined();
+    expect(result.day?.utcOffsetMin).toBeNull();
+  });
+
+  it("takes a day whose clocks are set", () => {
+    expect(parseDay(day(0)).day?.utcOffsetMin).toBe(0);
+  });
+
+  it("refuses a day with no word on its clocks at all", () => {
+    expect(parseDay(day(undefined))).toEqual({ error: "The day is missing utcOffsetMin." });
+  });
+});
diff --git a/suite/apps/brigade/core/import/day.ts b/suite/apps/brigade/core/import/day.ts
index 2a57d3c4..a634cb1a 100644
--- a/suite/apps/brigade/core/import/day.ts
+++ b/suite/apps/brigade/core/import/day.ts
@@ -52,8 +52,10 @@ export function parseDay(json: string): DayResult {
   for (const field of ["date", "coupleNames", "venueName"]) {
     if (typeof settings[field] !== "string") return { error: `The day is missing ${field}.` };
   }
-  for (const field of ["curfewMin", "utcOffsetMin"]) {
-    if (typeof settings[field] !== "number") return { error: `The day is missing ${field}.` };
+  if (typeof settings["curfewMin"] !== "number") return { error: "The day is missing curfewMin." };
+  // Null is a day whose clocks nobody has set yet, not a broken one.
+  if (typeof settings["utcOffsetMin"] !== "number" && settings["utcOffsetMin"] !== null) {
+    return { error: "The day is missing utcOffsetMin." };
   }
 
   const rawBlocks = entry["blocks"];
@@ -97,7 +99,7 @@ export function parseDay(json: string): DayResult {
       coupleNames: settings["coupleNames"] as string,
       venueName: settings["venueName"] as string,
       curfewMin: settings["curfewMin"] as number,
-      utcOffsetMin: settings["utcOffsetMin"] as number,
+      utcOffsetMin: settings["utcOffsetMin"] as number | null,
       lanes: Array.isArray(entry["lanes"]) ? entry["lanes"].filter(isString) : [],
       blocks,
     },
diff --git a/suite/apps/brigade/core/model/types.ts b/suite/apps/brigade/core/model/types.ts
index 32d8ff75..35aa205c 100644
--- a/suite/apps/brigade/core/model/types.ts
+++ b/suite/apps/brigade/core/model/types.ts
@@ -26,7 +26,8 @@ export interface ImportedDay {
   coupleNames: string;
   venueName: string;
   curfewMin: number;
-  utcOffsetMin: number;
+  /** Null until somebody sets the clocks. */
+  utcOffsetMin: number | null;
   lanes: string[];
   blocks: DayBlock[];
 }
diff --git a/suite/apps/brigade/state/sliceBridge.ts b/suite/apps/brigade/state/sliceBridge.ts
index c4cc3ddf..116ae6aa 100644
--- a/suite/apps/brigade/state/sliceBridge.ts
+++ b/suite/apps/brigade/state/sliceBridge.ts
@@ -1,5 +1,5 @@
 import type { Trousseau } from "@jfrusher/trousseau";
-import { guestName, readCrew, readGuests } from "@/lib/model/slices";
+import { personName, readCrew, readGuests } from "@/lib/model/slices";
 import { parseDay } from "../core/import/day";
 import { emptyDoc } from "../core/model/defaults";
 import type { BrigadeDoc } from "../core/model/types";
@@ -44,11 +44,7 @@ export function readSlice(doc: Trousseau): BrigadeDoc {
    * had, which is better than a job sheet that suddenly reads "Someone".
    */
   const guests = readGuests(doc);
-  const people = crew.people.map((person) => {
-    if (!person.guestId) return person;
-    const guest = guests[person.guestId];
-    return guest ? { ...person, name: guestName(guest) || person.name } : person;
-  });
+  const people = crew.people.map((person) => ({ ...person, name: personName(person, guests) }));
 
   return {
     schemaVersion: base.schemaVersion,
diff --git a/suite/apps/cadence/core/model/defaults.ts b/suite/apps/cadence/core/model/defaults.ts
index 0f87a079..b00cd4c5 100644
--- a/suite/apps/cadence/core/model/defaults.ts
+++ b/suite/apps/cadence/core/model/defaults.ts
@@ -49,7 +49,7 @@ export function defaultDay(): DaySettings {
     venueName: "",
     latitude: 51.5074,
     longitude: -0.1278,
-    utcOffsetMin: 60,
+    utcOffsetMin: null,
     curfewMin: 1500,
     logoKey: null,
   };
@@ -63,6 +63,7 @@ export function emptyDoc(): TimelineDoc {
     lanes: [...DEFAULT_LANES],
     blocks: [],
     tagDetails: [],
+    travel: [],
     outputs: DEFAULT_OUTPUTS.map((output) => ({ ...output })),
     styles: defaultStyles(),
     fonts: [],
@@ -169,6 +170,7 @@ export function sampleDoc(): TimelineDoc {
       { tag: "transport", displayName: "County Cars", phone: "07700 900506", arrivalMin: 690, notes: "" },
       { tag: "registrar", displayName: "County Registrar", phone: "07700 900610", arrivalMin: 780, notes: "" },
     ],
+    travel: [],
     outputs: DEFAULT_OUTPUTS.map((output) => ({ ...output })),
     styles: defaultStyles(),
     fonts: [],
diff --git a/suite/apps/cadence/core/model/types.ts b/suite/apps/cadence/core/model/types.ts
index b2aecd72..a86b6f0c 100644
--- a/suite/apps/cadence/core/model/types.ts
+++ b/suite/apps/cadence/core/model/types.ts
@@ -54,6 +54,16 @@ export interface TagDetail {
   notes?: string;
 }
 
+/**
+ * How long it takes to get between two places, typed by the couple. The same
+ * either way. Never guessed: two places with no journey typed are never
+ * checked against each other.
+ */
+export interface Journey {
+  between: [string, string];
+  minutes: number;
+}
+
 export interface DaySettings {
   /** ISO `YYYY-MM-DD`. Used for display and the solar calculation only. */
   date: string;
@@ -61,8 +71,11 @@ export interface DaySettings {
   venueName: string;
   latitude: number;
   longitude: number;
-  /** The day's offset from UTC in minutes. BST is 60. Entered, never inferred. */
-  utcOffsetMin: number;
+  /**
+   * The day's offset from UTC in minutes. BST is 60. Entered, never inferred:
+   * null until somebody chooses it, and whatever needs it says so meanwhile.
+   */
+  utcOffsetMin: number | null;
   /** Minutes-from-00:00. May exceed 1440. */
   curfewMin: number;
   /** Blob store key for the logo, or null. */
@@ -98,6 +111,7 @@ export interface TimelineDoc {
   lanes: string[];
   blocks: Block[];
   tagDetails: TagDetail[];
+  travel: Journey[];
   outputs: OutputSpec[];
   styles: Record<OutputId, StyleSpec>;
   fonts: UploadedFont[];
diff --git a/suite/apps/cadence/core/project/day.ts b/suite/apps/cadence/core/project/day.ts
index cf6920ef..a07b8a92 100644
--- a/suite/apps/cadence/core/project/day.ts
+++ b/suite/apps/cadence/core/project/day.ts
@@ -56,7 +56,8 @@ export interface ResolvedDay {
     coupleNames: string;
     venueName: string;
     curfewMin: number;
-    utcOffsetMin: number;
+    /** Null until somebody sets the clocks. */
+    utcOffsetMin: number | null;
   };
   lanes: string[];
   blocks: DayBlock[];
diff --git a/suite/apps/cadence/core/schedule/conflicts.ts b/suite/apps/cadence/core/schedule/conflicts.ts
index eab0a84c..11f6fa69 100644
--- a/suite/apps/cadence/core/schedule/conflicts.ts
+++ b/suite/apps/cadence/core/schedule/conflicts.ts
@@ -1,6 +1,7 @@
 import { formatClock, formatDuration } from "../time/minutes";
 import { isMoment, type TimelineDoc } from "../model/types";
 import { blocksById, byId, byLane, type ResolvedBlock } from "./resolve";
+import { travelShortfalls } from "./travel";
 
 export type ConflictKind =
   | "lane-overlap"
@@ -8,7 +9,8 @@ export type ConflictKind =
   | "anchor-collision"
   | "curfew-overrun"
   | "past-golden-hour"
-  | "squeezed";
+  | "squeezed"
+  | "no-travel-time";
 
 /** Conflicts block export. Advisories never do. */
 export type Severity = "conflict" | "advisory";
@@ -102,6 +104,7 @@ export function conflicts(
   }
 
   found.push(...tagDoubleBookings(resolved, doc, label));
+  found.push(...travelShortfalls(resolved, doc));
 
   const goldenHourEndMin = options.goldenHourEndMin;
   if (goldenHourEndMin !== undefined) {
diff --git a/suite/apps/cadence/core/schedule/travel.test.ts b/suite/apps/cadence/core/schedule/travel.test.ts
new file mode 100644
index 00000000..2df0a1c5
--- /dev/null
+++ b/suite/apps/cadence/core/schedule/travel.test.ts
@@ -0,0 +1,209 @@
+import { describe, expect, it } from "vitest";
+import { emptyDoc } from "../model/defaults";
+import type { Block, Journey, TagDetail, TimelineDoc } from "../model/types";
+import { blockingConflicts, conflicts } from "./conflicts";
+import { resolve } from "./resolve";
+import { journeyMinutes, moves, travelPairs, travelShortfalls, withJourney } from "./travel";
+
+function block(id: string, lane: string, at: string, minutes: number, location: string, tags: string[], extra: Partial<Block> = {}): Block {
+  const [h, m] = at.split(":").map(Number);
+  return {
+    id,
+    label: id,
+    durationMin: minutes,
+    anchorMin: h! * 60 + m!,
+    gapMin: 0,
+    bufferMin: 0,
+    lane,
+    tags,
+    location,
+    notes: "",
+    outputs: [],
+    ...extra,
+  };
+}
+
+function day(blocks: Block[], travel: Journey[] = [], tagDetails: TagDetail[] = []): TimelineDoc {
+  return { ...emptyDoc(), lanes: ["Main day", "Photos", "Suppliers"], blocks, travel, tagDetails };
+}
+
+const short = (doc: TimelineDoc) => travelShortfalls(resolve(doc), doc);
+const HOUSE_TO_VENUE: Journey[] = [{ between: ["The house", "The venue"], minutes: 15 }];
+
+describe("travel between places", () => {
+  it("says when somebody is due somewhere before they could get there", () => {
+    // The PRD's own case: hair and make-up ends at 13:00, the first look is
+    // at 13:05, and the venue is fifteen minutes away.
+    const doc = day(
+      [
+        block("Hair and make-up", "Main day", "11:00", 120, "The house", ["couple"]),
+        block("First look", "Main day", "13:05", 20, "The venue", ["couple"]),
+      ],
+      HOUSE_TO_VENUE,
+    );
+    expect(short(doc)).toEqual([
+      {
+        kind: "no-travel-time",
+        severity: "advisory",
+        blockIds: ["Hair and make-up", "First look"],
+        message:
+          "couple finishes Hair and make-up at 13:00 at The house, and is due at First look at 13:05 at The venue, 15 minutes away: 10 minutes short.",
+      },
+    ]);
+  });
+
+  it("measures from where the run sheet says a block ends, not after its buffer", () => {
+    // The buffer is for overrunning. Spent on the journey, it is gone.
+    const doc = day(
+      [
+        block("Hair and make-up", "Main day", "11:00", 120, "The house", ["couple"], { bufferMin: 10 }),
+        block("First look", "Photos", "13:12", 20, "The venue", ["couple"]),
+      ],
+      HOUSE_TO_VENUE,
+    );
+    expect(short(doc).map((found) => found.message)).toEqual([
+      "couple finishes Hair and make-up at 13:00 at The house, and is due at First look at 13:12 at The venue, 15 minutes away: 3 minutes short.",
+    ]);
+  });
+
+  it("says nothing when there is time, or when no time was typed", () => {
+    const blocks = [
+      block("Hair and make-up", "Main day", "11:00", 120, "The house", ["couple"]),
+      block("First look", "Main day", "13:15", 20, "The venue", ["couple"]),
+    ];
+    expect(short(day(blocks, HOUSE_TO_VENUE))).toEqual([]);
+    const tight = [blocks[0]!, { ...blocks[1]!, anchorMin: 13 * 60 + 5 }];
+    expect(short(day(tight, []))).toEqual([]);
+  });
+
+  it("matches places whatever their case and spacing, and a journey either way round", () => {
+    const doc = day(
+      [
+        block("First look", "Main day", "13:00", 20, "the venue ", ["couple"]),
+        block("Back for the dress", "Main day", "13:25", 20, "THE HOUSE", ["couple"]),
+      ],
+      HOUSE_TO_VENUE,
+    );
+    expect(journeyMinutes(doc, " the venue", "the house")).toBe(15);
+    expect(short(doc)).toHaveLength(1);
+  });
+
+  it("carries where somebody was across a block with no location", () => {
+    const doc = day(
+      [
+        block("Hair and make-up", "Main day", "11:00", 120, "The house", ["couple"]),
+        block("In the car", "Main day", "13:00", 5, "", ["couple"]),
+        block("First look", "Main day", "13:05", 20, "The venue", ["couple"]),
+      ],
+      HOUSE_TO_VENUE,
+    );
+    expect(short(doc).map((found) => found.blockIds)).toEqual([["Hair and make-up", "First look"]]);
+  });
+
+  it("names everybody making the same move once, by the name they were given", () => {
+    const doc = day(
+      [
+        block("Getting ready", "Main day", "11:00", 120, "The house", ["photographer", "couple"]),
+        block("First look", "Main day", "13:05", 20, "The venue", ["photographer", "couple"]),
+      ],
+      HOUSE_TO_VENUE,
+      [{ tag: "photographer", displayName: "Eleanor Vane Photography" }],
+    );
+    const found = short(doc);
+    expect(found).toHaveLength(1);
+    expect(found[0]?.message).toMatch(/^Eleanor Vane Photography and couple finish Getting ready at 13:00 .* and are due at First look/);
+  });
+
+  it("does not treat a lane as somebody: two suppliers one after the other are not a journey", () => {
+    const doc = day(
+      [
+        block("Florist", "Suppliers", "11:00", 60, "The house", ["florist"]),
+        block("Caterer", "Suppliers", "12:05", 60, "The venue", ["caterer"]),
+      ],
+      HOUSE_TO_VENUE,
+    );
+    expect(moves(resolve(doc), doc)).toEqual([]);
+    expect(short(doc)).toEqual([]);
+  });
+
+  it("leaves somebody in two places at once to the double-booking check", () => {
+    const doc = day(
+      [
+        block("Hair and make-up", "Main day", "11:00", 150, "The house", ["couple"]),
+        block("First look", "Photos", "13:05", 20, "The venue", ["couple"]),
+      ],
+      HOUSE_TO_VENUE,
+    );
+    const found = conflicts(resolve(doc), doc);
+    expect(found.map((entry) => entry.kind)).toEqual(["tag-double-booked"]);
+  });
+
+  it("is advisory: it is on the screen with the rest, and never holds up a print", () => {
+    const doc = day(
+      [
+        block("Hair and make-up", "Main day", "11:00", 120, "The house", ["couple"]),
+        block("First look", "Main day", "13:05", 20, "The venue", ["couple"]),
+      ],
+      HOUSE_TO_VENUE,
+    );
+    const found = conflicts(resolve(doc), doc);
+    expect(found.map((entry) => entry.kind)).toContain("no-travel-time");
+    expect(blockingConflicts(found)).toEqual([]);
+  });
+});
+
+describe("moves", () => {
+  it("lists every change of place, per tag, in time order", () => {
+    const doc = day([
+      block("Getting ready", "Main day", "08:00", 180, "The suite", ["photographer"]),
+      block("Ceremony", "Main day", "13:30", 45, "Orangery", ["photographer", "registrar"]),
+      block("Rings", "Main day", "13:15", 0, "Orangery", ["registrar"]),
+      block("Confetti", "Main day", "14:15", 15, "Front steps", ["photographer"]),
+    ]);
+    expect(moves(resolve(doc), doc).map((move) => `${move.tag}: ${move.fromPlace} → ${move.toPlace}`)).toEqual([
+      "photographer: The suite → Orangery",
+      "photographer: Orangery → Front steps",
+    ]);
+  });
+});
+
+describe("travelPairs", () => {
+  const doc = day(
+    [
+      block("Getting ready", "Main day", "08:00", 180, "The suite", ["photographer", "couple"]),
+      block("Ceremony", "Main day", "13:30", 45, "Orangery", ["photographer", "couple"]),
+      block("Back to change", "Main day", "15:00", 30, "the suite", ["couple"]),
+    ],
+    [
+      { between: ["Orangery", "The suite"], minutes: 5 },
+      { between: ["Church", "The suite"], minutes: 20 },
+    ],
+    [{ tag: "photographer", displayName: "Eleanor Vane Photography" }],
+  );
+
+  it("lists each pair of places once, with its time and everybody who makes the journey", () => {
+    expect(travelPairs(resolve(doc), doc).used).toEqual([
+      { between: ["The suite", "Orangery"], minutes: 5, who: ["Eleanor Vane Photography", "couple"] },
+    ]);
+  });
+
+  it("keeps the journeys the day no longer makes apart, to be forgotten", () => {
+    expect(travelPairs(resolve(doc), doc).unused).toEqual([{ between: ["Church", "The suite"], minutes: 20 }]);
+  });
+});
+
+describe("withJourney", () => {
+  const travel: Journey[] = [{ between: ["The house", "The venue"], minutes: 15 }];
+
+  it("adds, changes and takes away, matching a pair either way round", () => {
+    expect(withJourney([], ["The house", "The venue"], 15)).toEqual(travel);
+    expect(withJourney(travel, ["the venue", "the house"], 20)).toEqual([{ between: ["The house", "The venue"], minutes: 20 }]);
+    expect(withJourney(travel, ["The venue", "The house"], null)).toEqual([]);
+    expect(withJourney(travel, ["The venue", "The house"], 0)).toEqual([]);
+  });
+
+  it("hands back the same list when nothing changes", () => {
+    expect(withJourney(travel, ["The house", "The venue"], 15)).toBe(travel);
+    expect(withJourney(travel, ["Church", "The venue"], null)).toBe(travel);
+  });
+});
diff --git a/suite/apps/cadence/core/schedule/travel.ts b/suite/apps/cadence/core/schedule/travel.ts
new file mode 100644
index 00000000..0b64ea75
--- /dev/null
+++ b/suite/apps/cadence/core/schedule/travel.ts
@@ -0,0 +1,158 @@
+import { tagLabel } from "../model/tags";
+import { formatClock } from "../time/minutes";
+import type { Journey, TimelineDoc } from "../model/types";
+import type { Conflict } from "./conflicts";
+import { blocksById, byId, type ResolvedBlock } from "./resolve";
+
+/**
+ * Who has to get from one place to another during the day, and whether the
+ * day leaves them long enough to.
+ *
+ * Somebody is a tag — the photographer, the band, the two of you once your own
+ * blocks carry "couple" — as the double-booking check already reads it. Not a
+ * lane: the Suppliers lane holds the florist and then the caterer, and nobody
+ * travels from one to the other.
+ */
+
+/** A place as the couple would match it: trimmed, whatever the case. */
+export const placeKey = (place: string): string => place.trim().toLowerCase();
+
+/** Two places, either way round, as one key. */
+export function pairKey(a: string, b: string): string {
+  return [placeKey(a), placeKey(b)].sort().join("\u0000");
+}
+
+export interface Move {
+  tag: string;
+  from: ResolvedBlock;
+  to: ResolvedBlock;
+  fromPlace: string;
+  toPlace: string;
+}
+
+/**
+ * Every move the day makes: for each tag, in time order, a block somewhere
+ * other than where that tag last was. A block with no location moves nobody,
+ * so where they last were carries across it.
+ */
+export function moves(resolved: ResolvedBlock[], doc: TimelineDoc): Move[] {
+  const positions = byId(resolved);
+  const stopsByTag = new Map<string, Array<{ entry: ResolvedBlock; place: string }>>();
+  for (const block of doc.blocks) {
+    const entry = positions.get(block.id);
+    const place = block.location.trim();
+    if (!entry || !place) continue;
+    for (const tag of block.tags) {
+      const stops = stopsByTag.get(tag);
+      if (stops) stops.push({ entry, place });
+      else stopsByTag.set(tag, [{ entry, place }]);
+    }
+  }
+
+  const found: Move[] = [];
+  for (const [tag, stops] of stopsByTag) {
+    stops.sort((a, b) => a.entry.startMin - b.entry.startMin || a.entry.contentEndMin - b.entry.contentEndMin);
+    for (let i = 1; i < stops.length; i += 1) {
+      const from = stops[i - 1]!;
+      const to = stops[i]!;
+      if (placeKey(from.place) === placeKey(to.place)) continue;
+      found.push({ tag, from: from.entry, to: to.entry, fromPlace: from.place, toPlace: to.place });
+    }
+  }
+  return found;
+}
+
+/** The typed time between two places, or null: never a guess. */
+export function journeyMinutes(doc: TimelineDoc, a: string, b: string): number | null {
+  const key = pairKey(a, b);
+  return doc.travel.find((journey) => pairKey(...journey.between) === key)?.minutes ?? null;
+}
+
+export interface TravelPair {
+  between: [string, string];
+  /** The typed time, or null: not checked. */
+  minutes: number | null;
+  /** Who makes this journey, by name. */
+  who: string[];
+}
+
+/**
+ * The pairs of places the day moves between, in the order it first does, each
+ * with its typed time; and the journeys typed that the day no longer makes. The
+ * same walk the advisory uses, so what is listed is exactly what is checked.
+ */
+export function travelPairs(resolved: ResolvedBlock[], doc: TimelineDoc): { used: TravelPair[]; unused: Journey[] } {
+  const pairs = new Map<string, TravelPair>();
+  const inOrder = [...moves(resolved, doc)].sort((a, b) => a.to.startMin - b.to.startMin);
+  for (const move of inOrder) {
+    const key = pairKey(move.fromPlace, move.toPlace);
+    const who = tagLabel(doc, move.tag);
+    const pair = pairs.get(key);
+    if (!pair) {
+      pairs.set(key, { between: [move.fromPlace, move.toPlace], minutes: journeyMinutes(doc, move.fromPlace, move.toPlace), who: [who] });
+    } else if (!pair.who.includes(who)) {
+      pair.who.push(who);
+    }
+  }
+  return {
+    used: [...pairs.values()],
+    unused: doc.travel.filter((journey) => !pairs.has(pairKey(...journey.between))),
+  };
+}
+
+/**
+ * The travel list with one journey's time set, or taken away when there is
+ * none. The same list back when nothing changed, so no empty step lands on the
+ * history.
+ */
+export function withJourney(travel: Journey[], between: [string, string], minutes: number | null): Journey[] {
+  const key = pairKey(...between);
+  const existing = travel.find((journey) => pairKey(...journey.between) === key);
+  if (minutes === null || minutes <= 0) return existing ? travel.filter((journey) => journey !== existing) : travel;
+  if (existing?.minutes === minutes) return travel;
+  return existing
+    ? travel.map((journey) => (journey === existing ? { ...journey, minutes } : journey))
+    : [...travel, { between, minutes }];
+}
+
+const listOf = (names: string[]): string =>
+  names.length <= 1 ? (names[0] ?? "") : `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+
+/**
+ * Somebody due somewhere before they could get there. Measured from where the
+ * run sheet says a block ends — before its contingency buffer, which is for
+ * overrunning, not for travelling. One advisory per pair of blocks, naming
+ * everybody making that move. An overlap is not travel's to report: somebody
+ * in two places at once is a double booking already.
+ */
+export function travelShortfalls(resolved: ResolvedBlock[], doc: TimelineDoc): Conflict[] {
+  const blocks = blocksById(doc);
+  const label = (id: string) => blocks.get(id)?.label ?? id;
+  const short = new Map<string, { move: Move; minutes: number; who: string[] }>();
+
+  for (const move of moves(resolved, doc)) {
+    const minutes = journeyMinutes(doc, move.fromPlace, move.toPlace);
+    if (minutes === null) continue;
+    const gap = move.to.startMin - move.from.contentEndMin;
+    if (gap < 0 || gap >= minutes) continue;
+    const key = `${move.from.id}>${move.to.id}`;
+    const who = tagLabel(doc, move.tag);
+    const seen = short.get(key);
+    if (seen) seen.who.push(who);
+    else short.set(key, { move, minutes, who: [who] });
+  }
+
+  return [...short.values()].map(({ move, minutes, who }) => {
+    const one = who.length === 1;
+    const gap = move.to.startMin - move.from.contentEndMin;
+    return {
+      kind: "no-travel-time" as const,
+      severity: "advisory" as const,
+      blockIds: [move.from.id, move.to.id],
+      message:
+        `${listOf(who)} ${one ? "finishes" : "finish"} ${label(move.from.id)} at ${formatClock(move.from.contentEndMin)} ` +
+        `at ${move.fromPlace}, and ${one ? "is" : "are"} due at ${label(move.to.id)} at ${formatClock(move.to.startMin)} ` +
+        `at ${move.toPlace}, ${minutes} minutes away: ${minutes - gap} minutes short.`,
+    };
+  });
+}
diff --git a/suite/apps/cadence/core/sun/solar.test.ts b/suite/apps/cadence/core/sun/solar.test.ts
index 1f6925aa..4752f3d9 100644
--- a/suite/apps/cadence/core/sun/solar.test.ts
+++ b/suite/apps/cadence/core/sun/solar.test.ts
@@ -76,4 +76,10 @@ describe("sunForDay", () => {
       sunTimes("2026-06-20", 51.5074, -0.1278, 60)?.sunsetMin,
     );
   });
+
+  it("gives nothing until the clocks are set, rather than a sunset an hour out", async () => {
+    const { sunForDay } = await import("./solar");
+    const { sampleDoc } = await import("../model/defaults");
+    expect(sunForDay({ ...sampleDoc().day, utcOffsetMin: null })).toBeNull();
+  });
 });
diff --git a/suite/apps/cadence/core/sun/solar.ts b/suite/apps/cadence/core/sun/solar.ts
index c04025b3..9ad9f2bb 100644
--- a/suite/apps/cadence/core/sun/solar.ts
+++ b/suite/apps/cadence/core/sun/solar.ts
@@ -97,12 +97,17 @@ export function sunTimes(
   };
 }
 
-/** Convenience for the document's own day settings. */
+/**
+ * Convenience for the document's own day settings. Nothing until the clocks
+ * are set: sunset on the venue's clock needs the venue's offset, and one
+ * guessed would print a sunset an hour out.
+ */
 export function sunForDay(day: {
   date: string;
   latitude: number;
   longitude: number;
-  utcOffsetMin: number;
+  utcOffsetMin: number | null;
 }): SunTimes | null {
+  if (day.utcOffsetMin === null) return null;
   return sunTimes(day.date, day.latitude, day.longitude, day.utcOffsetMin);
 }
diff --git a/suite/apps/cadence/render/ics/calendar.test.ts b/suite/apps/cadence/render/ics/calendar.test.ts
new file mode 100644
index 00000000..bb6e6d59
--- /dev/null
+++ b/suite/apps/cadence/render/ics/calendar.test.ts
@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import { emptyDoc } from "../../core/model/defaults";
+import type { Block, TimelineDoc } from "../../core/model/types";
+import { calendar, escapeText, fold } from "./calendar";
+
+function block(id: string, label: string, anchorMin: number, durationMin: number, extra: Partial<Block> = {}): Block {
+  return { id, label, durationMin, anchorMin, gapMin: 0, bufferMin: 0, lane: "Main day", tags: [], location: "", notes: "", outputs: [], ...extra };
+}
+
+const doc: TimelineDoc = {
+  ...emptyDoc(),
+  day: { ...emptyDoc().day, coupleNames: "Alex & Sam" },
+  blocks: [
+    block("blk-ceremony", "Ceremony", 13 * 60 + 30, 45, { location: "Orangery", tags: ["registrar", "photographer"], bufferMin: 10 }),
+    block("blk-rings", "Rings to the best man", 13 * 60 + 15, 0, { location: "Orangery", tags: ["registrar"] }),
+    block("blk-carriages", "Carriages", 24 * 60 + 40, 20, { location: "Front drive" }),
+  ],
+  tagDetails: [{ tag: "registrar", displayName: "County Registrar" }],
+};
+
+const NOW = new Date("2028-05-01T09:08:07.123Z");
+const make = (tag?: string) => calendar(doc, { date: "2028-06-01", now: NOW, ...(tag === undefined ? {} : { tag }) });
+const lines = (ics: string) => ics.split("\r\n");
+const unfold = (ics: string) => ics.replace(/\r\n /g, "");
+
+describe("the day as a calendar", () => {
+  it("is a calendar of the day's blocks in time order, every line ended with CRLF", () => {
+    const ics = make();
+    expect(ics.startsWith("BEGIN:VCALENDAR\r\nVERSION:2.0\r\n")).toBe(true);
+    expect(ics.endsWith("END:VCALENDAR\r\n")).toBe(true);
+    expect(ics.replace(/\r\n/g, "")).not.toMatch(/[\r\n]/);
+    expect(lines(ics).filter((line) => line.startsWith("SUMMARY:"))).toEqual([
+      "SUMMARY:Rings to the best man",
+      "SUMMARY:Ceremony",
+      "SUMMARY:Carriages",
+    ]);
+    expect(ics).toContain("X-WR-CALNAME:Alex & Sam\r\n");
+  });
+
+  it("writes the venue's clock, ends a block where the run sheet does, and puts past midnight on the next day", () => {
+    const ics = make();
+    // The ceremony's ten-minute buffer is contingency, not the ceremony.
+    expect(ics).toContain("DTSTART:20280601T133000\r\nDTEND:20280601T141500\r\n");
+    expect(ics).toContain("DTSTART:20280602T004000\r\nDTEND:20280602T010000\r\n");
+    expect(ics).not.toMatch(/DTSTART:\d{8}T\d{6}Z/);
+  });
+
+  it("gives a moment a start and no end", () => {
+    const rings = unfold(make()).split("BEGIN:VEVENT")[1]!;
+    expect(rings).toContain("DTSTART:20280601T131500");
+    expect(rings).not.toContain("DTEND");
+  });
+
+  it("gives each event a stamp and an id that is stable, and particular to this wedding", () => {
+    const ics = make();
+    expect(ics).toContain("UID:blk-ceremony.2028-06-01.alex-and-sam@trousseau\r\n");
+    expect(ics).toContain("DTSTAMP:20280501T090807Z\r\n");
+    expect(make()).toBe(ics);
+  });
+
+  it("gives one tag its own blocks, under its name", () => {
+    const ics = make("registrar");
+    expect(lines(ics).filter((line) => line.startsWith("SUMMARY:"))).toEqual(["SUMMARY:Rings to the best man", "SUMMARY:Ceremony"]);
+    expect(ics).toContain("X-WR-CALNAME:Alex & Sam — County Registrar\r\n");
+  });
+
+  it("refuses a day without the wedding's date rather than inventing one", () => {
+    expect(() => calendar(doc, { date: "", now: NOW })).toThrow("the wedding's date");
+  });
+});
+
+describe("calendar text", () => {
+  it("escapes what the format reserves", () => {
+    expect(escapeText("Drinks; canapés, and a toast\\speech\nthen dinner")).toBe("Drinks\\; canapés\\, and a toast\\\\speech\\nthen dinner");
+  });
+
+  it("folds at 75 octets without splitting a character, and unfolds to what it was", () => {
+    const line = `DESCRIPTION:${"Rosé and café — ".repeat(12)}`;
+    const folded = fold(line);
+    for (const physical of folded.split("\r\n")) expect(new TextEncoder().encode(physical).length).toBeLessThanOrEqual(75);
+    expect(folded.split("\r\n").slice(1).every((physical) => physical.startsWith(" "))).toBe(true);
+    expect(folded.replace(/\r\n /g, "")).toBe(line);
+  });
+
+  it("leaves a short line alone", () => {
+    expect(fold("SUMMARY:Ceremony")).toBe("SUMMARY:Ceremony");
+  });
+});
diff --git a/suite/apps/cadence/render/ics/calendar.ts b/suite/apps/cadence/render/ics/calendar.ts
new file mode 100644
index 00000000..1f4d049f
--- /dev/null
+++ b/suite/apps/cadence/render/ics/calendar.ts
@@ -0,0 +1,117 @@
+import { tagLabel } from "../../core/model/tags";
+import type { TimelineDoc } from "../../core/model/types";
+import { resolve } from "../../core/schedule/resolve";
+
+/**
+ * The day as a calendar file (RFC 5545): every block, or one tag's — a
+ * supplier's own part of the day, for their own calendar.
+ *
+ * Times are the venue's clock, written as local times with no zone ("floating"
+ * in the RFC's word): the ceremony at 13:30 is at 13:30 on every phone, as it
+ * is in the Binder. Not UTC, because turning the venue's clock into UTC needs
+ * the day's offset, which a wedding may not have set — and the venue's clock
+ * is the one everybody there on the day is reading.
+ */
+
+export interface CalendarOptions {
+  /** The wedding's date, `YYYY-MM-DD`: the wedding's own, never the timeline's placeholder. */
+  date: string;
+  /** One tag's blocks; every block when absent. */
+  tag?: string;
+  /** When the file was made. Every event carries it. */
+  now: Date;
+}
+
+const CRLF = "\r\n";
+
+/** Text as a calendar reads it: backslashes, semicolons, commas and line breaks escaped. */
+export function escapeText(text: string): string {
+  return text.replace(/\\/g, "\\\\").replace(/;/g, "\\;").replace(/,/g, "\\,").replace(/\r?\n/g, "\\n");
+}
+
+/** A line folded at 75 octets, as the RFC asks, and never through a character. */
+export function fold(line: string): string {
+  const encoder = new TextEncoder();
+  const lines: string[] = [];
+  let current = "";
+  let octets = 0;
+  for (const char of line) {
+    const size = encoder.encode(char).length;
+    // A continuation starts with a space, which counts.
+    const limit = lines.length === 0 ? 75 : 74;
+    if (octets + size > limit) {
+      lines.push(current);
+      current = "";
+      octets = 0;
+    }
+    current += char;
+    octets += size;
+  }
+  lines.push(current);
+  return lines.join(`${CRLF} `);
+}
+
+const pad = (n: number, width = 2) => String(n).padStart(width, "0");
+
+/** A minute of the day, on the wedding's date, as a local time: past midnight is the next day. */
+function localTime(date: string, minutes: number): string {
+  const [year, month, day] = date.split("-").map(Number);
+  const at = new Date(Date.UTC(year!, month! - 1, day!, 0, minutes));
+  return `${at.getUTCFullYear()}${pad(at.getUTCMonth() + 1)}${pad(at.getUTCDate())}T${pad(at.getUTCHours())}${pad(at.getUTCMinutes())}00`;
+}
+
+const stamp = (now: Date) => now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}/, "");
+
+const slug = (text: string) =>
+  text
+    .toLowerCase()
+    .replace(/&/g, "and")
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "");
+
+export function calendar(doc: TimelineDoc, options: CalendarOptions): string {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(options.date)) throw new Error("A calendar needs the wedding's date.");
+
+  const positions = new Map(resolve(doc).map((entry) => [entry.id, entry]));
+  const couple = doc.day.coupleNames.trim();
+  const title = [couple || "The wedding", options.tag === undefined ? "" : tagLabel(doc, options.tag)].filter(Boolean).join(" — ");
+  // Stable, so importing the file again updates the events rather than doubling
+  // them; and particular to this wedding, because two weddings' days can share
+  // block ids when one was started from the other's running order.
+  const uidSuffix = `${options.date}.${slug(couple) || "wedding"}@trousseau`;
+
+  const events = doc.blocks
+    .filter((block) => options.tag === undefined || block.tags.includes(options.tag))
+    .flatMap((block) => {
+      const at = positions.get(block.id);
+      return at ? [{ block, at }] : [];
+    })
+    .sort((a, b) => a.at.startMin - b.at.startMin)
+    .flatMap(({ block, at }) => [
+      "BEGIN:VEVENT",
+      `UID:${block.id}.${uidSuffix}`,
+      `DTSTAMP:${stamp(options.now)}`,
+      `DTSTART:${localTime(options.date, at.startMin)}`,
+      // An end only where there is a length: the RFC wants it after the start,
+      // and an event with only a start is exactly what a moment is.
+      ...(at.contentEndMin > at.startMin ? [`DTEND:${localTime(options.date, at.contentEndMin)}`] : []),
+      `SUMMARY:${escapeText(block.label)}`,
+      ...(block.location.trim() ? [`LOCATION:${escapeText(block.location.trim())}`] : []),
+      ...(block.notes.trim() ? [`DESCRIPTION:${escapeText(block.notes.trim())}`] : []),
+      "END:VEVENT",
+    ]);
+
+  return [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    "PRODID:-//Trousseau//Timeline//EN",
+    "CALSCALE:GREGORIAN",
+    "METHOD:PUBLISH",
+    `X-WR-CALNAME:${escapeText(title)}`,
+    ...events,
+    "END:VCALENDAR",
+  ]
+    .map(fold)
+    .join(CRLF)
+    .concat(CRLF);
+}
diff --git a/suite/apps/cadence/state/sliceBridge.test.ts b/suite/apps/cadence/state/sliceBridge.test.ts
index 8fea8507..f0ee4f90 100644
--- a/suite/apps/cadence/state/sliceBridge.test.ts
+++ b/suite/apps/cadence/state/sliceBridge.test.ts
@@ -72,3 +72,23 @@ test("every edit republishes the resolved day, for Delegation and the Binder to
   const day = useTrousseauStore.getState().doc.day;
   expect(day?.blocks.map((block) => [block.label, block.startMin])).toEqual([["Ceremony", 810]]);
 });
+
+/**
+ * Clocks nobody has set stay unset.
+ *
+ * The Timeline used to fill a missing offset with British Summer Time and
+ * write that back into the wedding with its next edit — renaming a block was
+ * enough — so a guess became the wedding's clocks, shown in the Day panel as
+ * if chosen, and trusted by the Binder over the phone's own.
+ */
+test("an unset offset stays unset through a Timeline edit, and one set is kept", () => {
+  open({ date: "2028-12-12" });
+  expect(useTrousseauStore.getState().doc.event.utcOffsetMin).toBeNull();
+
+  useStore.getState().addBlock("Main day", { label: "Ceremony" });
+  expect(useTrousseauStore.getState().doc.event.utcOffsetMin).toBeNull();
+  expect(currentDoc().day.utcOffsetMin).toBeNull();
+
+  useStore.getState().setDay({ utcOffsetMin: 0 });
+  expect(useTrousseauStore.getState().doc.event.utcOffsetMin).toBe(0);
+});
diff --git a/suite/apps/cadence/state/store.test.ts b/suite/apps/cadence/state/store.test.ts
index 77108f8a..16087ff4 100644
--- a/suite/apps/cadence/state/store.test.ts
+++ b/suite/apps/cadence/state/store.test.ts
@@ -117,6 +117,26 @@ describe("document actions", () => {
     expect(doc().styles["order-of-day"].fontFamily).toBe("Crimson Text");
   });
 
+  it("sets a journey's time, changes it from either end, and takes it away", () => {
+    state().setJourney(["The suite", "Orangery"], 5);
+    expect(doc().travel).toEqual([{ between: ["The suite", "Orangery"], minutes: 5 }]);
+    expect(history().past.at(-1)?.label).toBe("a journey's time");
+
+    state().setJourney(["orangery", "the suite"], 8);
+    expect(doc().travel).toEqual([{ between: ["The suite", "Orangery"], minutes: 8 }]);
+
+    state().setJourney(["Orangery", "The suite"], null);
+    expect(doc().travel).toEqual([]);
+  });
+
+  it("puts nothing on the history for taking away a journey nobody typed", () => {
+    const before = doc();
+    const steps = history().past.length;
+    state().setJourney(["The suite", "Lawn"], null);
+    expect(doc()).toBe(before);
+    expect(history().past).toHaveLength(steps);
+  });
+
   it("adds a lane once", () => {
     state().addLane("Children");
     state().addLane("Children");
diff --git a/suite/apps/cadence/state/store.ts b/suite/apps/cadence/state/store.ts
index 94db7ae3..0ab3605e 100644
--- a/suite/apps/cadence/state/store.ts
+++ b/suite/apps/cadence/state/store.ts
@@ -21,6 +21,7 @@ import {
   type Conflict,
 } from "../core/schedule/conflicts";
 import { byId, resolve, type ResolvedBlock } from "../core/schedule/resolve";
+import { withJourney } from "../core/schedule/travel";
 import { slack as computeSlack, type SlackReport } from "../core/schedule/slack";
 import { whatIf, type Change, type WhatIf } from "../core/schedule/whatIf";
 import { sunForDay, type SunTimes } from "../core/sun/solar";
@@ -100,6 +101,8 @@ export interface StoreState {
   setDay: (patch: Partial<DaySettings>) => void;
   setTagDetail: (detail: TagDetail) => void;
   removeTagDetail: (tag: string) => void;
+  /** Minutes between two places, or null to stop checking them. */
+  setJourney: (between: [string, string], minutes: number | null) => void;
   setStyle: (output: OutputId, patch: Partial<StyleSpec>) => void;
   addFont: (font: UploadedFont) => void;
   removeFont: (blobKey: string) => void;
@@ -255,6 +258,12 @@ export const useStore = create<StoreState>((set, get) => {
         };
       }),
 
+    setJourney: (between, minutes) =>
+      edit("a journey's time", (doc) => {
+        const travel = withJourney(doc.travel, between, minutes);
+        return travel === doc.travel ? doc : { ...doc, travel };
+      }),
+
     removeTagDetail: (tag) =>
       edit("removing a supplier's details", (doc) => ({
         ...doc,
diff --git a/suite/apps/cadence/ui/ExportBar.module.css b/suite/apps/cadence/ui/ExportBar.module.css
index ea9a20f3..805b611f 100644
--- a/suite/apps/cadence/ui/ExportBar.module.css
+++ b/suite/apps/cadence/ui/ExportBar.module.css
@@ -1,6 +1,6 @@
 .bar {
   display: flex;
-  align-items: center;
+  flex-direction: column;
   gap: var(--sp-2);
   flex: none;
   padding: var(--sp-3);
@@ -8,6 +8,13 @@
   max-width: 420px;
 }
 
+/* The printed pieces on one line, the calendar on the next. */
+.group {
+  display: flex;
+  align-items: center;
+  gap: var(--sp-2);
+}
+
 .select {
   padding: 5px var(--sp-2);
   border: 1px solid var(--border);
diff --git a/suite/apps/cadence/ui/ExportBar.tsx b/suite/apps/cadence/ui/ExportBar.tsx
index f5f17d12..ef040d4d 100644
--- a/suite/apps/cadence/ui/ExportBar.tsx
+++ b/suite/apps/cadence/ui/ExportBar.tsx
@@ -1,10 +1,13 @@
 import { useState } from "react";
 import type { OutputId } from "../core/model/types";
+import { tagLabel, usedTags } from "../core/model/tags";
 import { blockingConflicts } from "../core/schedule/conflicts";
+import { calendar } from "../render/ics/calendar";
 import { browserFontSource } from "../render/pdf/fontSource";
 import { getBlob } from "../state/blobStore";
 import { useSchedule, useStore, useTimelineDoc } from "../state/store";
 import { Button } from "@/components/ui/fields";
+import { useTrousseauStore } from "@/lib/store/useTrousseauStore";
 import styles from "./ExportBar.module.css";
 
 const FILENAMES: Record<OutputId, string> = {
@@ -21,6 +24,11 @@ export function ExportBar() {
   const setUi = useStore((state) => state.setUi);
   const setNotice = useStore((state) => state.setNotice);
   const [busy, setBusy] = useState(false);
+  // "" is the whole day; otherwise one tag's part of it.
+  const [calendarTag, setCalendarTag] = useState("");
+  // The wedding's own date. The timeline's has a placeholder until one is set,
+  // and a calendar on the wrong day is worse than none.
+  const weddingDate = useTrousseauStore((state) => state.doc.event.date);
 
   const blocking = blockingConflicts(schedule.conflicts);
   const empty = doc.blocks.length === 0;
@@ -30,6 +38,37 @@ export function ExportBar() {
       ? `Fix ${blocking.length} clash${blocking.length === 1 ? "" : "es"} first — a printed sheet that contradicts itself is worse than none.`
       : null;
 
+  const slug = (text: string) =>
+    text
+      .toLowerCase()
+      .replace(/&/g, "and")
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-|-$/g, "");
+  const fileStem = slug(doc.day.coupleNames) || "cadence";
+
+  const save = (blob: Blob, filename: string) => {
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filename;
+    document.body.append(link);
+    link.click();
+    link.remove();
+    URL.revokeObjectURL(url);
+  };
+
+  const calendarReason = reason ?? (weddingDate ? null : "Set the wedding's date first: a calendar needs the day it is on.");
+  const tags = usedTags(doc);
+
+  const downloadCalendar = () => {
+    const tag = calendarTag === "" ? undefined : calendarTag;
+    const text = calendar(doc, { date: weddingDate, now: new Date(), ...(tag === undefined ? {} : { tag }) });
+    save(
+      new Blob([text], { type: "text/calendar;charset=utf-8" }),
+      `${fileStem}-${tag === undefined ? "the-day" : slug(tagLabel(doc, tag)) || "tag"}.ics`,
+    );
+  };
+
   const download = async (piece: OutputId | "timeline") => {
     setBusy(true);
     try {
@@ -52,20 +91,10 @@ export function ExportBar() {
                 ? await (await import("../render/pdf/orderOfDay")).renderOrderOfDay(doc, { fontSource })
                 : await (await import("../render/pdf/contactSheet")).renderContactSheet(doc, { fontSource, generatedOn });
 
-      const slug = (doc.day.coupleNames || "cadence")
-        .toLowerCase()
-        .replace(/&/g, "and")
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-|-$/g, "");
-
-      const url = URL.createObjectURL(new Blob([bytes as BlobPart], { type: "application/pdf" }));
-      const link = document.createElement("a");
-      link.href = url;
-      link.download = `${slug}-${piece === "timeline" ? "timeline" : FILENAMES[piece]}.pdf`;
-      document.body.append(link);
-      link.click();
-      link.remove();
-      URL.revokeObjectURL(url);
+      save(
+        new Blob([bytes as BlobPart], { type: "application/pdf" }),
+        `${fileStem}-${piece === "timeline" ? "timeline" : FILENAMES[piece]}.pdf`,
+      );
     } catch (error) {
       setNotice(`The PDF could not be made: ${error instanceof Error ? error.message : "unknown problem"}`);
     } finally {
@@ -75,37 +104,62 @@ export function ExportBar() {
 
   return (
     <div data-tour="timeline.export" className={styles.bar}>
-      <select
-        className={styles.select}
-        value={output}
-        aria-label="Printed piece"
-        onChange={(event) => setUi({ sheetOutput: event.target.value as OutputId })}
-      >
-        {doc.outputs.map((spec) => (
-          <option key={spec.id} value={spec.id}>
-            {spec.label}
-          </option>
-        ))}
-      </select>
+      <div className={styles.group}>
+        <select
+          className={styles.select}
+          value={output}
+          aria-label="Printed piece"
+          onChange={(event) => setUi({ sheetOutput: event.target.value as OutputId })}
+        >
+          {doc.outputs.map((spec) => (
+            <option key={spec.id} value={spec.id}>
+              {spec.label}
+            </option>
+          ))}
+        </select>
+
+        <Button
+          variant="primary"
+          disabled={busy || reason !== null}
+          onClick={() => void download(output)}
+          {...(reason === null ? {} : { title: reason })}
+        >
+          {busy ? "Making the PDF…" : "Download PDF"}
+        </Button>
 
-      <Button
-        variant="primary"
-        disabled={busy || reason !== null}
-        onClick={() => void download(output)}
-        {...(reason === null ? {} : { title: reason })}
-      >
-        {busy ? "Making the PDF…" : "Download PDF"}
-      </Button>
+        <Button
+          disabled={busy || reason !== null}
+          onClick={() => void download("timeline")}
+          title={reason ?? "The whole day on one page, lane by lane."}
+        >
+          Download timeline
+        </Button>
+      </div>
 
-      <Button
-        disabled={busy || reason !== null}
-        onClick={() => void download("timeline")}
-        title={reason ?? "The whole day on one page, lane by lane."}
-      >
-        Download timeline
-      </Button>
+      <div className={styles.group}>
+        <select
+          className={styles.select}
+          value={calendarTag}
+          aria-label="Calendar for"
+          onChange={(event) => setCalendarTag(event.target.value)}
+        >
+          <option value="">The whole day</option>
+          {tags.map((summary) => (
+            <option key={summary.tag} value={summary.tag}>
+              {tagLabel(doc, summary.tag)}
+            </option>
+          ))}
+        </select>
+        <Button
+          disabled={calendarReason !== null}
+          onClick={downloadCalendar}
+          title={calendarReason ?? "For a phone's calendar: the whole day, or one supplier's part of it."}
+        >
+          Download calendar
+        </Button>
+      </div>
 
-      {reason && <span className={styles.reason}>{reason}</span>}
+      {(reason ?? calendarReason) && <span className={styles.reason}>{reason ?? calendarReason}</span>}
     </div>
   );
 }
diff --git a/suite/apps/cadence/ui/Sidebar.tsx b/suite/apps/cadence/ui/Sidebar.tsx
index df2aee51..04a7128c 100644
--- a/suite/apps/cadence/ui/Sidebar.tsx
+++ b/suite/apps/cadence/ui/Sidebar.tsx
@@ -4,6 +4,7 @@ import { FontsPanel } from "./panels/FontsPanel";
 import { InspectorPanel } from "./panels/InspectorPanel";
 import { StylePanel } from "./panels/StylePanel";
 import { TagsPanel } from "./panels/TagsPanel";
+import { TravelPanel } from "./panels/TravelPanel";
 import styles from "./Sidebar.module.css";
 
 export function Sidebar() {
@@ -13,6 +14,7 @@ export function Sidebar() {
       <BlocksPanel />
       <InspectorPanel />
       <TagsPanel />
+      <TravelPanel />
       <StylePanel />
       <FontsPanel />
     </aside>
diff --git a/suite/apps/cadence/ui/panels/DayPanel.tsx b/suite/apps/cadence/ui/panels/DayPanel.tsx
index d4278a27..a8eebf82 100644
--- a/suite/apps/cadence/ui/panels/DayPanel.tsx
+++ b/suite/apps/cadence/ui/panels/DayPanel.tsx
@@ -71,9 +71,14 @@ export function DayPanel() {
       <Field label="Clocks" hint="Entered, not guessed. British Summer Time is UTC+1.">
         <select
           className={styles.date}
-          value={doc.day.utcOffsetMin}
+          // "" until chosen, so the first choice is a change even when it is
+          // British Summer Time, and nothing is shown as chosen that was not.
+          value={doc.day.utcOffsetMin ?? ""}
           onChange={(event) => setDay({ utcOffsetMin: Number(event.target.value) })}
         >
+          <option value="" disabled>
+            Not set
+          </option>
           {OFFSETS.map((offset) => (
             <option key={offset.value} value={offset.value}>
               {offset.label}
@@ -83,7 +88,9 @@ export function DayPanel() {
       </Field>
 
       <p className={styles.sun}>
-        {sun?.sunsetMin == null
+        {doc.day.utcOffsetMin === null
+          ? "Set the clocks to see sunset and golden hour."
+          : sun?.sunsetMin == null
           ? "The sun does not set at this latitude on this date."
           : `Sunset ${formatClock(sun.sunsetMin)}, golden hour from ${formatClock(sun.goldenHourStartMin ?? sun.sunsetMin)}.`}
       </p>
diff --git a/suite/apps/cadence/ui/panels/TravelPanel.module.css b/suite/apps/cadence/ui/panels/TravelPanel.module.css
new file mode 100644
index 00000000..714e22c0
--- /dev/null
+++ b/suite/apps/cadence/ui/panels/TravelPanel.module.css
@@ -0,0 +1,72 @@
+.hint,
+.empty {
+  margin: 0 0 var(--sp-2);
+  font-size: var(--text-sm);
+  color: var(--text-muted);
+}
+
+.list {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.row {
+  display: flex;
+  align-items: center;
+  gap: var(--sp-2);
+  padding: 4px 0;
+  font-size: var(--text-sm);
+}
+
+.places {
+  display: flex;
+  flex: 1;
+  flex-direction: column;
+  min-width: 0;
+}
+
+.name {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.who {
+  font-size: var(--text-xs);
+  color: var(--text-muted);
+}
+
+.minutes {
+  flex: none;
+  width: 4.5rem;
+}
+
+.unit {
+  flex: none;
+  font-size: var(--text-xs);
+  color: var(--text-muted);
+}
+
+.unused {
+  margin-top: var(--sp-3);
+  padding-top: var(--sp-2);
+  border-top: 1px solid var(--border);
+}
+
+.unusedTitle {
+  margin: 0 0 var(--sp-1);
+  font-size: var(--text-xs);
+  font-weight: 600;
+  color: var(--text-muted);
+}
+
+.unusedRow {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--sp-2);
+  padding: 2px 0;
+  font-size: var(--text-sm);
+  color: var(--text-muted);
+}
diff --git a/suite/apps/cadence/ui/panels/TravelPanel.tsx b/suite/apps/cadence/ui/panels/TravelPanel.tsx
new file mode 100644
index 00000000..402754f3
--- /dev/null
+++ b/suite/apps/cadence/ui/panels/TravelPanel.tsx
@@ -0,0 +1,73 @@
+import { useMemo } from "react";
+import { pairKey, travelPairs } from "../../core/schedule/travel";
+import { useSchedule, useStore, useTimelineDoc } from "../../state/store";
+import { Button, Panel } from "@/components/ui/fields";
+import { NumberInput } from "@/components/ui/NumberInput";
+import fields from "@/components/ui/fields.module.css";
+import styles from "./TravelPanel.module.css";
+
+/**
+ * How long it takes to get between the places the day moves between.
+ *
+ * Only the pairs somebody actually travels between are listed, so there is
+ * nothing to invent: a blank is a journey nobody is checked against, which is
+ * right for two rooms next door to each other.
+ */
+export function TravelPanel() {
+  const doc = useTimelineDoc();
+  const { resolved } = useSchedule();
+  const setJourney = useStore((state) => state.setJourney);
+  const { used, unused } = useMemo(() => travelPairs(resolved, doc), [resolved, doc]);
+
+  return (
+    <Panel title="Travel">
+      <p className={styles.hint}>
+        How long it takes to get from one place to the other. Anybody tagged at both is checked against it. To have
+        the two of you checked, tag your own blocks — “couple”, say.
+      </p>
+
+      {used.length === 0 && <p className={styles.empty}>Tag blocks in two different places and the journey between them appears here.</p>}
+
+      <ul className={styles.list}>
+        {used.map((pair) => {
+          const [from, to] = pair.between;
+          return (
+            <li key={pairKey(from, to)} className={styles.row}>
+              <span className={styles.places}>
+                <span className={styles.name}>
+                  {from} – {to}
+                </span>
+                <span className={styles.who}>{pair.who.join(", ")}</span>
+              </span>
+              <NumberInput
+                label={`Minutes between ${from} and ${to}`}
+                value={pair.minutes}
+                onCommit={(minutes) => setJourney(pair.between, minutes)}
+                className={`${fields.input} ${styles.minutes}`}
+              />
+              <span className={styles.unit}>min</span>
+            </li>
+          );
+        })}
+      </ul>
+
+      {unused.length > 0 && (
+        <div className={styles.unused}>
+          <h3 className={styles.unusedTitle}>No longer on the day</h3>
+          <ul className={styles.list}>
+            {unused.map((journey) => (
+              <li key={pairKey(...journey.between)} className={styles.unusedRow}>
+                <span className={styles.name}>
+                  {journey.between[0]} – {journey.between[1]}, {journey.minutes} min
+                </span>
+                <Button variant="quiet" onClick={() => setJourney(journey.between, null)}>
+                  Forget
+                </Button>
+              </li>
+            ))}
+          </ul>
+        </div>
+      )}
+    </Panel>
+  );
+}
diff --git a/suite/apps/fontEngine.test.ts b/suite/apps/fontEngine.test.ts
new file mode 100644
index 00000000..c10c7502
--- /dev/null
+++ b/suite/apps/fontEngine.test.ts
@@ -0,0 +1,77 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { describe, expect, it } from "vitest";
+
+/**
+ * The font engine loads with the tools that measure or embed fonts, never with
+ * the shell every page shares.
+ *
+ * fontkit is 144 KB gzipped. It was on every page — the checklist, the money
+ * page, the front page — because the shared store reads the card design, the
+ * design starts from Place cards' defaults, and one constant among them was
+ * imported from the module that measures text. Measured on a production build:
+ * 522 KB of JavaScript shared by every page, 393 KB once it was cut.
+ *
+ * A grep-shaped test, as `offline.test.ts` is, and for the same reason: what is
+ * being protected is the shape of the imports, which no unit test observes.
+ * Static imports only — `import()` behind `next/dynamic` is exactly how a tool
+ * is kept off the pages that do not use it.
+ */
+
+const ROOT = join(__dirname, "..");
+const ENGINES = new Set(["fontkit", "@pdf-lib/fontkit"]);
+const SHELLS = ["app/layout.tsx", "app/(app)/layout.tsx"];
+
+function resolveSpec(from: string, spec: string): string | null {
+  const base = spec.startsWith("@/") ? join(ROOT, spec.slice(2)) : spec.startsWith(".") ? join(dirname(from), spec) : null;
+  if (base === null) return null;
+  for (const candidate of [base, `${base}.ts`, `${base}.tsx`, join(base, "index.ts"), join(base, "index.tsx")]) {
+    if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
+  }
+  return null;
+}
+
+/** What a file imports statically: not `import type`, not `import()`. */
+function staticImports(file: string): string[] {
+  const source = readFileSync(file, "utf8");
+  const specs: string[] = [];
+  for (const match of source.matchAll(/^\s*(?:import|export)\s+(?!type\b)[^;]*?\bfrom\s+["']([^"']+)["']/gm)) specs.push(match[1]!);
+  for (const match of source.matchAll(/^\s*import\s+["']([^"']+)["']/gm)) specs.push(match[1]!);
+  return specs;
+}
+
+/** The chain of files from `start` to one importing a font engine, or null. */
+function chainToEngine(start: string): string[] | null {
+  const cameFrom = new Map<string, string | null>([[start, null]]);
+  const queue = [start];
+  while (queue.length > 0) {
+    const file = queue.shift()!;
+    for (const spec of staticImports(file)) {
+      if (ENGINES.has(spec)) {
+        const chain = [spec];
+        for (let at: string | null = file; at !== null; at = cameFrom.get(at) ?? null) chain.unshift(relative(ROOT, at));
+        return chain;
+      }
+      const next = resolveSpec(file, spec);
+      if (next && !cameFrom.has(next)) {
+        cameFrom.set(next, file);
+        queue.push(next);
+      }
+    }
+  }
+  return null;
+}
+
+describe("the font engine", () => {
+  it.each(SHELLS)("is not reachable from %s", (shell) => {
+    expect(chainToEngine(join(ROOT, shell))).toBeNull();
+  });
+
+  it("is still found where it is used, so the walk is not silently finding nothing", () => {
+    expect(chainToEngine(join(ROOT, "apps/plaque/core/text/fit.ts"))).toEqual([
+      "apps/plaque/core/text/fit.ts",
+      "apps/plaque/core/text/measure.ts",
+      "fontkit",
+    ]);
+  });
+});
diff --git a/suite/apps/plaque/core/data/suite.test.ts b/suite/apps/plaque/core/data/suite.test.ts
index 9886af11..0eeed42e 100644
--- a/suite/apps/plaque/core/data/suite.test.ts
+++ b/suite/apps/plaque/core/data/suite.test.ts
@@ -5,7 +5,7 @@ import { parseCsv } from "@/lib/data/csv";
 import { paginate } from "../imposition/paginate";
 import { defaultCard, defaultSheet, newId } from "../template/defaults";
 import { makeResolveOptions } from "../template/resolve";
-import { DEFAULT_FIT } from "../text/fit";
+import { DEFAULT_FIT } from "../template/defaults";
 import { loadFont, type LoadedFont } from "../text/measure";
 import type {
   CardSpec,
diff --git a/suite/apps/plaque/core/template/defaults.ts b/suite/apps/plaque/core/template/defaults.ts
index a98f67db..22201a26 100644
--- a/suite/apps/plaque/core/template/defaults.ts
+++ b/suite/apps/plaque/core/template/defaults.ts
@@ -2,8 +2,22 @@ import { DEFAULT_FONT_ID } from "../../assets/fonts";
 import { BUNDLED_ICONS } from "../../assets/icons";
 import { defaultNameTemplate, guessMapping } from "../csv/guessMapping";
 import { panelBounds } from "../geometry/fold";
-import { DEFAULT_FIT } from "../text/fit";
-import type { CardElement, CardSpec, ElementId, IconRule, SheetSpec, Template } from "../types";
+import type { CardElement, CardSpec, ElementId, FitConfig, IconRule, SheetSpec, Template } from "../types";
+
+/**
+ * How a text element fits its box until someone says otherwise.
+ *
+ * Here rather than beside the fitter in `text/fit`, because that module
+ * measures with fontkit, and every page loads these defaults: the shared store
+ * reads the card design, which starts from them. Importing one constant from
+ * there put 144 KB of font engine on every page of the app.
+ */
+export const DEFAULT_FIT: FitConfig = {
+  mode: "shrink",
+  minFontSizePt: 8,
+  maxLines: 2,
+  anchor: "align",
+};
 
 let fallbackCounter = 0;
 
diff --git a/suite/apps/plaque/core/template/overrides.test.ts b/suite/apps/plaque/core/template/overrides.test.ts
index 46ffbc45..41b06190 100644
--- a/suite/apps/plaque/core/template/overrides.test.ts
+++ b/suite/apps/plaque/core/template/overrides.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import type { Template, TextElement } from "../types";
-import { DEFAULT_FIT } from "../text/fit";
+import { DEFAULT_FIT } from "./defaults";
 import {
   hasOverrides,
   orphanedOverrides,
diff --git a/suite/apps/plaque/core/template/rebind.test.ts b/suite/apps/plaque/core/template/rebind.test.ts
index 3c9aa059..2dc6c191 100644
--- a/suite/apps/plaque/core/template/rebind.test.ts
+++ b/suite/apps/plaque/core/template/rebind.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { DEFAULT_FIT } from "../text/fit";
+import { DEFAULT_FIT } from "./defaults";
 import type { IconElement, ListElement, Template, TextElement } from "../types";
 import { rebindTemplate, unboundTokens } from "./rebind";
 
diff --git a/suite/apps/plaque/core/template/registry.ts b/suite/apps/plaque/core/template/registry.ts
index 640c135e..021f1bb6 100644
--- a/suite/apps/plaque/core/template/registry.ts
+++ b/suite/apps/plaque/core/template/registry.ts
@@ -1,7 +1,6 @@
 import { DEFAULT_FONT_ID } from "../../assets/fonts";
 import type { CardElement, CardSpec, ElementId } from "../types";
-import { DEFAULT_FIT } from "../text/fit";
-import { defaultIconRules } from "./defaults";
+import { DEFAULT_FIT, defaultIconRules } from "./defaults";
 
 /**
  * One table describing every element kind (F3).
diff --git a/suite/apps/plaque/core/text/fit.test.ts b/suite/apps/plaque/core/text/fit.test.ts
index 955b1cde..0778b35a 100644
--- a/suite/apps/plaque/core/text/fit.test.ts
+++ b/suite/apps/plaque/core/text/fit.test.ts
@@ -1,7 +1,8 @@
 import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
 import type { FitConfig } from "../types";
-import { DEFAULT_FIT, fitBlock, fitText, type FitInput } from "./fit";
+import { fitBlock, fitText, type FitInput } from "./fit";
+import { DEFAULT_FIT } from "../template/defaults";
 import { loadFont, measureWidth, widestLineMm } from "./measure";
 
 const crimson = loadFont(
diff --git a/suite/apps/plaque/core/text/fit.ts b/suite/apps/plaque/core/text/fit.ts
index ae17ea95..b2c9ba14 100644
--- a/suite/apps/plaque/core/text/fit.ts
+++ b/suite/apps/plaque/core/text/fit.ts
@@ -123,10 +123,3 @@ export function fitBlock(font: LoadedFont, input: FitBlockInput): FitOutcome {
 function round(pt: Pt): Pt {
   return Math.round(pt * 100) / 100;
 }
-
-export const DEFAULT_FIT: FitConfig = {
-  mode: "shrink",
-  minFontSizePt: 8,
-  maxLines: 2,
-  anchor: "align",
-};
diff --git a/suite/components/bar/BarBoard.tsx b/suite/components/bar/BarBoard.tsx
new file mode 100644
index 00000000..bb27dee5
--- /dev/null
+++ b/suite/components/bar/BarBoard.tsx
@@ -0,0 +1,337 @@
+"use client";
+
+import { useState } from "react";
+import { FileSpreadsheet, ListChecks, RotateCcw } from "lucide-react";
+import { Button, Check, Panel, Segmented, SelectField } from "@/components/ui/controls";
+import { NumberInput } from "@/components/ui/NumberInput";
+import { ToolUndo } from "@/components/shell/ToolUndo";
+import {
+  chooseKind,
+  resetMix,
+  setCrowd,
+  setFigure,
+  setHave,
+  setPeople,
+  setPrice,
+  setShare,
+  setShop,
+  setWholeCases,
+} from "@/lib/bar/actions";
+import { CROWD_NAMES, FIGURE_DEFAULTS, KIND_NAMES, LINES, MIXES, SHOP_NAMES } from "@/lib/bar/defaults";
+import { buyWords, forWords, shoppingCsv, shoppingList, spendWords } from "@/lib/bar/rows";
+import { barSum, figure, mixOf, type LineSum } from "@/lib/bar/sum";
+import { download } from "@/lib/data/file";
+import { useBar, useEvent, useStatus, useWriters } from "@/lib/model/useSuite";
+import { useTrousseauStore } from "@/lib/store/useTrousseauStore";
+import { BAR_KINDS, CROWDS, POURS, SHOPS, type Bar, type BarKind, type Figure, type MixedPart, type Pour } from "@/lib/model/types";
+
+const CONTROL = "rounded border border-charcoal/15 bg-parchment px-2 py-1 text-sm text-charcoal tabular-nums focus:border-gold";
+
+const number = (n: number) => n.toLocaleString("en-GB", { maximumFractionDigits: 1 });
+const money = (n: number) => Math.round(n).toLocaleString("en-GB");
+
+const PART_WORDS: Record<MixedPart, string> = { reception: "at the reception", evening: "in the evening" };
+
+const pourName = (kind: BarKind, pour: Pour): string =>
+  ({ fizz: "Fizz", wine: "Wine", beer: "Beer and cider", spirit: kind === "cocktails" ? "Cocktails" : "Spirits" })[pour];
+
+/**
+ * The drinks a couple buys themselves: how much of each, in what a UK shop
+ * sells, and roughly what it costs. Every figure the sum uses is on screen,
+ * changeable, and put back in one click. It keeps no copy: the amounts are
+ * worked out from the guest list and the figures on every render.
+ */
+export function BarBoard() {
+  const status = useStatus();
+  const bar = useBar();
+  const sum = useTrousseauStore((s) => barSum(s.doc));
+  const event = useEvent();
+  const { setBar } = useWriters();
+  const [note, setNote] = useState<string | null>(null);
+
+  if (status !== "ready") return null;
+
+  const stem = (event.coupleNames || "wedding").toLowerCase().replace(/&/g, "and").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "wedding";
+  const print = async () => {
+    setNote(null);
+    try {
+      const [{ renderShoppingList }, { browserFontSource }] = await Promise.all([
+        import("@/lib/bar/render/pdf/shoppingList"),
+        import("@/apps/brigade/render/pdf/fontSource"),
+      ]);
+      const bytes = await renderShoppingList(shoppingList(bar, sum), {
+        fontSource: browserFontSource(),
+        coupleNames: event.coupleNames,
+        forWhom: forWords(sum),
+        spend: spendWords(sum),
+        generatedOn: `Made with Trousseau, ${new Date().toLocaleDateString()}`,
+      });
+      download(`${stem}-drinks.pdf`, new Blob([bytes as BlobPart], { type: "application/pdf" }));
+    } catch (cause) {
+      setNote(cause instanceof Error ? cause.message : "The page could not be made.");
+    }
+  };
+
+  const write = (next: Bar, label: string) => setBar(next, { label });
+  const { heads, each } = sum;
+
+  const field = (id: Figure) => (
+    <FigureField
+      key={id}
+      bar={bar}
+      id={id}
+      onChange={(value) => write(setFigure(bar, id, value), value === null ? "putting a figure back" : "a figure for the bar")}
+    />
+  );
+
+  return (
+    <div className="flex h-[calc(100dvh-var(--shell-header-h))]">
+      <ToolUndo />
+      <div data-tour="bar.figures" className="w-[26rem] shrink-0 overflow-y-auto border-r border-charcoal/10 p-4">
+        <h2 className="mb-4 font-display text-2xl text-charcoal">The figures</h2>
+        <Panel title="Who">
+          <div className="flex items-center justify-between gap-2 text-sm text-charcoal">
+            <span>Coming</span>
+            <NumberInput
+              label="How many are coming"
+              value={bar.people}
+              placeholder={String(heads.listed)}
+              onCommit={(people) => write(setPeople(bar, people), "how many are coming")}
+              className={`${CONTROL} w-20`}
+            />
+          </div>
+          <p className="mt-1 text-xs text-slate">
+            {heads.typed ? (
+              <>
+                Typed: the guest list has {heads.listed}.{" "}
+                <button type="button" onClick={() => write(setPeople(bar, null), "how many are coming")} className="underline hover:text-charcoal">
+                  Use the guest list
+                </button>
+              </>
+            ) : (
+              "From the guest list: everyone who has not said no."
+            )}
+          </p>
+          <div className="mt-3 flex flex-col gap-2">
+            {field("eveningGuests")}
+            {field("notDrinkingPct")}
+          </div>
+          <p className="mt-2 text-xs text-slate">
+            {heads.drinking} drinking alcohol, {heads.notDrinking} on soft drinks — children, drivers, and anyone who doesn&rsquo;t.
+          </p>
+        </Panel>
+
+        <Panel title="The bar">
+          <SelectField
+            label="What kind of bar"
+            value={bar.kind}
+            onChange={(kind) => write(chooseKind(bar, kind), "the kind of bar")}
+            options={BAR_KINDS.map((kind) => ({ value: kind, label: KIND_NAMES[kind] }))}
+          />
+          <p className="mt-3 mb-1 text-xs text-slate">How much this crowd drinks</p>
+          <Segmented value={bar.crowd} onChange={(crowd) => write(setCrowd(bar, crowd), "the crowd")} options={CROWDS.map((crowd) => ({ value: crowd, label: CROWD_NAMES[crowd] }))} />
+        </Panel>
+
+        <Panel title="The day">
+          <p className="mb-2 text-xs text-slate">Drinks each, for those drinking. Set a part to nothing if you are not buying for it — a venue&rsquo;s own bar.</p>
+          <div className="flex flex-col gap-2">
+            {field("receptionHours")}
+            {field("receptionPerHour")}
+            <Each>{number(each.reception)} each at the reception</Each>
+            {field("toastGlasses")}
+            {field("mealGlasses")}
+            {field("eveningHours")}
+            {field("eveningPerHour")}
+            <Each>{number(each.evening)} each in the evening</Each>
+          </div>
+        </Panel>
+
+        <Panel title="What is poured">
+          <p className="mb-2 text-xs text-slate">The toast is fizz and the meal is wine. The reception and the evening pour a mix, in shares.</p>
+          {(["reception", "evening"] as const).map((part) => (
+            <MixFields key={part} bar={bar} part={part} onChange={write} />
+          ))}
+        </Panel>
+
+        <Panel title="Glasses and measures">
+          <div className="flex flex-col gap-2">
+            {field("fizzGlassMl")}
+            {field("wineGlassMl")}
+            {field("redPct")}
+            {field("spiritMl")}
+            {field("mixerMl")}
+            {field("softMl")}
+            {field("iceKg")}
+          </div>
+        </Panel>
+      </div>
+
+      <div className="min-w-0 flex-1 overflow-y-auto p-4">
+        <div className="flex flex-wrap items-baseline justify-between gap-3">
+          <h2 className="font-display text-2xl text-charcoal">What to buy</h2>
+          <Check
+            label="Round up to whole cases, for sale or return"
+            checked={bar.wholeCases}
+            onChange={(on) => write(setWholeCases(bar, on), "whole cases")}
+          />
+        </div>
+
+        {heads.people + heads.evening === 0 ? (
+          <p className="mt-4 text-sm text-slate">Nobody to buy for yet. Add the guests, or type how many are coming.</p>
+        ) : (
+          <>
+            <table aria-label="What to buy" className="mt-4 w-full text-sm">
+              <thead>
+                <tr className="border-b border-charcoal/10 text-left text-xs tracking-wide text-slate">
+                  <th className="py-1.5 font-normal">Drink</th>
+                  <th className="py-1.5 font-normal whitespace-nowrap">Comes to</th>
+                  <th className="py-1.5 font-normal">Have</th>
+                  <th className="py-1.5 font-normal">To buy</th>
+                  <th className="py-1.5 font-normal">Price</th>
+                  <th className="py-1.5 text-right font-normal">Cost</th>
+                  <th className="py-1.5 pl-3 font-normal">Where</th>
+                </tr>
+              </thead>
+              <tbody>
+                {sum.lines.map((line) => (
+                  <LineRow key={line.line} bar={bar} line={line} onChange={write} />
+                ))}
+              </tbody>
+            </table>
+            <p className="mt-4 text-sm text-charcoal">{spendWords(sum)}</p>
+            <div className="mt-4 flex flex-wrap gap-2">
+              <Button icon={ListChecks} onClick={() => void print()}>
+                Shopping list
+              </Button>
+              <Button icon={FileSpreadsheet} onClick={() => download(`${stem}-drinks.csv`, shoppingCsv(shoppingList(bar, sum)), "text/csv")}>
+                CSV
+              </Button>
+            </div>
+            {note && (
+              <p role="status" className="mt-2 text-xs text-danger">
+                {note}
+              </p>
+            )}
+          </>
+        )}
+      </div>
+    </div>
+  );
+}
+
+function Each({ children }: { children: React.ReactNode }) {
+  return <p className="-mt-1 text-right text-xs text-slate">{children}</p>;
+}
+
+/** One figure: its value, and — when changed — what it usually is, and a way back to it. */
+function FigureField({ bar, id, onChange }: { bar: Bar; id: Figure; onChange: (value: number | null) => void }) {
+  const info = FIGURE_DEFAULTS[id];
+  const changed = bar.figures[id] !== undefined;
+  return (
+    <div className="flex items-center gap-2 text-sm text-charcoal">
+      <span className="min-w-0 flex-1">{info.label}</span>
+      {changed && (
+        <button
+          type="button"
+          onClick={() => onChange(null)}
+          aria-label={`Put ${info.label.toLowerCase()} back to ${info.value}`}
+          title={`Usually ${info.value}`}
+          className="inline-flex items-center gap-1 text-xs text-slate hover:text-charcoal"
+        >
+          <RotateCcw size={11} aria-hidden />
+          {info.value}
+        </button>
+      )}
+      <NumberInput
+        label={info.label}
+        value={figure(bar, id)}
+        step={info.step}
+        onCommit={onChange}
+        className={`${CONTROL} w-20 ${changed ? "border-gold" : ""}`}
+      />
+      <span className="w-12 text-xs text-slate">{info.unit}</span>
+    </div>
+  );
+}
+
+function MixFields({ bar, part, onChange }: { bar: Bar; part: MixedPart; onChange: (next: Bar, label: string) => void }) {
+  const mix = mixOf(bar, part);
+  const total = POURS.reduce((sum, pour) => sum + mix[pour], 0);
+  const changed = bar.mix[part] !== undefined;
+  return (
+    <div className="mb-3">
+      <div className="mb-1 flex items-center justify-between text-xs text-slate">
+        <span>Poured {PART_WORDS[part]}</span>
+        {changed && (
+          <button type="button" onClick={() => onChange(resetMix(bar, part), "what is poured")} className="inline-flex items-center gap-1 hover:text-charcoal">
+            <RotateCcw size={11} aria-hidden />
+            {KIND_NAMES[bar.kind]}&rsquo;s mix
+          </button>
+        )}
+      </div>
+      <div className="grid grid-cols-4 gap-2">
+        {POURS.map((pour) => (
+          <label key={pour} className="text-xs text-slate">
+            {pourName(bar.kind, pour)}
+            <NumberInput
+              label={`${pourName(bar.kind, pour)} ${PART_WORDS[part]}, in percent`}
+              value={mix[pour]}
+              onCommit={(value) => onChange(setShare(bar, part, pour, value ?? MIXES[bar.kind][part][pour]), "what is poured")}
+              className={`${CONTROL} mt-0.5 w-full ${changed ? "border-gold" : ""}`}
+            />
+          </label>
+        ))}
+      </div>
+      {total !== 100 && total > 0 && <p className="mt-1 text-xs text-slate">These add up to {total}: each is taken as its share of that.</p>}
+      {total === 0 && <p className="mt-1 text-xs text-slate">Nothing poured {PART_WORDS[part]}.</p>}
+    </div>
+  );
+}
+
+function LineRow({ bar, line, onChange }: { bar: Bar; line: LineSum; onChange: (next: Bar, label: string) => void }) {
+  const info = LINES[line.line];
+  const { amount, cases } = buyWords(bar, line);
+  return (
+    <tr className="border-b border-charcoal/5 align-middle">
+      <td className="py-1.5 pr-2 text-charcoal">{line.name}</td>
+      <td className="py-1.5 pr-2 text-slate tabular-nums">{line.needed === 0 ? "None" : number(line.needed)}</td>
+      <td className="py-1.5 pr-2">
+        <NumberInput
+          label={`${line.name} you already have, in ${info.units}`}
+          value={line.have === 0 ? null : line.have}
+          onCommit={(have) => onChange(setHave(bar, line.line, have), "what you already have")}
+          className={`${CONTROL} w-16`}
+        />
+      </td>
+      <td className="py-1.5 pr-2 text-charcoal tabular-nums">
+        {amount || "—"}
+        {cases && <span className="block text-xs text-slate">{cases}</span>}
+      </td>
+      <td className="py-1.5 pr-2 whitespace-nowrap">
+        <NumberInput
+          label={`Price of ${line.name.toLowerCase()}, ${info.priceWords}`}
+          value={line.price}
+          step={0.01}
+          onCommit={(price) => onChange(setPrice(bar, line.line, price), "a price")}
+          className={`${CONTROL} w-20`}
+        />
+        <span className="ml-1 text-xs text-slate">{info.per}</span>
+      </td>
+      <td className="py-1.5 text-right text-charcoal tabular-nums">{line.cost === null ? "" : money(line.cost)}</td>
+      <td className="py-1.5 pl-3">
+        <select
+          aria-label={`Where ${line.name.toLowerCase()} is bought`}
+          value={line.shop}
+          onChange={(event) => onChange(setShop(bar, line.line, event.target.value as typeof line.shop), "where it is bought")}
+          className={CONTROL}
+        >
+          {SHOPS.map((shop) => (
+            <option key={shop} value={shop}>
+              {SHOP_NAMES[shop]}
+            </option>
+          ))}
+        </select>
+      </td>
+    </tr>
+  );
+}
diff --git a/suite/components/binder/Binder.tsx b/suite/components/binder/Binder.tsx
index 6919c7e3..12c5adde 100644
--- a/suite/components/binder/Binder.tsx
+++ b/suite/components/binder/Binder.tsx
@@ -5,8 +5,8 @@ import { useEffect, useMemo, useState } from "react";
 import { Phone } from "lucide-react";
 import { useTrousseauStore } from "@/lib/store/useTrousseauStore";
 import { contacts, dayClock, findGuests, nowAndNext, runningOrder, takenKey, type BinderBlock } from "@/lib/binder/binder";
-import { resolveShot } from "@/lib/ensemble/resolve";
-import { readGuests, readSeating, readShots } from "@/lib/model/slices";
+import { resolveMembers } from "@/lib/cast/resolve";
+import { readCast, readGuests, readSeating, readShots } from "@/lib/model/slices";
 import { formatClock } from "@/apps/cadence/core/time/minutes";
 import { longDate } from "@/lib/dates";
 
@@ -253,6 +253,7 @@ function Shots() {
 
   const sections = useMemo(() => {
     const shots = readShots(doc);
+    const cast = readCast(doc);
     const guests = readGuests(doc);
     const seating = readSeating(doc);
     return shots.sections.map((section) => ({
@@ -260,7 +261,7 @@ function Shots() {
       name: section.name,
       shots: section.shots.map((shot) => ({
         id: shot.id,
-        ...resolveShot(shot, guests, seating, shots.cast, shots.customRoles, doc.event),
+        ...resolveMembers(shot, guests, seating, cast.roles, cast.customRoles, doc.event),
       })),
     }));
   }, [doc]);
diff --git a/suite/components/boxes/BoxesBoard.tsx b/suite/components/boxes/BoxesBoard.tsx
new file mode 100644
index 00000000..6611663f
--- /dev/null
+++ b/suite/components/boxes/BoxesBoard.tsx
@@ -0,0 +1,363 @@
+"use client";
+
+import { useMemo, useState } from "react";
+import { FileSpreadsheet, ListChecks, PackagePlus, Plus, Tag, Trash2, X } from "lucide-react";
+import { formatClock } from "@/apps/cadence/core/time/minutes";
+import { Button, Empty, IconButton, NumberField, Panel, SelectField, TextArea, TextField } from "@/components/ui/controls";
+import { NumberInput } from "@/components/ui/NumberInput";
+import { ToolUndo } from "@/components/shell/ToolUndo";
+import { addBox, addItem, moveItem, patchBox, patchItem, removeBox, removeItem, USUAL_BOXES, withUsualBoxes } from "@/lib/boxes/actions";
+import { dayPlaces, find, neededAt, packing, whereBy, type Place } from "@/lib/boxes/view";
+import { boxesCsv, boxRows } from "@/lib/boxes/rows";
+import { download } from "@/lib/data/file";
+import { personName } from "@/lib/model/slices";
+import { useBoxes, useCrew, useEvent, useGuests, useStatus, useWriters } from "@/lib/model/useSuite";
+import { useTrousseauStore } from "@/lib/store/useTrousseauStore";
+import type { Box, Boxes, Crew, Guest } from "@/lib/model/types";
+
+const CONTROL = "rounded border border-charcoal/15 bg-parchment px-2 py-1 text-sm text-charcoal focus:border-gold";
+
+/**
+ * The boxes: what is in each, found in a moment, and where each has to be by
+ * when — the where and the when being the Timeline's, for the block a box is
+ * needed for. It keeps no copy: it reads the wedding and writes it, on the
+ * wedding's one history.
+ */
+export function BoxesBoard() {
+  const status = useStatus();
+  const boxes = useBoxes();
+  const crew = useCrew();
+  const guests = useGuests();
+  const event = useEvent();
+  const places = useTrousseauStore((s) => dayPlaces(s.doc));
+  const { setBoxes } = useWriters();
+  const [selectedId, setSelectedId] = useState<string | null>(null);
+  const [query, setQuery] = useState("");
+  const [note, setNote] = useState<string | null>(null);
+  const found = useMemo(() => find(boxes, query), [boxes, query]);
+
+  if (status !== "ready") return null;
+
+  const selected = boxes.boxes.find((box) => box.id === selectedId) ?? null;
+  const have = new Set(boxes.boxes.map((box) => box.name.trim().toLowerCase()));
+  const usualMissing = USUAL_BOXES.some((usual) => !have.has(usual.name.toLowerCase()));
+
+  const stem = (event.coupleNames || "wedding").toLowerCase().replace(/&/g, "and").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "wedding";
+  const rows = () => boxRows(boxes, places, crew, guests);
+
+  const print = async (what: "labels" | "list") => {
+    setNote(null);
+    try {
+      const { browserFontSource } = await import("@/apps/brigade/render/pdf/fontSource");
+      const fontSource = browserFontSource();
+      const bytes =
+        what === "labels"
+          ? await (await import("@/lib/boxes/render/pdf/labels")).renderBoxLabels(rows(), { fontSource })
+          : await (await import("@/lib/boxes/render/pdf/packingList")).renderPackingList(rows(), {
+              fontSource,
+              coupleNames: event.coupleNames,
+              generatedOn: `Made with Trousseau, ${new Date().toLocaleDateString()}`,
+            });
+      download(`${stem}-${what === "labels" ? "box-labels" : "packing-list"}.pdf`, new Blob([bytes as BlobPart], { type: "application/pdf" }));
+    } catch (cause) {
+      setNote(cause instanceof Error ? cause.message : "The page could not be made.");
+    }
+  };
+
+  const add = () => {
+    const next = addBox(boxes);
+    setBoxes(next, { label: "adding a box" });
+    setSelectedId(next.boxes[next.boxes.length - 1]!.id);
+  };
+
+  return (
+    <div className="flex h-[calc(100dvh-var(--shell-header-h))]">
+      <ToolUndo />
+      <div data-tour="boxes.list" className="flex w-96 shrink-0 flex-col border-r border-charcoal/10">
+        <div className="flex flex-wrap gap-2 border-b border-charcoal/10 p-3">
+          <Button icon={Plus} onClick={add}>
+            Add a box
+          </Button>
+          {usualMissing && (
+            <Button icon={PackagePlus} onClick={() => setBoxes(withUsualBoxes(boxes), { label: "adding the usual boxes" })}>
+              Add the usual boxes
+            </Button>
+          )}
+        </div>
+        {boxes.boxes.length > 0 && (
+          <div className="flex flex-wrap gap-2 border-b border-charcoal/10 p-3">
+            <Button icon={Tag} onClick={() => void print("labels")}>
+              Labels
+            </Button>
+            <Button icon={ListChecks} onClick={() => void print("list")}>
+              Packing list
+            </Button>
+            <Button icon={FileSpreadsheet} onClick={() => download(`${stem}-boxes.csv`, boxesCsv(rows()), "text/csv")}>
+              CSV
+            </Button>
+          </div>
+        )}
+        {note && (
+          <p role="status" className="border-b border-charcoal/10 px-3 py-2 text-xs text-danger">
+            {note}
+          </p>
+        )}
+        <div className="border-b border-charcoal/10 p-3">
+          <TextField label="Find something" value={query} onChange={setQuery} placeholder="Shoes, the rings…" />
+        </div>
+
+        {query.trim() ? (
+          <ul aria-label="Found" className="flex-1 overflow-y-auto p-1.5">
+            {found.length === 0 && <li className="p-2 text-sm text-slate">Not in any box.</li>}
+            {found.map(({ box, item }) => (
+              <li key={`${box.id}-${item?.id ?? "box"}`}>
+                <button
+                  type="button"
+                  onClick={() => setSelectedId(box.id)}
+                  className="w-full rounded px-2 py-1.5 text-left text-sm hover:bg-stone/50"
+                >
+                  <span className="text-charcoal">{item ? item.label : box.name}</span>
+                  <span className="block text-xs text-slate">
+                    {item ? `In box ${box.number}, ${box.name || "with no name"}` : `Box ${box.number}`}
+                  </span>
+                </button>
+              </li>
+            ))}
+          </ul>
+        ) : boxes.boxes.length === 0 ? (
+          <div className="p-4">
+            <Empty>
+              No boxes yet. Add the usual ones — the rings and the paperwork, getting ready, the day&rsquo;s odds and
+              ends, overnight — and change anything in them, or add boxes one at a time.
+            </Empty>
+          </div>
+        ) : (
+          <ol aria-label="The boxes" className="flex-1 overflow-y-auto p-1.5">
+            {boxes.boxes.map((box) => {
+              const { place, lost } = neededAt(box, places);
+              const { packed, total } = packing(box);
+              // Nobody taking it matters only for a box that has somewhere to be.
+              const trouble = lost || (box.blockId !== null && box.personIds.length === 0);
+              return (
+                <li key={box.id}>
+                  <button
+                    type="button"
+                    onClick={() => setSelectedId(box.id)}
+                    className={`w-full rounded px-2 py-1.5 text-left ${box.id === selectedId ? "bg-stone" : "hover:bg-stone/50"}`}
+                  >
+                    <span className="block truncate text-sm text-charcoal">
+                      {box.number}. {box.name || "A box with no name"}
+                      {trouble && <span className="ml-1 text-danger">●</span>}
+                    </span>
+                    <span className="block truncate text-xs text-slate">
+                      {whereBy(place, lost)} · {total === 0 ? "Nothing in it yet" : `${packed} of ${total} packed`}
+                    </span>
+                  </button>
+                </li>
+              );
+            })}
+          </ol>
+        )}
+      </div>
+
+      <div className="min-w-0 flex-1 overflow-y-auto">
+        {selected ? (
+          <BoxInspector
+            box={selected}
+            boxes={boxes}
+            crew={crew}
+            guests={guests}
+            places={places}
+            onChange={setBoxes}
+            onRemoved={() => setSelectedId(null)}
+          />
+        ) : (
+          <div className="flex h-full items-center justify-center">
+            <Empty>{boxes.boxes.length === 0 ? "The boxes appear on the left." : "Pick a box on the left."}</Empty>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+function BoxInspector({
+  box,
+  boxes,
+  crew,
+  guests,
+  places,
+  onChange,
+  onRemoved,
+}: {
+  box: Box;
+  boxes: Boxes;
+  crew: Crew;
+  guests: Record<string, Guest>;
+  places: ReadonlyMap<string, Place>;
+  onChange: (next: Boxes, options: { label: string }) => void;
+  onRemoved: () => void;
+}) {
+  const [newItem, setNewItem] = useState("");
+  const { lost } = neededAt(box, places);
+  const patch = (change: Partial<Omit<Box, "id" | "items">>, label: string) => onChange(patchBox(boxes, box.id, change), { label });
+  const blocks = [...places.entries()].sort(([, a], [, b]) => a.startMin - b.startMin);
+  const others = boxes.boxes.filter((other) => other.id !== box.id);
+  const people = new Map(crew.people.map((person) => [person.id, person]));
+  const addable = crew.people.filter((person) => !box.personIds.includes(person.id));
+
+  const addNew = () => {
+    const next = addItem(boxes, box.id, newItem);
+    if (next !== boxes) onChange(next, { label: "what is in a box" });
+    setNewItem("");
+  };
+
+  return (
+    <div className="flex flex-col gap-4 p-4">
+      <Panel title="Box">
+        <div className="flex gap-3">
+          <div className="w-24">
+            <NumberField label="Number" value={box.number} min={1} onChange={(number) => patch({ number }, "a box's number")} />
+          </div>
+          <div className="flex-1">
+            <TextField label="Name" value={box.name} onChange={(name) => patch({ name }, "a box's name")} placeholder="e.g. Getting ready — Alex" />
+          </div>
+        </div>
+      </Panel>
+
+      <Panel title="Needed for">
+        {lost && (
+          <p className="mb-2 text-sm text-danger">The part of the day it was needed for is no longer on the Timeline. Say where it is needed now.</p>
+        )}
+        <SelectField
+          label="The part of the day it has to be there for"
+          value={box.blockId !== null && places.has(box.blockId) ? box.blockId : ""}
+          onChange={(blockId) => patch({ blockId: blockId || null }, "where a box is needed")}
+          options={[
+            { value: "", label: "Not for the day" },
+            ...blocks.map(([id, place]) => ({
+              value: id,
+              label: `${formatClock(place.startMin)} · ${place.label}${place.location ? ` · ${place.location}` : ""}`,
+            })),
+          ]}
+        />
+      </Panel>
+
+      <Panel title="Who takes it">
+        <ul className="mb-2 flex flex-wrap gap-1.5">
+          {box.personIds.map((id) => {
+            const person = people.get(id);
+            const name = person ? personName(person, guests) : "Someone no longer in the crew";
+            return (
+              <li key={id} className="inline-flex items-center gap-1 rounded-full bg-stone px-2 py-0.5 text-xs text-charcoal">
+                {name}
+                <button
+                  type="button"
+                  aria-label={`${name} is not taking it`}
+                  onClick={() => patch({ personIds: box.personIds.filter((other) => other !== id) }, "who takes a box")}
+                  className="text-slate hover:text-danger"
+                >
+                  <X size={11} aria-hidden />
+                </button>
+              </li>
+            );
+          })}
+          {box.personIds.length === 0 &&
+            (box.blockId === null ? (
+              <li className="text-sm text-slate">Nobody named: fine for a box that is not for the day.</li>
+            ) : (
+              <li className="text-sm text-danger">Nobody is taking it there yet.</li>
+            ))}
+        </ul>
+        {crew.people.length === 0 ? (
+          <p className="text-sm text-slate">Add the people helping on the day in Delegation, and they can be picked here.</p>
+        ) : (
+          addable.length > 0 && (
+            <select
+              aria-label="Somebody to take it"
+              value=""
+              onChange={(event) => event.target.value && patch({ personIds: [...box.personIds, event.target.value] }, "who takes a box")}
+              className={CONTROL}
+            >
+              <option value="">Add somebody…</option>
+              {addable.map((person) => (
+                <option key={person.id} value={person.id}>
+                  {personName(person, guests)}
+                </option>
+              ))}
+            </select>
+          )
+        )}
+      </Panel>
+
+      <Panel title="In it">
+        <ul className="mb-2 flex flex-col gap-1">
+          {box.items.map((item) => (
+            <li key={item.id} className="flex items-center gap-2">
+              <input
+                type="checkbox"
+                aria-label={`${item.label} is packed`}
+                checked={item.packed}
+                onChange={(event) => onChange(patchItem(boxes, box.id, item.id, { packed: event.target.checked }), { label: "packing" })}
+                className="accent-[var(--color-gold)]"
+              />
+              <input
+                aria-label="What it is"
+                value={item.label}
+                onChange={(event) => onChange(patchItem(boxes, box.id, item.id, { label: event.target.value }), { label: "what is in a box" })}
+                className={`${CONTROL} min-w-0 flex-1 ${item.packed ? "text-slate line-through" : ""}`}
+              />
+              <NumberInput
+                label={`How many of ${item.label}`}
+                value={item.quantity}
+                onCommit={(quantity) => onChange(patchItem(boxes, box.id, item.id, { quantity: Math.max(1, quantity ?? 1) }), { label: "what is in a box" })}
+                className={`${CONTROL} w-14`}
+              />
+              {others.length > 0 && (
+                <select
+                  aria-label={`Move ${item.label} to another box`}
+                  value=""
+                  onChange={(event) => event.target.value && onChange(moveItem(boxes, item.id, event.target.value), { label: "moving something" })}
+                  className={`${CONTROL} w-28`}
+                >
+                  <option value="">Move to…</option>
+                  {others.map((other) => (
+                    <option key={other.id} value={other.id}>
+                      Box {other.number}
+                      {other.name ? ` — ${other.name}` : ""}
+                    </option>
+                  ))}
+                </select>
+              )}
+              <IconButton icon={Trash2} label={`Take ${item.label} out`} tone="danger" onClick={() => onChange(removeItem(boxes, box.id, item.id), { label: "what is in a box" })} />
+            </li>
+          ))}
+          {box.items.length === 0 && <li className="text-sm text-slate">Nothing in it yet.</li>}
+        </ul>
+        <div className="flex gap-2">
+          <TextField value={newItem} onChange={setNewItem} placeholder="Something to pack" />
+          <Button tone="quiet" onClick={addNew}>
+            Add
+          </Button>
+        </div>
+      </Panel>
+
+      <Panel title="Notes">
+        <TextArea value={box.notes} onChange={(notes) => patch({ notes }, "a box's notes")} />
+      </Panel>
+
+      <div>
+        <Button
+          tone="danger"
+          icon={Trash2}
+          onClick={() => {
+            onChange(removeBox(boxes, box.id), { label: "removing a box" });
+            onRemoved();
+          }}
+        >
+          Remove this box
+        </Button>
+      </div>
+    </div>
+  );
+}
diff --git a/suite/components/ensemble/GuestPicker.tsx b/suite/components/cast/GuestPicker.tsx
similarity index 100%
rename from suite/components/ensemble/GuestPicker.tsx
rename to suite/components/cast/GuestPicker.tsx
diff --git a/suite/components/cast/MemberPicker.tsx b/suite/components/cast/MemberPicker.tsx
new file mode 100644
index 00000000..30638f96
--- /dev/null
+++ b/suite/components/cast/MemberPicker.tsx
@@ -0,0 +1,132 @@
+"use client";
+
+import { useState } from "react";
+import { Heart, Plus } from "lucide-react";
+import type { Event as WeddingEvent } from "@jfrusher/trousseau";
+import { Button, TextField } from "@/components/ui/controls";
+import { GuestChip, GuestPicker } from "@/components/cast/GuestPicker";
+import { memberDescriptor } from "@/lib/cast/resolve";
+import { roleLabel } from "@/lib/model/partners";
+import { CAST_ROLES, type CustomRole, type Guest, type Seating, type ShotMember } from "@/lib/model/types";
+
+/**
+ * Who is in a group — a group shot, a processional's group — picked the one
+ * way everywhere: a role from the cast, a role of the couple's own, a family,
+ * a group, a guest, or a few words for somebody who is none of those.
+ *
+ * Adding hands back a list, so "+ The couple" is one change and one undo step.
+ */
+export function MemberPicker({
+  members,
+  customRoles,
+  guests,
+  seating,
+  event,
+  onAdd,
+  onRemove,
+  textPlaceholder,
+}: {
+  members: ShotMember[];
+  customRoles: CustomRole[];
+  guests: Record<string, Guest>;
+  seating: Seating;
+  event: WeddingEvent;
+  onAdd: (members: ShotMember[]) => void;
+  onRemove: (index: number) => void;
+  textPlaceholder: string;
+}) {
+  const [textValue, setTextValue] = useState("");
+
+  const hasRole = (role: string) => members.some((m) => m.kind === "role" && m.ref === role);
+  const availableRoles = CAST_ROLES.filter((role) => !hasRole(role));
+  const availableCustomRoles = customRoles.filter((r) => !members.some((m) => m.kind === "customRole" && m.ref === r.id));
+  const availableFamilies = Object.values(seating.families).filter(
+    (f) => !members.some((m) => m.kind === "family" && m.ref === f.id),
+  );
+  const availableGroups = [...Object.values(seating.groups), ...Object.values(seating.subgroups)].filter(
+    (g) => !members.some((m) => m.kind === "group" && m.ref === g.id),
+  );
+
+  return (
+    <>
+      <ul className="mb-2 flex flex-wrap gap-1.5">
+        {members.map((member, index) => (
+          <li key={index}>
+            <GuestChip name={memberDescriptor(member, guests, seating, customRoles, event)} onRemove={() => onRemove(index)} />
+          </li>
+        ))}
+        {members.length === 0 && <li className="text-sm text-slate">Nobody added yet.</li>}
+      </ul>
+
+      {!(hasRole("a") && hasRole("b")) && (
+        <div className="mb-2">
+          <Button
+            icon={Heart}
+            tone="primary"
+            onClick={() =>
+              onAdd((["a", "b"] as const).filter((role) => !hasRole(role)).map((ref) => ({ kind: "role", ref })))
+            }
+          >
+            + The couple
+          </Button>
+        </div>
+      )}
+
+      <ul className="mb-2 flex flex-wrap gap-1.5">
+        {availableRoles.map((role) => (
+          <li key={role}>
+            <QuickAddChip label={roleLabel(role, event)} onClick={() => onAdd([{ kind: "role", ref: role }])} />
+          </li>
+        ))}
+        {availableCustomRoles.map((r) => (
+          <li key={r.id}>
+            <QuickAddChip label={r.name} onClick={() => onAdd([{ kind: "customRole", ref: r.id }])} />
+          </li>
+        ))}
+        {availableFamilies.map((f) => (
+          <li key={f.id}>
+            <QuickAddChip label={f.name} onClick={() => onAdd([{ kind: "family", ref: f.id }])} />
+          </li>
+        ))}
+        {availableGroups.map((g) => (
+          <li key={g.id}>
+            <QuickAddChip label={g.name} onClick={() => onAdd([{ kind: "group", ref: g.id }])} />
+          </li>
+        ))}
+      </ul>
+
+      <GuestPicker
+        guests={guests}
+        exclude={members.filter((m) => m.kind === "guest").map((m) => m.ref)}
+        onPick={(guestId) => onAdd([{ kind: "guest", ref: guestId }])}
+      />
+
+      <div className="mt-2 flex gap-2">
+        <TextField value={textValue} onChange={setTextValue} placeholder={textPlaceholder} />
+        <Button
+          tone="quiet"
+          onClick={() => {
+            if (!textValue.trim()) return;
+            onAdd([{ kind: "text", ref: textValue.trim() }]);
+            setTextValue("");
+          }}
+        >
+          Add
+        </Button>
+      </div>
+    </>
+  );
+}
+
+function QuickAddChip({ label, onClick }: { label: string; onClick: () => void }) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      className="inline-flex items-center gap-1 rounded-full border border-dashed border-charcoal/25 px-2 py-0.5 text-xs text-slate transition hover:border-gold hover:text-charcoal"
+    >
+      <Plus size={11} />
+      {label}
+    </button>
+  );
+}
diff --git a/suite/components/ceremony/CeremonyBoard.tsx b/suite/components/ceremony/CeremonyBoard.tsx
new file mode 100644
index 00000000..a75d92e1
--- /dev/null
+++ b/suite/components/ceremony/CeremonyBoard.tsx
@@ -0,0 +1,275 @@
+"use client";
+
+import { useState } from "react";
+import { ArrowDown, ArrowUp, Copy, Plus, Printer, Trash2, Wand2 } from "lucide-react";
+import type { Event as WeddingEvent } from "@jfrusher/trousseau";
+import { Button, Empty, IconButton, Panel, Segmented, TextField } from "@/components/ui/controls";
+import { ToolUndo } from "@/components/shell/ToolUndo";
+import { MemberPicker } from "@/components/cast/MemberPicker";
+import { resolveMembers, type MemberProblem } from "@/lib/cast/resolve";
+import { addGroup, addMembers, moveGroup, patchGroup, removeGroup, removeMember } from "@/lib/ceremony/actions";
+import { suggestOrder } from "@/lib/ceremony/propose";
+import { FORMATION_WORDS, processionalRows, processionalText } from "@/lib/ceremony/rows";
+import { download } from "@/lib/data/file";
+import { sideLabel } from "@/lib/model/partners";
+import { useCast, useCeremony, useEvent, useGuests, useSeating, useStatus, useWriters } from "@/lib/model/useSuite";
+import type { CastSlice, Ceremony, Formation, Guest, Seating, Side, WalkGroup } from "@/lib/model/types";
+
+/**
+ * The processional: who walks, in the order they walk, how, which side they
+ * go to, and what they walk to. It keeps no copy of anything — it reads the
+ * wedding and writes it, on the wedding's one history — and its people come
+ * from the one cast Group shots uses.
+ */
+export function CeremonyBoard() {
+  const status = useStatus();
+  const event = useEvent();
+  const guests = useGuests();
+  const seating = useSeating();
+  const cast = useCast();
+  const ceremony = useCeremony();
+  const { setCeremony } = useWriters();
+  const [selectedId, setSelectedId] = useState<string | null>(null);
+  const [note, setNote] = useState<string | null>(null);
+
+  if (status !== "ready") return null;
+
+  const processional = ceremony.processional;
+  const selected = processional.find((group) => group.id === selectedId) ?? null;
+  const resolve = (group: WalkGroup) => resolveMembers(group, guests, seating, cast.roles, cast.customRoles, event);
+
+  const rows = () => processionalRows(processional, guests, seating, cast, event);
+
+  const print = async () => {
+    setNote(null);
+    try {
+      const [{ renderProcessionalSheet }, { browserFontSource }] = await Promise.all([
+        import("@/lib/ceremony/render/pdf/processionalSheet"),
+        import("@/apps/brigade/render/pdf/fontSource"),
+      ]);
+      const bytes = await renderProcessionalSheet(rows(), {
+        fontSource: browserFontSource(),
+        coupleNames: event.coupleNames,
+        generatedOn: `Made with Trousseau, ${new Date().toLocaleDateString()}`,
+      });
+      const slug = (event.coupleNames || "wedding").toLowerCase().replace(/&/g, "and").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+      download(`${slug || "wedding"}-processional.pdf`, new Blob([bytes as BlobPart], { type: "application/pdf" }));
+    } catch (cause) {
+      setNote(cause instanceof Error ? cause.message : "The page could not be made.");
+    }
+  };
+
+  const copy = async () => {
+    try {
+      await navigator.clipboard.writeText(processionalText(rows(), event));
+      setNote("Copied — paste it into an email to the wedding party.");
+    } catch {
+      setNote("This browser would not copy. Print the page instead.");
+    }
+  };
+
+  const add = () => {
+    const next = addGroup(ceremony);
+    setCeremony(next, { label: "adding a group" });
+    setSelectedId(next.processional[next.processional.length - 1]!.id);
+  };
+
+  return (
+    <div className="flex h-[calc(100dvh-var(--shell-header-h))]">
+      <ToolUndo />
+      <div data-tour="ceremony.order" className="flex w-96 shrink-0 flex-col border-r border-charcoal/10">
+        <div className="flex gap-2 border-b border-charcoal/10 p-3">
+          <Button icon={Plus} onClick={add}>
+            Add a group
+          </Button>
+          {processional.length === 0 ? (
+            <Button icon={Wand2} onClick={() => setCeremony({ ...ceremony, processional: suggestOrder(cast) }, { label: "suggesting an order" })}>
+              Suggest an order
+            </Button>
+          ) : (
+            <>
+              <Button icon={Printer} onClick={() => void print()}>
+                Print
+              </Button>
+              <Button icon={Copy} onClick={() => void copy()}>
+                Copy as text
+              </Button>
+            </>
+          )}
+        </div>
+        {note && (
+          <p role="status" className="border-b border-charcoal/10 px-3 py-2 text-xs text-slate">
+            {note}
+          </p>
+        )}
+
+        {processional.length === 0 ? (
+          <div className="p-4">
+            <Empty>
+              Nobody walking yet. Suggest an order from who&rsquo;s who — the officiant, grandparents, parents, the
+              wedding parties, then the two of you — and change anything in it, or add groups one at a time.
+            </Empty>
+          </div>
+        ) : (
+          <ol aria-label="The processional" className="flex-1 overflow-y-auto p-1.5">
+            {processional.map((group, index) => {
+              const resolved = resolve(group);
+              return (
+                <li
+                  key={group.id}
+                  className={`flex items-start gap-1 rounded px-2 py-1.5 ${group.id === selectedId ? "bg-stone" : "hover:bg-stone/50"}`}
+                >
+                  <button type="button" onClick={() => setSelectedId(group.id)} className="min-w-0 flex-1 text-left">
+                    <div className="truncate text-sm text-charcoal">
+                      {index + 1}. {resolved.label}
+                      {resolved.problems.length > 0 && <span className="ml-1 text-danger">●</span>}
+                    </div>
+                    <div className="truncate text-xs text-slate">
+                      {[FORMATION_WORDS[group.formation], group.music && `♪ ${group.music}`].filter(Boolean).join(" · ")}
+                    </div>
+                  </button>
+                  <IconButton
+                    icon={ArrowUp}
+                    label={`Move ${resolved.label} earlier`}
+                    onClick={() => setCeremony(moveGroup(ceremony, index, index - 1), { label: "changing the order" })}
+                  />
+                  <IconButton
+                    icon={ArrowDown}
+                    label={`Move ${resolved.label} later`}
+                    onClick={() => setCeremony(moveGroup(ceremony, index, index + 1), { label: "changing the order" })}
+                  />
+                </li>
+              );
+            })}
+          </ol>
+        )}
+      </div>
+
+      <div className="min-w-0 flex-1 overflow-y-auto">
+        {selected ? (
+          <GroupInspector
+            group={selected}
+            ceremony={ceremony}
+            cast={cast}
+            guests={guests}
+            seating={seating}
+            event={event}
+            problems={resolve(selected).problems}
+            onChange={setCeremony}
+            onRemoved={() => setSelectedId(null)}
+          />
+        ) : (
+          <div className="flex h-full items-center justify-center">
+            <Empty>{processional.length === 0 ? "The order appears on the left." : "Pick a group on the left."}</Empty>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+function GroupInspector({
+  group,
+  ceremony,
+  cast,
+  guests,
+  seating,
+  event,
+  problems,
+  onChange,
+  onRemoved,
+}: {
+  group: WalkGroup;
+  ceremony: Ceremony;
+  cast: CastSlice;
+  guests: Record<string, Guest>;
+  seating: Seating;
+  event: WeddingEvent;
+  problems: MemberProblem[];
+  onChange: (next: Ceremony, options: { label: string }) => void;
+  onRemoved: () => void;
+}) {
+  const patch = (change: Partial<Omit<WalkGroup, "id">>, label: string) => onChange(patchGroup(ceremony, group.id, change), { label });
+  const sides: Array<{ value: Side; label: string }> = [
+    { value: "a", label: sideLabel("a", event) },
+    { value: "b", label: sideLabel("b", event) },
+    { value: "both", label: "Both sides" },
+    { value: "", label: "Not said" },
+  ];
+
+  return (
+    <div className="flex flex-col gap-4 p-4">
+      <Panel title="Group">
+        <TextField
+          label="Label"
+          value={group.label}
+          onChange={(label) => patch({ label }, "a group's label")}
+          placeholder="Leave blank to build it from who walks"
+        />
+      </Panel>
+
+      <Panel title="Who walks">
+        {problems.length > 0 && (
+          <ul className="mb-2 text-sm text-danger">
+            {problems.map((problem, index) => (
+              <li key={index}>{describe(problem)}</li>
+            ))}
+          </ul>
+        )}
+        <MemberPicker
+          members={group.members}
+          customRoles={cast.customRoles}
+          guests={guests}
+          seating={seating}
+          event={event}
+          onAdd={(members) => onChange(addMembers(ceremony, group.id, members), { label: "who walks" })}
+          onRemove={(index) => onChange(removeMember(ceremony, group.id, index), { label: "who walks" })}
+          textPlaceholder="Or type a name, e.g. the officiant"
+        />
+      </Panel>
+
+      <Panel title="How they walk">
+        <Segmented
+          value={group.formation}
+          onChange={(formation) => patch({ formation }, "how a group walks")}
+          options={(Object.keys(FORMATION_WORDS) as Formation[]).map((value) => ({ value, label: FORMATION_WORDS[value] }))}
+        />
+      </Panel>
+
+      <Panel title="Where they go">
+        <Segmented value={group.side} onChange={(side) => patch({ side }, "where a group goes")} options={sides} />
+      </Panel>
+
+      <Panel title="Music">
+        <div className="flex flex-col gap-2">
+          <TextField label="What they walk to" value={group.music} onChange={(music) => patch({ music }, "the music")} placeholder="e.g. Canon in D" />
+          <TextField label="When" value={group.cue} onChange={(cue) => patch({ cue }, "a cue")} placeholder="e.g. The music changes as the couple enter" />
+        </div>
+      </Panel>
+
+      <div>
+        <Button
+          tone="danger"
+          icon={Trash2}
+          onClick={() => {
+            onChange(removeGroup(ceremony, group.id), { label: "removing a group" });
+            onRemoved();
+          }}
+        >
+          Remove this group
+        </Button>
+      </div>
+    </div>
+  );
+}
+
+function describe(problem: MemberProblem): string {
+  switch (problem.kind) {
+    case "dangling":
+      return `${problem.detail}.`;
+    case "declined":
+      return `${problem.name} has declined.`;
+    case "empty":
+      return "Nobody is in this group yet.";
+  }
+}
diff --git a/suite/components/ensemble/CastPanel.tsx b/suite/components/ensemble/CastPanel.tsx
index 77cbd360..088501f0 100644
--- a/suite/components/ensemble/CastPanel.tsx
+++ b/suite/components/ensemble/CastPanel.tsx
@@ -3,30 +3,31 @@
 import { useState } from "react";
 import { Trash2 } from "lucide-react";
 import { Button, IconButton, Panel, TextField } from "@/components/ui/controls";
-import { GuestChip, GuestPicker } from "./GuestPicker";
+import { GuestChip, GuestPicker } from "@/components/cast/GuestPicker";
 import { guestName } from "@/lib/model/slices";
 import type { Event as WeddingEvent } from "@jfrusher/trousseau";
 import { roleLabel } from "@/lib/model/partners";
-import { CAST_ROLES, SINGLE_ROLES, type Guest, type Shots } from "@/lib/model/types";
-import { addCustomRole, removeCustomRole, renameCustomRole, setCastRole, setCustomRoleMembers } from "@/lib/ensemble/actions";
+import { CAST_ROLES, SINGLE_ROLES, type CastSlice, type Guest } from "@/lib/model/types";
+import { addCustomRole, removeCustomRole, renameCustomRole, setCastRole, setCustomRoleMembers } from "@/lib/cast/actions";
 
+/** Who is who, shared with Ceremony: a mother named here walks there too. */
 export function CastPanel({
-  shots,
+  cast,
   guests,
   event,
   onChange,
 }: {
-  shots: Shots;
+  cast: CastSlice;
   guests: Record<string, Guest>;
   event: WeddingEvent;
-  onChange: (next: Shots) => void;
+  onChange: (next: CastSlice) => void;
 }) {
   const [newRoleName, setNewRoleName] = useState("");
 
   return (
     <div className="flex flex-col gap-4 p-4">
       {CAST_ROLES.map((role) => {
-        const chosen = shots.cast[role];
+        const chosen = cast.roles[role];
         const single = SINGLE_ROLES.has(role);
         return (
           <Panel key={role} title={roleLabel(role, event)}>
@@ -35,7 +36,7 @@ export function CastPanel({
                 <li key={guestId}>
                   <GuestChip
                     name={guests[guestId] ? guestName(guests[guestId]!) || "Unnamed guest" : "Deleted guest"}
-                    onRemove={() => onChange(setCastRole(shots, role, chosen.filter((id) => id !== guestId)))}
+                    onRemove={() => onChange(setCastRole(cast, role, chosen.filter((id) => id !== guestId)))}
                   />
                 </li>
               ))}
@@ -46,23 +47,23 @@ export function CastPanel({
               <GuestPicker
                 guests={guests}
                 exclude={chosen}
-                onPick={(guestId) => onChange(setCastRole(shots, role, single ? [guestId] : [...chosen, guestId]))}
+                onPick={(guestId) => onChange(setCastRole(cast, role, single ? [guestId] : [...chosen, guestId]))}
               />
             )}
           </Panel>
         );
       })}
 
-      {shots.customRoles.map((role) => (
+      {cast.customRoles.map((role) => (
         <div key={role.id} className="rounded border border-charcoal/10 p-3">
           <div className="mb-2 flex items-center gap-2">
             <input
               aria-label="Role name"
               value={role.name}
-              onChange={(e) => onChange(renameCustomRole(shots, role.id, e.target.value))}
+              onChange={(e) => onChange(renameCustomRole(cast, role.id, e.target.value))}
               className="min-w-0 flex-1 bg-transparent text-xs tracking-widest text-slate uppercase"
             />
-            <IconButton icon={Trash2} label={`Remove ${role.name}`} tone="danger" onClick={() => onChange(removeCustomRole(shots, role.id))} />
+            <IconButton icon={Trash2} label={`Remove ${role.name}`} tone="danger" onClick={() => onChange(removeCustomRole(cast, role.id))} />
           </div>
           <ul className="mb-2 flex flex-wrap gap-1.5">
             {role.guestIds.map((guestId) => (
@@ -70,7 +71,7 @@ export function CastPanel({
                 <GuestChip
                   name={guests[guestId] ? guestName(guests[guestId]!) || "Unnamed guest" : "Deleted guest"}
                   onRemove={() =>
-                    onChange(setCustomRoleMembers(shots, role.id, role.guestIds.filter((id) => id !== guestId)))
+                    onChange(setCustomRoleMembers(cast, role.id, role.guestIds.filter((id) => id !== guestId)))
                   }
                 />
               </li>
@@ -80,7 +81,7 @@ export function CastPanel({
           <GuestPicker
             guests={guests}
             exclude={role.guestIds}
-            onPick={(guestId) => onChange(setCustomRoleMembers(shots, role.id, [...role.guestIds, guestId]))}
+            onPick={(guestId) => onChange(setCustomRoleMembers(cast, role.id, [...role.guestIds, guestId]))}
           />
         </div>
       ))}
@@ -91,7 +92,7 @@ export function CastPanel({
           tone="quiet"
           onClick={() => {
             if (!newRoleName.trim()) return;
-            onChange(addCustomRole(shots, newRoleName.trim()));
+            onChange(addCustomRole(cast, newRoleName.trim()));
             setNewRoleName("");
           }}
         >
diff --git a/suite/components/ensemble/EnsembleBoard.tsx b/suite/components/ensemble/EnsembleBoard.tsx
index 8dc9bbdb..9b710804 100644
--- a/suite/components/ensemble/EnsembleBoard.tsx
+++ b/suite/components/ensemble/EnsembleBoard.tsx
@@ -4,7 +4,7 @@ import { useState } from "react";
 import { Sparkles, Wand2 } from "lucide-react";
 import { Button, Empty, Segmented } from "@/components/ui/controls";
 import { ToolUndo } from "@/components/shell/ToolUndo";
-import { useEvent, useGuests, useSeating, useShots, useStatus, useWriters } from "@/lib/model/useSuite";
+import { useCast, useEvent, useGuests, useSeating, useShots, useStatus, useWriters } from "@/lib/model/useSuite";
 import { propose } from "@/lib/ensemble/propose";
 import { CastPanel } from "./CastPanel";
 import { PrintPanel } from "./PrintPanel";
@@ -19,7 +19,8 @@ export function EnsembleBoard() {
   const guests = useGuests();
   const seating = useSeating();
   const shots = useShots();
-  const { setShots } = useWriters();
+  const cast = useCast();
+  const { setShots, setCast } = useWriters();
 
   // Ensemble has no store of its own — its edits land on the suite-wide undo
   // stack, so that is the one the header's undo has to drive.
@@ -60,6 +61,7 @@ export function EnsembleBoard() {
         </div>
         <ShotList
           shots={shots}
+          cast={cast}
           guests={guests}
           seating={seating}
           event={event}
@@ -88,14 +90,14 @@ export function EnsembleBoard() {
         <div data-tour="groupshots.panel" className="flex-1 overflow-y-auto">
           {tab === "shot" &&
             (selectedShot ? (
-              <ShotInspector shot={selectedShot} shots={shots} guests={guests} seating={seating} event={event} onChange={setShots} />
+              <ShotInspector shot={selectedShot} shots={shots} cast={cast} guests={guests} seating={seating} event={event} onChange={setShots} />
             ) : (
               <div className="flex h-full items-center justify-center">
                 <Empty>Pick a shot on the left, or add one.</Empty>
               </div>
             ))}
-          {tab === "cast" && <CastPanel shots={shots} guests={guests} event={event} onChange={setShots} />}
-          {tab === "print" && <PrintPanel shots={shots} guests={guests} seating={seating} event={event} />}
+          {tab === "cast" && <CastPanel cast={cast} guests={guests} event={event} onChange={setCast} />}
+          {tab === "print" && <PrintPanel shots={shots} cast={cast} guests={guests} seating={seating} event={event} />}
         </div>
       </div>
     </div>
diff --git a/suite/components/ensemble/PrintPanel.tsx b/suite/components/ensemble/PrintPanel.tsx
index 385e46fe..57193375 100644
--- a/suite/components/ensemble/PrintPanel.tsx
+++ b/suite/components/ensemble/PrintPanel.tsx
@@ -5,17 +5,19 @@ import { browserFontSource } from "@/apps/brigade/render/pdf/fontSource";
 import { Button, Empty, Panel, Segmented } from "@/components/ui/controls";
 import { download } from "@/lib/data/file";
 import { shotListCsv } from "@/lib/ensemble/exports";
-import { resolveShot } from "@/lib/ensemble/resolve";
+import { resolveMembers } from "@/lib/cast/resolve";
 import type { Event as WeddingEvent } from "@jfrusher/trousseau";
-import type { Guest, Seating, Shots } from "@/lib/model/types";
+import type { CastSlice, Guest, Seating, Shots } from "@/lib/model/types";
 
 export function PrintPanel({
   shots,
+  cast,
   guests,
   seating,
   event,
 }: {
   shots: Shots;
+  cast: CastSlice;
   guests: Record<string, Guest>;
   seating: Seating;
   event: WeddingEvent;
@@ -26,7 +28,7 @@ export function PrintPanel({
 
   const problems = shots.sections.flatMap((section) =>
     section.shots.flatMap((shot) => {
-      const resolved = resolveShot(shot, guests, seating, shots.cast, shots.customRoles, event);
+      const resolved = resolveMembers(shot, guests, seating, cast.roles, cast.customRoles, event);
       return resolved.problems.map((problem) => ({
         shotLabel: resolved.label,
         text:
@@ -51,7 +53,7 @@ export function PrintPanel({
         shots.sections,
         guests,
         seating,
-        shots.cast,
+        cast.roles,
         {
           fontSource: browserFontSource(),
           pageSize,
@@ -59,7 +61,7 @@ export function PrintPanel({
           partners: event.partners,
           generatedOn: `Made with Trousseau, ${new Date().toLocaleDateString()}`,
         },
-        shots.customRoles,
+        cast.customRoles,
       );
       download(`${slug()}-group-shots.pdf`, new Blob([bytes as BlobPart], { type: "application/pdf" }));
     } catch (cause) {
@@ -74,7 +76,7 @@ export function PrintPanel({
     try {
       download(
         `${slug()}-group-shots.csv`,
-        shotListCsv(shots.sections, guests, seating, shots.cast, shots.customRoles, event),
+        shotListCsv(shots.sections, guests, seating, cast.roles, cast.customRoles, event),
         "text/csv",
       );
     } catch (cause) {
diff --git a/suite/components/ensemble/ShotInspector.tsx b/suite/components/ensemble/ShotInspector.tsx
index 9e0ec959..d744c500 100644
--- a/suite/components/ensemble/ShotInspector.tsx
+++ b/suite/components/ensemble/ShotInspector.tsx
@@ -1,18 +1,15 @@
 "use client";
 
-import { useState } from "react";
-import { Heart, Plus } from "lucide-react";
-import { Button, Panel, TextArea, TextField } from "@/components/ui/controls";
-import { GuestChip, GuestPicker } from "./GuestPicker";
-import { memberDescriptor } from "@/lib/ensemble/resolve";
+import { Panel, TextArea, TextField } from "@/components/ui/controls";
+import { MemberPicker } from "@/components/cast/MemberPicker";
 import { addMember, patchShot, removeMember } from "@/lib/ensemble/actions";
 import type { Event as WeddingEvent } from "@jfrusher/trousseau";
-import { roleLabel } from "@/lib/model/partners";
-import { CAST_ROLES, type Guest, type Seating, type Shot, type ShotMember, type Shots } from "@/lib/model/types";
+import type { CastSlice, Guest, Seating, Shot, Shots } from "@/lib/model/types";
 
 export function ShotInspector({
   shot,
   shots,
+  cast,
   guests,
   seating,
   event,
@@ -20,34 +17,12 @@ export function ShotInspector({
 }: {
   shot: Shot;
   shots: Shots;
+  cast: CastSlice;
   guests: Record<string, Guest>;
   seating: Seating;
   event: WeddingEvent;
   onChange: (next: Shots) => void;
 }) {
-  const [textValue, setTextValue] = useState("");
-
-  const add = (member: ShotMember) => onChange(addMember(shots, shot.id, member));
-  const hasRole = (role: string) => shot.members.some((m) => m.kind === "role" && m.ref === role);
-
-  const addCouple = () => {
-    let next = shots;
-    if (!hasRole("a")) next = addMember(next, shot.id, { kind: "role", ref: "a" });
-    if (!hasRole("b")) next = addMember(next, shot.id, { kind: "role", ref: "b" });
-    onChange(next);
-  };
-
-  const availableRoles = CAST_ROLES.filter((role) => !hasRole(role));
-  const availableCustomRoles = shots.customRoles.filter(
-    (r) => !shot.members.some((m) => m.kind === "customRole" && m.ref === r.id),
-  );
-  const availableFamilies = Object.values(seating.families).filter(
-    (f) => !shot.members.some((m) => m.kind === "family" && m.ref === f.id),
-  );
-  const availableGroups = [...Object.values(seating.groups), ...Object.values(seating.subgroups)].filter(
-    (g) => !shot.members.some((m) => m.kind === "group" && m.ref === g.id),
-  );
-
   return (
     <div className="flex flex-col gap-4 p-4">
       <Panel title="Shot">
@@ -60,68 +35,16 @@ export function ShotInspector({
       </Panel>
 
       <Panel title="Who's in it">
-        <ul className="mb-2 flex flex-wrap gap-1.5">
-          {shot.members.map((member, index) => (
-            <li key={index}>
-              <GuestChip
-                name={memberDescriptor(member, guests, seating, shots.customRoles, event)}
-                onRemove={() => onChange(removeMember(shots, shot.id, index))}
-              />
-            </li>
-          ))}
-          {shot.members.length === 0 && <li className="text-sm text-slate">Nobody added yet.</li>}
-        </ul>
-
-        {!(hasRole("a") && hasRole("b")) && (
-          <div className="mb-2">
-            <Button icon={Heart} tone="primary" onClick={addCouple}>
-              + The couple
-            </Button>
-          </div>
-        )}
-
-        <ul className="mb-2 flex flex-wrap gap-1.5">
-          {availableRoles.map((role) => (
-            <li key={role}>
-              <QuickAddChip label={roleLabel(role, event)} onClick={() => add({ kind: "role", ref: role })} />
-            </li>
-          ))}
-          {availableCustomRoles.map((r) => (
-            <li key={r.id}>
-              <QuickAddChip label={r.name} onClick={() => add({ kind: "customRole", ref: r.id })} />
-            </li>
-          ))}
-          {availableFamilies.map((f) => (
-            <li key={f.id}>
-              <QuickAddChip label={f.name} onClick={() => add({ kind: "family", ref: f.id })} />
-            </li>
-          ))}
-          {availableGroups.map((g) => (
-            <li key={g.id}>
-              <QuickAddChip label={g.name} onClick={() => add({ kind: "group", ref: g.id })} />
-            </li>
-          ))}
-        </ul>
-
-        <GuestPicker
+        <MemberPicker
+          members={shot.members}
+          customRoles={cast.customRoles}
           guests={guests}
-          exclude={shot.members.filter((m) => m.kind === "guest").map((m) => m.ref)}
-          onPick={(guestId) => add({ kind: "guest", ref: guestId })}
+          seating={seating}
+          event={event}
+          onAdd={(members) => onChange(members.reduce((next, member) => addMember(next, shot.id, member), shots))}
+          onRemove={(index) => onChange(removeMember(shots, shot.id, index))}
+          textPlaceholder="Or type something else, e.g. the dog"
         />
-
-        <div className="mt-2 flex gap-2">
-          <TextField value={textValue} onChange={setTextValue} placeholder="Or type something else, e.g. the dog" />
-          <Button
-            tone="quiet"
-            onClick={() => {
-              if (!textValue.trim()) return;
-              add({ kind: "text", ref: textValue.trim() });
-              setTextValue("");
-            }}
-          >
-            Add
-          </Button>
-        </div>
       </Panel>
 
       <Panel title="Notes">
@@ -130,16 +53,3 @@ export function ShotInspector({
     </div>
   );
 }
-
-function QuickAddChip({ label, onClick }: { label: string; onClick: () => void }) {
-  return (
-    <button
-      type="button"
-      onClick={onClick}
-      className="inline-flex items-center gap-1 rounded-full border border-dashed border-charcoal/25 px-2 py-0.5 text-xs text-slate transition hover:border-gold hover:text-charcoal"
-    >
-      <Plus size={11} />
-      {label}
-    </button>
-  );
-}
diff --git a/suite/components/ensemble/ShotList.tsx b/suite/components/ensemble/ShotList.tsx
index a789704d..4aae02c7 100644
--- a/suite/components/ensemble/ShotList.tsx
+++ b/suite/components/ensemble/ShotList.tsx
@@ -21,8 +21,8 @@ import { CSS } from "@dnd-kit/utilities";
 import { ChevronDown, ChevronUp, Copy, GripVertical, Plus, Trash2 } from "lucide-react";
 import { IconButton } from "@/components/ui/controls";
 import { newId } from "@/lib/model/ids";
-import type { Cast, CustomRole, Guest, Seating, Shot, Shots } from "@/lib/model/types";
-import { resolveShot } from "@/lib/ensemble/resolve";
+import type { Cast, CastSlice, CustomRole, Guest, Seating, Shot, Shots } from "@/lib/model/types";
+import { resolveMembers } from "@/lib/cast/resolve";
 import {
   addSection,
   addShot,
@@ -36,6 +36,7 @@ import {
 
 export function ShotList({
   shots,
+  cast,
   guests,
   seating,
   event,
@@ -44,6 +45,7 @@ export function ShotList({
   onChange,
 }: {
   shots: Shots;
+  cast: CastSlice;
   guests: Record<string, Guest>;
   seating: Seating;
   event: WeddingEvent;
@@ -142,8 +144,8 @@ export function ShotList({
                         number={numbers.get(shot.id) ?? 0}
                         guests={guests}
                         seating={seating}
-                        cast={shots.cast}
-                        customRoles={shots.customRoles}
+                        cast={cast.roles}
+                        customRoles={cast.customRoles}
                         event={event}
                         selected={shot.id === selectedId}
                         onSelect={() => onSelect(shot.id)}
@@ -209,7 +211,7 @@ function ShotRow({
   onDuplicate: () => void;
 }) {
   const { attributes, listeners, setNodeRef, transform, transition } = useSortable({ id: shot.id });
-  const resolved = resolveShot(shot, guests, seating, cast, customRoles, event);
+  const resolved = resolveMembers(shot, guests, seating, cast, customRoles, event);
 
   return (
     <li
diff --git a/suite/components/library/LibraryPage.tsx b/suite/components/library/LibraryPage.tsx
index b964c995..258b0d54 100644
--- a/suite/components/library/LibraryPage.tsx
+++ b/suite/components/library/LibraryPage.tsx
@@ -5,7 +5,7 @@ import { useCallback, useEffect, useState } from "react";
 import { migrate } from "@jfrusher/trousseau";
 import { useTrousseauStore } from "@/lib/store/useTrousseauStore";
 import { publishDay, readTimeline } from "@/lib/model/slices";
-import { applyTo, extract, KIND_NAMES, KINDS, type Kind } from "@/lib/library/items";
+import { adds, applyTo, extract, KIND_NAMES, KINDS, type Adding, type Kind } from "@/lib/library/items";
 import type { LibraryListing } from "@/lib/library/store";
 import { longDate } from "@/lib/dates";
 import { Button, Empty } from "@/components/ui/controls";
@@ -20,13 +20,18 @@ const CARRIES: Record<Kind, string> = {
   day: "The blocks, lanes and times, with each block’s notes — without the date, the couple or the suppliers’ numbers.",
   room: "The tables and the floor, with every chair empty.",
   checklist: "The tasks, each as so many days before the day.",
+  processional: "The order, who walks by what they are to the couple, how, and the music — nobody by name.",
+  boxes: "The boxes and what goes in each — not who takes them, when they are needed, or what is packed.",
+  bar: "The kind of bar, the figures, the mix, the prices and the shops — not how many are coming or what a couple has.",
 };
 
 /** What putting it in does to the wedding it goes into, said before it is done. */
-const REPLACES: Record<Exclude<Kind, "checklist">, string> = {
+const REPLACES: Record<Exclude<Kind, Adding>, string> = {
   cards: "The card design here is replaced. Who the cards are for is not.",
   day: "The running order here is replaced. Jobs tied to its blocks will need new ones.",
   room: "The room here is replaced, and everyone is unseated. Families and groups stay.",
+  processional: "The processional here is replaced. Who is who is not.",
+  bar: "The bar's settings here are replaced. How many are coming, and what is already bought, are not.",
 };
 
 type Listing = { status: "loading" } | { status: "ready"; items: LibraryListing[] } | { status: "signed-out" } | { status: "failed"; message: string };
@@ -68,7 +73,7 @@ export function LibraryPage() {
   };
 
   const use = async (item: LibraryListing) => {
-    if (item.kind !== "checklist") {
+    if (!adds(item.kind)) {
       const ok = await confirm({ title: `Use “${item.name}” here?`, body: <p>{REPLACES[item.kind]} Undo takes it back.</p>, action: "Use it" });
       if (!ok) return;
     }
diff --git a/suite/components/money/MoneyPage.tsx b/suite/components/money/MoneyPage.tsx
index 00f3df84..c80ce6f8 100644
--- a/suite/components/money/MoneyPage.tsx
+++ b/suite/components/money/MoneyPage.tsx
@@ -10,6 +10,7 @@ import { daysUntil, longDate, todayIso } from "@/lib/dates";
 import { changeBudget, changeTeam, type TeamMoney } from "@/lib/money/edit";
 import { Button, Empty } from "@/components/ui/controls";
 import { ToolUndo } from "@/components/shell/ToolUndo";
+import { NumberInput } from "@/components/ui/NumberInput";
 
 const CONTROL = "rounded border border-charcoal/15 bg-parchment px-2 py-1 text-sm text-charcoal tabular-nums focus:border-gold";
 
@@ -63,7 +64,7 @@ export function MoneyPage() {
             label="Budget"
             value={accounts.budget}
             onCommit={(budget) => write(changeBudget(storedCrew(), budget), "the budget")}
-            className="mt-2 w-full text-2xl"
+            className={`${CONTROL} mt-2 w-full text-2xl`}
           />
         </div>
         <Figure label="Committed" value={amount(accounts.committed)}>
@@ -146,10 +147,10 @@ export function MoneyPage() {
                           {team.name}
                         </th>
                         <td className="px-3 py-1.5">
-                          <NumberInput label={`${team.name}: cost`} value={team.cost} onCommit={(cost) => change(team.id, { cost })} className="w-24" />
+                          <NumberInput label={`${team.name}: cost`} value={team.cost} onCommit={(cost) => change(team.id, { cost })} className={`${CONTROL} w-24`} />
                         </td>
                         <td className="px-3 py-1.5">
-                          <NumberInput label={`${team.name}: deposit`} value={team.deposit} onCommit={(deposit) => change(team.id, { deposit })} className="w-24" />
+                          <NumberInput label={`${team.name}: deposit`} value={team.deposit} onCommit={(deposit) => change(team.id, { deposit })} className={`${CONTROL} w-24`} />
                         </td>
                         <td className="px-3 py-1.5">
                           <DateInput label={`${team.name}: deposit paid on`} value={team.depositPaidOn} onChange={(depositPaidOn) => change(team.id, { depositPaidOn })} />
@@ -191,41 +192,6 @@ function Figure({ label, value, children }: { label: string; value: string; chil
   );
 }
 
-/** A whole amount, or nothing; written when you leave the field, not per keystroke. */
-function NumberInput({
-  label,
-  value,
-  onCommit,
-  className,
-}: {
-  label: string;
-  value: number | null;
-  onCommit: (value: number | null) => void;
-  className: string;
-}) {
-  return (
-    <input
-      // Keyed on the stored value, so an undo shows through.
-      key={value ?? "none"}
-      type="number"
-      min={0}
-      step={1}
-      aria-label={label}
-      defaultValue={value ?? ""}
-      placeholder="—"
-      onBlur={(event) => {
-        const text = event.target.value.trim();
-        const next = text === "" ? null : Math.max(0, Math.round(Number(text)));
-        if (next !== value && (next === null || Number.isFinite(next))) onCommit(next);
-      }}
-      onKeyDown={(event) => {
-        if (event.key === "Enter") event.currentTarget.blur();
-      }}
-      className={`${CONTROL} ${className}`}
-    />
-  );
-}
-
 function DateInput({ label, value, onChange }: { label: string; value: string; onChange: (value: string) => void }) {
   return <input type="date" aria-label={label} value={value} onChange={(event) => onChange(event.target.value)} className={CONTROL} />;
 }
diff --git a/suite/components/shell/Header.tsx b/suite/components/shell/Header.tsx
index 23e1b373..8e8bb541 100644
--- a/suite/components/shell/Header.tsx
+++ b/suite/components/shell/Header.tsx
@@ -4,9 +4,10 @@ import { useEffect, useState } from "react";
 import dynamic from "next/dynamic";
 import Link from "next/link";
 import { usePathname } from "next/navigation";
-import { Search } from "lucide-react";
+import { Plus, Search } from "lucide-react";
 import { useTrousseauStore } from "@/lib/store/useTrousseauStore";
-import { TOOLS } from "@/lib/tools";
+import { shownTools } from "@/lib/model/toolbox";
+import { GUESTS } from "@/lib/tools";
 import { AccountStatus } from "./AccountStatus";
 import { WeddingMenu } from "./WeddingMenu";
 import { HowThisWorks } from "./TourButtons";
@@ -16,6 +17,7 @@ import { WhoIsHere } from "./WhoIsHere";
 import { useDataPanel } from "./dataPanel";
 import { useGuestImport } from "./guestImportPanel";
 import { useSyncPanel } from "./syncPanel";
+import { useToolsPanel } from "./toolsPanel";
 import { usePalette } from "./CommandPalette";
 
 const DataManager = dynamic(() => import("./DataManager").then((m) => m.DataManager), {
@@ -27,6 +29,9 @@ const GuestImport = dynamic(() => import("./GuestImport").then((m) => m.GuestImp
 const SyncHistory = dynamic(() => import("./SyncHistory").then((m) => m.SyncHistory), {
   ssr: false,
 });
+const ToolsPanel = dynamic(() => import("./ToolsPanel").then((m) => m.ToolsPanel), {
+  ssr: false,
+});
 const CommandPalette = dynamic(() => import("./CommandPalette").then((m) => m.CommandPalette), {
   ssr: false,
 });
@@ -63,6 +68,16 @@ export function Header() {
   const [syncEverOpened, setSyncEverOpened] = useState(false);
   if (syncOpen && !syncEverOpened) setSyncEverOpened(true);
   useEffect(() => useSyncPanel.getState().fromAddress(), []);
+  // Tools, adding and removing them, loaded the same way; `?panel=tools` opens it.
+  const toolsOpen = useToolsPanel((s) => s.open);
+  const showTools = useToolsPanel((s) => s.show);
+  const hideTools = useToolsPanel((s) => s.hide);
+  const [toolsEverOpened, setToolsEverOpened] = useState(false);
+  if (toolsOpen && !toolsEverOpened) setToolsEverOpened(true);
+  useEffect(() => useToolsPanel.getState().fromAddress(), []);
+  // The guest list, then the wedding's own choice of tools, the same for
+  // everyone planning it.
+  const tools = useTrousseauStore((s) => shownTools(s.doc));
   // The palette: its button, and Ctrl/⌘ K from anywhere.
   const paletteOpen = usePalette((s) => s.open);
   const showPalette = usePalette((s) => s.show);
@@ -96,7 +111,7 @@ export function Header() {
           {/* Scrolls within the header on a narrow screen, rather than making
               the whole page wider than it and pushing Data off the edge. */}
           <nav aria-label="Tools" className="flex min-w-0 items-center gap-1 overflow-x-auto">
-            {TOOLS.map((tool) => {
+            {[GUESTS, ...tools].map((tool) => {
               const active = pathname === tool.href;
               return (
                 <Link
@@ -116,6 +131,15 @@ export function Header() {
                 </Link>
               );
             })}
+            <button
+              type="button"
+              onClick={showTools}
+              aria-label="Add or remove tools"
+              title="Add or remove tools"
+              className="flex shrink-0 items-center rounded px-2 py-1.5 text-slate transition hover:bg-stone/60 hover:text-charcoal"
+            >
+              <Plus size={16} aria-hidden />
+            </button>
           </nav>
 
           {/*
@@ -127,8 +151,13 @@ export function Header() {
             * `safe` end alignment: plain `justify-end` pushes overflow out of
             * the start edge, where no scrollbar can reach it, and Timeline's
             * zoom and Present buttons sat there invisible at 1440px.
+            *
+            * Never narrower than what the tool put here: when the row is short
+            * of room, the tabs give way and scroll instead. With every tool
+            * added, the tabs took the room at 1024px and four of Timeline's
+            * controls sat out of sight — measured, and the header test's case.
             */}
-          <div className="flex min-w-0 flex-1 items-center justify-end-safe gap-1 overflow-x-auto [&_button]:whitespace-nowrap [&>*]:shrink-0">
+          <div className="flex shrink-0 grow basis-auto items-center justify-end-safe gap-1 [&_button]:whitespace-nowrap [&>*]:shrink-0">
             <ChromeSlot name="tool-actions" />
           </div>
           <div className="hidden shrink-0 items-center sm:flex">
@@ -156,6 +185,7 @@ export function Header() {
       {dataEverOpened ? <DataManager open={dataOpen} onClose={hideData} /> : null}
       {importEverOpened ? <GuestImport /> : null}
       {syncEverOpened ? <SyncHistory open={syncOpen} onClose={hideSync} /> : null}
+      {toolsEverOpened ? <ToolsPanel open={toolsOpen} onClose={hideTools} /> : null}
       {paletteEverOpened ? <CommandPalette /> : null}
     </>
   );
diff --git a/suite/components/shell/Overview.tsx b/suite/components/shell/Overview.tsx
index d31dce89..50d3afaf 100644
--- a/suite/components/shell/Overview.tsx
+++ b/suite/components/shell/Overview.tsx
@@ -2,23 +2,16 @@
 
 import Link from "next/link";
 import { useMemo } from "react";
-import { AlertTriangle, ArrowRight, Banknote, Check, ListChecks, Users, type LucideIcon } from "lucide-react";
+import { AlertTriangle, ArrowRight, Check } from "lucide-react";
 import { useTrousseauStore } from "@/lib/store/useTrousseauStore";
 import { readiness, type Readiness } from "@/lib/model/readiness";
 import { overview, type Area, type AreaId } from "@/lib/model/overview";
-import { TOOLS } from "@/lib/tools";
+import { GUESTS, TOOLS, type Tab } from "@/lib/tools";
 import { SignInFailed } from "./SignInFailed";
 import { TakeTheTour } from "./TourButtons";
 
 /** Where each area is worked on, and how it is drawn. */
-const PLACES: Record<AreaId, { name: string; href: string; icon: LucideIcon; tokens: string }> = {
-  guests: { name: "Guests", href: "/guests", icon: Users, tokens: "tableaux-tokens" },
-  money: { name: "Money", href: "/money", icon: Banknote, tokens: "brigade-tokens" },
-  checklist: { name: "Checklist", href: "/checklist", icon: ListChecks, tokens: "brigade-tokens" },
-  ...(Object.fromEntries(
-    TOOLS.map((tool) => [tool.href.slice(1), { name: tool.name, href: tool.href, icon: tool.icon, tokens: tool.tokens }]),
-  ) as Record<Exclude<AreaId, "guests" | "money" | "checklist">, { name: string; href: string; icon: LucideIcon; tokens: string }>),
-};
+const PLACES = { guests: GUESTS, ...Object.fromEntries(TOOLS.map((tool) => [tool.id, tool])) } as Record<AreaId, Tab>;
 
 /**
  * The wedding's state: the one thing to do next, how far along each part is,
diff --git a/suite/components/shell/ToolsPanel.tsx b/suite/components/shell/ToolsPanel.tsx
new file mode 100644
index 00000000..0ccf5955
--- /dev/null
+++ b/suite/components/shell/ToolsPanel.tsx
@@ -0,0 +1,72 @@
+"use client";
+
+import { Plus, X } from "lucide-react";
+import { useTrousseauStore } from "@/lib/store/useTrousseauStore";
+import { shownTools, withTool } from "@/lib/model/toolbox";
+import { TOOLS, type Tool } from "@/lib/tools";
+import { Button } from "@/components/ui/controls";
+import { SlideOver } from "@/components/ui/SlideOver";
+
+/**
+ * The tools this wedding uses, each with what it is for, and Add or Remove.
+ *
+ * The choice is kept in the wedding, so whoever it is planned with sees the
+ * same tools. Removing one hides it and nothing more: what was made in it is
+ * kept, and is there again when it is added back. Either is one step on the
+ * wedding's history.
+ */
+export function ToolsPanel({ open, onClose }: { open: boolean; onClose: () => void }) {
+  const shown = useTrousseauStore((s) => shownTools(s.doc));
+  // The store refuses a write before the wedding is read; say so by being off.
+  const ready = useTrousseauStore((s) => s.status === "ready");
+  const setSlice = useTrousseauStore((s) => s.setSlice);
+
+  const choose = (tool: Tool, show: boolean) =>
+    setSlice("tools", withTool(useTrousseauStore.getState().raw, tool.id, show), {
+      label: `${show ? "adding" : "removing"} ${tool.name}`,
+    });
+
+  return (
+    <SlideOver open={open} onClose={onClose} labelledBy="tools-title">
+      <div className="flex h-full flex-col">
+        <div className="flex items-center justify-between border-b border-charcoal/10 px-5 py-4">
+          <h2 id="tools-title" className="font-display text-2xl text-charcoal">
+            Tools
+          </h2>
+          <button type="button" onClick={onClose} aria-label="Close" className="rounded p-1.5 text-slate hover:bg-stone hover:text-charcoal">
+            <X size={18} aria-hidden />
+          </button>
+        </div>
+        <div className="flex-1 overflow-y-auto px-5 py-5">
+          <p className="text-sm text-slate">The tools this wedding uses. Whoever you plan it with sees the same ones.</p>
+          <ul className="mt-4 space-y-3">
+            {TOOLS.map((tool) => {
+              const on = shown.includes(tool);
+              return (
+                <li key={tool.id} className={`${tool.tokens} flex items-center gap-3 rounded border border-charcoal/10 bg-stone/40 p-3`}>
+                  <tool.icon size={18} aria-hidden className="shrink-0 text-[var(--accent-bright)]" />
+                  <div className="min-w-0 flex-1">
+                    <p className="text-sm text-charcoal">{tool.name}</p>
+                    <p className="text-xs text-slate">{tool.tagline}</p>
+                  </div>
+                  {on ? (
+                    <Button onClick={() => choose(tool, false)} disabled={!ready}>
+                      Remove<span className="sr-only"> {tool.name}</span>
+                    </Button>
+                  ) : (
+                    <Button tone="primary" icon={Plus} onClick={() => choose(tool, true)} disabled={!ready}>
+                      Add<span className="sr-only"> {tool.name}</span>
+                    </Button>
+                  )}
+                </li>
+              );
+            })}
+          </ul>
+          <p className="mt-4 text-xs text-slate">
+            Removing a tool only hides it. Everything made in it is kept, and is there again when you add it back.
+          </p>
+        </div>
+      </div>
+    </SlideOver>
+  );
+}
diff --git a/suite/components/shell/WeddingPack.tsx b/suite/components/shell/WeddingPack.tsx
index b5be6a59..1193e3d6 100644
--- a/suite/components/shell/WeddingPack.tsx
+++ b/suite/components/shell/WeddingPack.tsx
@@ -5,14 +5,16 @@ import { FileDown } from "lucide-react";
 import { useTrousseauStore } from "@/lib/store/useTrousseauStore";
 import { KO_FI_URL } from "@/lib/support";
 import type { PackSection } from "@/lib/export/weddingPack";
-import { readGuests, readSeating, readShots, readTimeline } from "@/lib/model/slices";
+import { hiddenToolIds } from "@/lib/model/toolbox";
+import { readBar, readBoxes, readCast, readCeremony, readCrew, readGuests, readSeating, readShots, readTimeline } from "@/lib/model/slices";
 
 /**
  * The one button that produces everything you carry on the day.
  *
  * It lives here rather than in any one tool because it is the only
  * thing in the suite that is not any one tool's job: the plan comes from the
- * room, the running order from the day, the jobs from the crew, and the whole
+ * room, the running order from the day, the processional from the ceremony,
+ * the jobs from the crew, the drinks from the bar, and the whole
  * point is that they are printed from the same wedding at the same moment.
  *
  * Sections are gathered one at a time and a failure is reported rather than
@@ -41,7 +43,10 @@ export function WeddingPack() {
     for (const [title, make] of [
       ["The room", floorPlan],
       ["The day", runSheet],
+      ["The processional", processional],
       ["The jobs", jobList],
+      ["The boxes", packingList],
+      ["The drinks", drinksList],
       ["The shots", shotSheet],
     ] as const) {
       try {
@@ -82,8 +87,9 @@ export function WeddingPack() {
     <div data-tour="shell.pack" className="rounded-lg border border-charcoal/10 bg-stone/60 p-6">
       <h2 className="mb-1 text-lg text-charcoal">The wedding pack</h2>
       <p className="mb-4 max-w-prose text-sm text-slate">
-        The floor plan, the run sheet, the job list and the group shot list as one document,
-        printed from the wedding as it stands right now. Place cards are a separate print — they
+        The floor plan, the run sheet, the job list and the group shot list — and the processional,
+        the packing list and the drinks to buy, from the tools you use — as one document, printed
+        from the wedding as it stands right now. Place cards are a separate print — they
         go on card stock, not in a binder.
       </p>
 
@@ -173,9 +179,71 @@ async function jobList(): Promise<Uint8Array | null> {
   });
 }
 
+async function processional(): Promise<Uint8Array | null> {
+  const { doc } = useTrousseauStore.getState();
+  const groups = readCeremony(doc).processional;
+  if (groups.length === 0) return null;
+
+  const [{ renderProcessionalSheet }, { browserFontSource }, { processionalRows }] = await Promise.all([
+    import("@/lib/ceremony/render/pdf/processionalSheet"),
+    import("@/apps/brigade/render/pdf/fontSource"),
+    import("@/lib/ceremony/rows"),
+  ]);
+
+  return renderProcessionalSheet(processionalRows(groups, readGuests(doc), readSeating(doc), readCast(doc), doc.event), {
+    fontSource: browserFontSource(),
+    coupleNames: doc.event.coupleNames,
+    generatedOn: `Made with Trousseau, ${new Date().toLocaleDateString()}`,
+  });
+}
+
+async function drinksList(): Promise<Uint8Array | null> {
+  const { doc } = useTrousseauStore.getState();
+  // Worked out for any wedding with guests, so printed only for one using the Bar.
+  if (hiddenToolIds(doc).has("bar")) return null;
+
+  const [{ renderShoppingList }, { browserFontSource }, { forWords, shoppingList, spendWords }, { barSum }] = await Promise.all([
+    import("@/lib/bar/render/pdf/shoppingList"),
+    import("@/apps/brigade/render/pdf/fontSource"),
+    import("@/lib/bar/rows"),
+    import("@/lib/bar/sum"),
+  ]);
+  const sum = barSum(doc);
+  const groups = shoppingList(readBar(doc), sum);
+  if (groups.length === 0) return null;
+
+  return renderShoppingList(groups, {
+    fontSource: browserFontSource(),
+    coupleNames: doc.event.coupleNames,
+    forWhom: forWords(sum),
+    spend: spendWords(sum),
+    generatedOn: `Made with Trousseau, ${new Date().toLocaleDateString()}`,
+  });
+}
+
+async function packingList(): Promise<Uint8Array | null> {
+  const { doc } = useTrousseauStore.getState();
+  const boxes = readBoxes(doc);
+  if (boxes.boxes.length === 0) return null;
+
+  const [{ renderPackingList }, { browserFontSource }, { boxRows }, { dayPlaces }] = await Promise.all([
+    import("@/lib/boxes/render/pdf/packingList"),
+    import("@/apps/brigade/render/pdf/fontSource"),
+    import("@/lib/boxes/rows"),
+    import("@/lib/boxes/view"),
+  ]);
+
+  return renderPackingList(boxRows(boxes, dayPlaces(doc), readCrew(doc), readGuests(doc)), {
+    fontSource: browserFontSource(),
+    coupleNames: doc.event.coupleNames,
+    generatedOn: `Made with Trousseau, ${new Date().toLocaleDateString()}`,
+  });
+}
+
 async function shotSheet(): Promise<Uint8Array | null> {
   const { doc } = useTrousseauStore.getState();
   const shots = readShots(doc);
+  const cast = readCast(doc);
   const total = shots.sections.reduce((sum, section) => sum + section.shots.length, 0);
   if (total === 0) return null;
 
@@ -188,13 +256,13 @@ async function shotSheet(): Promise<Uint8Array | null> {
     shots.sections,
     readGuests(doc),
     readSeating(doc),
-    shots.cast,
+    cast.roles,
     {
       fontSource: browserFontSource(),
       coupleNames: doc.event.coupleNames,
       partners: doc.event.partners,
       generatedOn: `Made with Trousseau, ${new Date().toLocaleDateString()}`,
     },
-    shots.customRoles,
+    cast.customRoles,
   );
 }
diff --git a/suite/components/shell/addressablePanel.ts b/suite/components/shell/addressablePanel.ts
new file mode 100644
index 00000000..486702df
--- /dev/null
+++ b/suite/components/shell/addressablePanel.ts
@@ -0,0 +1,40 @@
+import { create } from "zustand";
+
+/**
+ * Whether a slide-over is open. Addressable, as the design's slide-overs are:
+ * `?panel=<name>` opens it, and opening it puts that in the address, so a link
+ * to it — or a reload — lands with it open.
+ */
+export interface AddressablePanel {
+  open: boolean;
+  show: () => void;
+  hide: () => void;
+  /** Open it if the address asks for it. Called once, as the page loads. */
+  fromAddress: () => void;
+}
+
+const PARAM = "panel";
+
+export function addressablePanel(name: string) {
+  const address = (open: boolean) => {
+    const url = new URL(window.location.href);
+    if (open) url.searchParams.set(PARAM, name);
+    else url.searchParams.delete(PARAM);
+    window.history.replaceState(window.history.state, "", url);
+  };
+
+  return create<AddressablePanel>()((set) => ({
+    open: false,
+    show: () => {
+      address(true);
+      set({ open: true });
+    },
+    hide: () => {
+      address(false);
+      set({ open: false });
+    },
+    fromAddress: () => {
+      if (new URLSearchParams(window.location.search).get(PARAM) === name) set({ open: true });
+    },
+  }));
+}
diff --git a/suite/components/shell/syncPanel.ts b/suite/components/shell/syncPanel.ts
index 0cc66f71..f238e588 100644
--- a/suite/components/shell/syncPanel.ts
+++ b/suite/components/shell/syncPanel.ts
@@ -1,39 +1,4 @@
-import { create } from "zustand";
+import { addressablePanel } from "./addressablePanel";
 
-/**
- * Whether Sync & history is open. Addressable, as the design's slide-overs
- * are: `?panel=sync` opens it, and opening it puts that in the address, so a
- * link to it — or a reload — lands with it open.
- */
-interface SyncPanel {
-  open: boolean;
-  show: () => void;
-  hide: () => void;
-  /** Open it if the address asks for it. Called once, as the page loads. */
-  fromAddress: () => void;
-}
-
-const PARAM = "panel";
-const VALUE = "sync";
-
-function address(open: boolean) {
-  const url = new URL(window.location.href);
-  if (open) url.searchParams.set(PARAM, VALUE);
-  else url.searchParams.delete(PARAM);
-  window.history.replaceState(window.history.state, "", url);
-}
-
-export const useSyncPanel = create<SyncPanel>()((set) => ({
-  open: false,
-  show: () => {
-    address(true);
-    set({ open: true });
-  },
-  hide: () => {
-    address(false);
-    set({ open: false });
-  },
-  fromAddress: () => {
-    if (new URLSearchParams(window.location.search).get(PARAM) === VALUE) set({ open: true });
-  },
-}));
+/** Whether Sync & history is open: `?panel=sync`. */
+export const useSyncPanel = addressablePanel("sync");
diff --git a/suite/components/shell/toolsPanel.ts b/suite/components/shell/toolsPanel.ts
new file mode 100644
index 00000000..56b04ade
--- /dev/null
+++ b/suite/components/shell/toolsPanel.ts
@@ -0,0 +1,4 @@
+import { addressablePanel } from "./addressablePanel";
+
+/** Whether Tools — adding and removing them — is open: `?panel=tools`. */
+export const useToolsPanel = addressablePanel("tools");
diff --git a/suite/components/ui/NumberInput.tsx b/suite/components/ui/NumberInput.tsx
new file mode 100644
index 00000000..76d97978
--- /dev/null
+++ b/suite/components/ui/NumberInput.tsx
@@ -0,0 +1,50 @@
+"use client";
+
+/**
+ * A number, or nothing: written when you leave the field or press Enter,
+ * never per keystroke. An emptied box is nothing — "not agreed", "no time
+ * typed" — rather than a zero, and the caller says which it means.
+ *
+ * Whole numbers unless given a `step`, which it rounds to: 0.25 for hours,
+ * 0.01 for a price.
+ *
+ * Styled by the caller, so the pages' kit and the tools' kit can both use it.
+ */
+export function NumberInput({
+  label,
+  value,
+  onCommit,
+  className,
+  step = 1,
+  placeholder = "—",
+}: {
+  label: string;
+  value: number | null;
+  onCommit: (value: number | null) => void;
+  className: string;
+  step?: number;
+  placeholder?: string;
+}) {
+  const places = (String(step).split(".")[1] ?? "").length;
+  return (
+    <input
+      // Keyed on the stored value, so an undo shows through.
+      key={value ?? "none"}
+      type="number"
+      min={0}
+      step={step}
+      aria-label={label}
+      defaultValue={value ?? ""}
+      placeholder={placeholder}
+      onBlur={(event) => {
+        const text = event.target.value.trim();
+        const next = text === "" ? null : Number((Math.max(0, Math.round(Number(text) / step)) * step).toFixed(places));
+        if (next !== value && (next === null || Number.isFinite(next))) onCommit(next);
+      }}
+      onKeyDown={(event) => {
+        if (event.key === "Enter") event.currentTarget.blur();
+      }}
+      className={className}
+    />
+  );
+}
diff --git a/suite/e2e/a11y.spec.ts b/suite/e2e/a11y.spec.ts
index 50d5139f..346de06d 100644
--- a/suite/e2e/a11y.spec.ts
+++ b/suite/e2e/a11y.spec.ts
@@ -8,7 +8,7 @@ import { seedExampleWedding } from "./wedding";
  * included: landmarks and headings are how a screen reader user finds their
  * way around, and they are what these pages got wrong.
  */
-const PAGES = ["/", "/guests", "/money", "/checklist", "/library", "/binder", "/seating", "/place-cards", "/timeline", "/delegation", "/group-shots", "/account", "/login", "/support", "/setup", "/weddings"];
+const PAGES = ["/", "/guests", "/money", "/checklist", "/library", "/binder", "/seating", "/place-cards", "/timeline", "/delegation", "/group-shots", "/ceremony", "/boxes", "/bar", "/account", "/login", "/support", "/setup", "/weddings"];
 
 for (const path of PAGES) {
   test(`${path} has no accessibility violations`, async ({ page }) => {
@@ -62,6 +62,13 @@ test("the Data panel, open, has no accessibility violations", async ({ page }) =
   await noViolations(page);
 });
 
+test("the Tools panel, open, has no accessibility violations", async ({ page }) => {
+  await seedExampleWedding(page);
+  await page.goto("/?panel=tools");
+  await expect(page.getByRole("dialog", { name: "Tools" })).toBeVisible();
+  await noViolations(page);
+});
+
 test("the tour, open, has no accessibility violations", async ({ page }) => {
   await seedExampleWedding(page);
   await page.goto("/");
diff --git a/suite/e2e/bar.spec.ts b/suite/e2e/bar.spec.ts
new file mode 100644
index 00000000..2090e22e
--- /dev/null
+++ b/suite/e2e/bar.spec.ts
@@ -0,0 +1,84 @@
+import { readFileSync } from "node:fs";
+import { expect, test } from "@playwright/test";
+import { seedExampleWedding, storedDocument } from "./wedding";
+
+/*
+ * The Bar keeps only what the couple chose: the amounts are worked out from
+ * the guest list every time, and a figure put back is forgotten.
+ */
+const row = (page: Parameters<typeof storedDocument>[0], drink: string) =>
+  page.getByRole("table", { name: "What to buy" }).getByRole("row").filter({ has: page.getByRole("cell", { name: drink, exact: true }) });
+
+test("the example wedding's drinks come to whole cases, and its priced lines to an estimate", async ({ page }) => {
+  await seedExampleWedding(page);
+  await page.goto("/bar");
+  // 100 coming and 30 for the evening, a fifth of them not drinking.
+  await expect(page.getByText("104 drinking alcohol, 26 on soft drinks")).toBeVisible();
+  await expect(row(page, "Fizz")).toContainText("42 bottles7 cases of 6");
+  await expect(row(page, "Beer and cider")).toContainText("240 bottles or cans10 cases of 24");
+  // Two bottles of spirits in the cupboard: one more to buy.
+  await expect(row(page, "Spirits")).toContainText("1 70cl bottle");
+  await expect(page.getByText("About 1,206 for what has a price; 4 to buy with no price yet.")).toBeVisible();
+});
+
+test("a figure changed is kept, shows what it usually is, and goes back in one click", async ({ page }) => {
+  await seedExampleWedding(page);
+  await page.goto("/bar");
+  const hours = page.getByRole("spinbutton", { name: "Hours of the evening bar" });
+  await hours.fill("5");
+  await hours.press("Enter");
+  await expect.poll(async () => (await storedDocument(page)).bar?.figures?.eveningHours).toBe(5);
+  await expect(page.getByText("5 each in the evening")).toBeVisible();
+
+  await page.getByRole("button", { name: "Put hours of the evening bar back to 4" }).click();
+  await expect.poll(async () => (await storedDocument(page)).bar?.figures?.eveningHours).toBeUndefined();
+  await expect(hours).toHaveValue("4");
+
+  await page.getByRole("button", { name: "Undo putting a figure back" }).click();
+  await expect(hours).toHaveValue("5");
+});
+
+test("a new wedding adds the Bar from Tools and buys for the number typed", async ({ page }) => {
+  await page.goto("/");
+  const tabs = page.getByRole("navigation", { name: "Tools" });
+  await tabs.getByRole("button", { name: "Add or remove tools" }).click();
+  await page.getByRole("dialog", { name: "Tools" }).getByRole("button", { name: "Add Bar" }).click();
+  await page.keyboard.press("Escape");
+  await tabs.getByRole("link", { name: "Bar" }).click();
+
+  await expect(page.getByText("Nobody to buy for yet.")).toBeVisible();
+  const coming = page.getByRole("spinbutton", { name: "How many are coming" });
+  await coming.fill("100");
+  await coming.press("Enter");
+  await expect(page.getByText("Typed: the guest list has 0.")).toBeVisible();
+  // The agreed defaults, for 100.
+  await expect(row(page, "Fizz")).toContainText("42 bottles");
+  await expect(row(page, "Ice")).toContainText("100 kilos");
+
+  await page.getByRole("combobox", { name: "What kind of bar" }).selectOption({ label: "No and low" });
+  await expect(row(page, "Alcohol-free fizz")).toContainText("42 bottles");
+  await expect(row(page, "Alcohol-free spirits")).toContainText("—");
+});
+
+test("the drinks print as a shopping list, download as CSV, and join the pack only while the Bar is shown", async ({ page }) => {
+  await seedExampleWedding(page);
+  await page.goto("/bar");
+  const save = async (button: string) => {
+    const [download] = await Promise.all([page.waitForEvent("download"), page.getByRole("button", { name: button, exact: true }).click()]);
+    return download;
+  };
+  expect((await save("Shopping list")).suggestedFilename()).toBe("alex-and-sam-drinks.pdf");
+  const csv = await save("CSV");
+  expect(csv.suggestedFilename()).toBe("alex-and-sam-drinks.csv");
+  expect(readFileSync(await csv.path(), "utf8")).toContain("Wine merchant,Fizz,42 bottles,7 cases of 6,8.50,357.00");
+
+  await page.goto("/");
+  await Promise.all([page.waitForEvent("download"), page.getByRole("button", { name: "Download the pack" }).click()]);
+  await expect(page.getByText(/The boxes \(\d+\), The drinks \(1\)/)).toBeVisible();
+
+  await page.goto("/?panel=tools");
+  await page.getByRole("dialog", { name: "Tools" }).getByRole("button", { name: "Remove Bar" }).click();
+  await page.keyboard.press("Escape");
+  await Promise.all([page.waitForEvent("download"), page.getByRole("button", { name: "Download the pack" }).click()]);
+  await expect(page.getByText(/The boxes \(\d+\), The shots/)).toBeVisible();
+});
diff --git a/suite/e2e/boxes.spec.ts b/suite/e2e/boxes.spec.ts
new file mode 100644
index 00000000..53ee7bdb
--- /dev/null
+++ b/suite/e2e/boxes.spec.ts
@@ -0,0 +1,83 @@
+import { readFileSync } from "node:fs";
+import { expect, test } from "@playwright/test";
+import { seedExampleWedding, storedDocument } from "./wedding";
+
+type StoredBox = { id: string; items: Array<{ id: string; label: string; packed: boolean }> };
+const stored = async (page: Parameters<typeof storedDocument>[0], boxId: string) =>
+  ((await storedDocument(page)).boxes?.boxes as StoredBox[]).find((box) => box.id === boxId)!;
+
+/*
+ * Boxes keeps no copy: a tick is in the wedding when it is made, and the
+ * header's undo takes it back. Where a box has to be, and by when, is the
+ * Timeline's.
+ */
+test("shoes are found in their box, which says where it has to be and by when", async ({ page }) => {
+  await seedExampleWedding(page);
+  await page.goto("/boxes");
+  const list = page.getByRole("list", { name: "The boxes" });
+  await expect(list.getByRole("listitem")).toHaveCount(4);
+  await expect(list.getByRole("listitem").nth(1)).toContainText("The suite, by 08:00");
+
+  await page.getByRole("textbox", { name: "Find something" }).fill("shoes");
+  await page.getByRole("list", { name: "Found" }).getByRole("button", { name: /Shoes\s*In box 2, Getting ready/ }).click();
+  await expect(page.getByRole("textbox", { name: "Name" })).toHaveValue("Getting ready");
+});
+
+test("a thing ticked as packed is stored, and undo takes the tick back", async ({ page }) => {
+  await seedExampleWedding(page);
+  await page.goto("/boxes");
+  await page.getByRole("list", { name: "The boxes" }).getByRole("button", { name: /^2\. Getting ready/ }).click();
+
+  await page.getByRole("checkbox", { name: "Steamer is packed" }).check();
+  await expect.poll(async () => (await stored(page, "box-getting-ready")).items.find((item) => item.label === "Steamer")?.packed).toBe(true);
+
+  await page.getByRole("button", { name: "Undo packing" }).click();
+  await expect(page.getByRole("checkbox", { name: "Steamer is packed" })).not.toBeChecked();
+});
+
+test("a thing moved to another box goes, and lands at the end of it", async ({ page }) => {
+  await seedExampleWedding(page);
+  await page.goto("/boxes");
+  await page.getByRole("list", { name: "The boxes" }).getByRole("button", { name: /^2\. Getting ready/ }).click();
+
+  await page.getByRole("combobox", { name: "Move Steamer to another box" }).selectOption({ label: "Box 4 — Overnight and the day after" });
+  await expect
+    .poll(async () => (await stored(page, "box-overnight")).items.map((item) => item.label))
+    .toEqual(["Clothes for the day after", "Toiletries", "Passports and travel documents", "Steamer"]);
+  expect((await stored(page, "box-getting-ready")).items.map((item) => item.label)).not.toContain("Steamer");
+});
+
+test("a new wedding adds Boxes from Tools and starts from the usual ones", async ({ page }) => {
+  await page.goto("/");
+  const tabs = page.getByRole("navigation", { name: "Tools" });
+  await tabs.getByRole("button", { name: "Add or remove tools" }).click();
+  await page.getByRole("dialog", { name: "Tools" }).getByRole("button", { name: "Add Boxes" }).click();
+  await page.keyboard.press("Escape");
+  await tabs.getByRole("link", { name: "Boxes" }).click();
+
+  await page.getByRole("button", { name: "Add the usual boxes" }).click();
+  await expect(page.getByRole("list", { name: "The boxes" }).getByRole("listitem")).toHaveText([
+    /1\. The rings and the paperwork/,
+    /2\. Getting ready/,
+    /3\. The day's odds and ends/,
+    /4\. Overnight and the day after/,
+  ]);
+  await expect(page.getByRole("button", { name: "Add the usual boxes" })).toHaveCount(0);
+});
+
+test("the boxes print as labels and a packing list, and download as CSV", async ({ page }) => {
+  await seedExampleWedding(page);
+  await page.goto("/boxes");
+  const save = async (button: string) => {
+    const [download] = await Promise.all([page.waitForEvent("download"), page.getByRole("button", { name: button, exact: true }).click()]);
+    return download;
+  };
+
+  expect((await save("Labels")).suggestedFilename()).toBe("alex-and-sam-box-labels.pdf");
+  expect((await save("Packing list")).suggestedFilename()).toBe("alex-and-sam-packing-list.pdf");
+  const csv = await save("CSV");
+  expect(csv.suggestedFilename()).toBe("alex-and-sam-boxes.csv");
+  const text = readFileSync(await csv.path(), "utf8");
+  expect(text.split(/\r?\n/)[0]).toBe("Box,Name,Needed,Taken by,Item,How many,Packed");
+  expect(text).toContain("Getting ready");
+});
diff --git a/suite/e2e/ceremony.spec.ts b/suite/e2e/ceremony.spec.ts
new file mode 100644
index 00000000..f5ade212
--- /dev/null
+++ b/suite/e2e/ceremony.spec.ts
@@ -0,0 +1,63 @@
+import { expect, test } from "@playwright/test";
+import { seedExampleWedding, storedDocument } from "./wedding";
+
+const order = async (page: Parameters<typeof storedDocument>[0]) =>
+  ((await storedDocument(page)).ceremony?.processional ?? []).map((group: { id: string }) => group.id);
+
+/*
+ * Ceremony keeps no copy: the processional is in the wedding as it is changed,
+ * and the header's undo takes a change back.
+ */
+test("the processional walks in its order, and a group moved is moved in the wedding", async ({ page }) => {
+  await seedExampleWedding(page);
+  await page.goto("/ceremony");
+  const processional = page.getByRole("list", { name: "The processional" });
+  await expect(processional.getByRole("listitem")).toHaveCount(6);
+  await expect(processional.getByRole("listitem").first()).toContainText("1. The registrar");
+  await expect(processional.getByRole("listitem").last()).toContainText("6. Alex + Sam");
+
+  await page.getByRole("button", { name: "Move Alex + Sam earlier" }).click();
+  await expect.poll(() => order(page)).toEqual([
+    "walk-registrar",
+    "walk-a-parents",
+    "walk-b-parents",
+    "walk-a-party",
+    "walk-couple",
+    "walk-b-party",
+  ]);
+
+  await page.getByRole("button", { name: "Undo changing the order" }).click();
+  await expect.poll(async () => (await order(page)).at(-1)).toBe("walk-couple");
+});
+
+test("a new wedding adds Ceremony from Tools and is given a starting order, and told who is missing", async ({ page }) => {
+  await page.goto("/");
+  const tabs = page.getByRole("navigation", { name: "Tools" });
+  await tabs.getByRole("button", { name: "Add or remove tools" }).click();
+  await page.getByRole("dialog", { name: "Tools" }).getByRole("button", { name: "Add Ceremony" }).click();
+  await page.keyboard.press("Escape");
+  await tabs.getByRole("link", { name: "Ceremony" }).click();
+
+  await page.getByRole("button", { name: "Suggest an order" }).click();
+  const processional = page.getByRole("list", { name: "The processional" });
+  await expect(processional.getByRole("listitem")).toHaveText([/1\. The officiant/, /2\. Partner one \+ Partner two/]);
+
+  // Nobody is cast as either partner yet, and the page says so where it is fixed.
+  await processional.getByRole("button", { name: /^2\. Partner one \+ Partner two/ }).click();
+  await expect(page.getByText("No one is set as Partner one yet.")).toBeVisible();
+});
+
+test("the processional prints as a page, and copies as text for an email", async ({ page, context }) => {
+  await context.grantPermissions(["clipboard-read", "clipboard-write"]);
+  await seedExampleWedding(page);
+  await page.goto("/ceremony");
+
+  const [download] = await Promise.all([page.waitForEvent("download"), page.getByRole("button", { name: "Print" }).click()]);
+  expect(download.suggestedFilename()).toBe("alex-and-sam-processional.pdf");
+
+  await page.getByRole("button", { name: "Copy as text" }).click();
+  await expect(page.getByText("Copied — paste it into an email to the wedding party.")).toBeVisible();
+  const copied = await page.evaluate(() => navigator.clipboard.readText());
+  expect(copied.split("\n")[0]).toBe("The processional — Alex & Sam");
+  expect(copied).toContain("6. Alex + Sam");
+});
diff --git a/suite/e2e/header.spec.ts b/suite/e2e/header.spec.ts
index c3c3c264..401a481d 100644
--- a/suite/e2e/header.spec.ts
+++ b/suite/e2e/header.spec.ts
@@ -11,7 +11,8 @@ import { seedExampleWedding } from "./wedding";
 test.describe("at 1024px", () => {
   test.use({ viewport: { width: 1024, height: 768 } });
 
-  for (const tool of TOOLS) {
+  // The Binder is a page for a phone, outside the planning app's header.
+  for (const tool of TOOLS.filter((candidate) => candidate.id !== "binder")) {
     test(`${tool.name}'s own controls are all in view`, async ({ page }) => {
       await seedExampleWedding(page);
       await page.goto(tool.href);
diff --git a/suite/e2e/money.spec.ts b/suite/e2e/money.spec.ts
index 6d27e414..f777b364 100644
--- a/suite/e2e/money.spec.ts
+++ b/suite/e2e/money.spec.ts
@@ -35,5 +35,6 @@ test("a balance paid, and a budget cut, show wherever money is counted", async (
 
   await page.getByRole("navigation", { name: "Tools" }).getByRole("link", { name: "Delegation" }).click();
   await expect(page.getByRole("spinbutton", { name: "Budget" })).toHaveCount(0);
-  await expect(page.getByRole("link", { name: "Money" })).toBeVisible();
+  // Delegation's own pointer to Money, not the header's tab of the same name.
+  await expect(page.getByRole("main").getByRole("link", { name: "Money" })).toBeVisible();
 });
diff --git a/suite/e2e/palette.spec.ts b/suite/e2e/palette.spec.ts
index 04bd7754..a9da7e5a 100644
--- a/suite/e2e/palette.spec.ts
+++ b/suite/e2e/palette.spec.ts
@@ -53,5 +53,5 @@ test("the header's search button opens it too", async ({ page }) => {
   await page.goto("/");
   await page.getByRole("button", { name: "Find anything" }).click();
   await expect(page.getByRole("dialog", { name: "Find anything" })).toBeVisible();
-  await expect(page.getByRole("option")).toHaveCount(10);
+  await expect(page.getByRole("option")).toHaveCount(13);
 });
diff --git a/suite/e2e/timeline.spec.ts b/suite/e2e/timeline.spec.ts
index 04805c01..63b61f77 100644
--- a/suite/e2e/timeline.spec.ts
+++ b/suite/e2e/timeline.spec.ts
@@ -1,3 +1,4 @@
+import { readFileSync } from "node:fs";
 import { expect, test } from "@playwright/test";
 import { seedExampleWedding, storedDocument } from "./wedding";
 
@@ -25,3 +26,65 @@ test("a block renamed is stored at once, and the header's undo takes it back", a
   await expect.poll(() => ceremony(page)).toEqual({ label: "Ceremony", published: "Ceremony" });
   await expect(page.getByRole("textbox", { name: "Label" })).toHaveValue("Ceremony");
 });
+
+/*
+ * Travel: the photographer finishes the ceremony in the Orangery at 14:15 and
+ * is due at the confetti on the front steps at 14:15. Nothing is said until
+ * somebody types how long that walk takes.
+ */
+test("a journey's time is checked once typed, and taken back by undo", async ({ page }) => {
+  await seedExampleWedding(page);
+  await page.goto("/timeline");
+  const problems = page.locator('[data-tour="timeline.problems"]');
+  const short =
+    "Eleanor Vane Photography finishes Ceremony at 14:15 at Orangery, and is due at Confetti at 14:15 at Front steps, 5 minutes away: 5 minutes short.";
+  await expect(problems).not.toContainText("minutes short");
+
+  const minutes = page.getByRole("spinbutton", { name: "Minutes between Orangery and Front steps" });
+  await minutes.fill("5");
+  await minutes.press("Enter");
+
+  await expect(problems.getByRole("button", { name: short })).toBeVisible();
+  await expect
+    .poll(async () => (await storedDocument(page)).timeline.travel)
+    .toEqual([{ between: ["Orangery", "Front steps"], minutes: 5 }]);
+
+  await page.getByRole("button", { name: "Undo a journey's time" }).click();
+  await expect(problems).not.toContainText("minutes short");
+  await expect(minutes).toHaveValue("");
+});
+
+test("the day downloads as a calendar, whole or one supplier's part of it", async ({ page }) => {
+  await seedExampleWedding(page);
+  await page.goto("/timeline");
+  const summaries = (text: string) => text.split("\r\n").filter((line) => line.startsWith("SUMMARY:"));
+
+  const [whole] = await Promise.all([page.waitForEvent("download"), page.getByRole("button", { name: "Download calendar" }).click()]);
+  expect(whole.suggestedFilename()).toBe("alex-and-sam-the-day.ics");
+  const day = readFileSync(await whole.path(), "utf8");
+  expect(day).toContain("X-WR-CALNAME:Alex & Sam\r\n");
+  // The venue's clock, on the wedding's own date.
+  expect(day).toContain("SUMMARY:Ceremony\r\n");
+  expect(day).toContain("DTSTART:20280601T133000\r\n");
+  expect(summaries(day)).toHaveLength(27);
+
+  await page.getByRole("combobox", { name: "Calendar for" }).selectOption({ label: "County Registrar" });
+  const [one] = await Promise.all([page.waitForEvent("download"), page.getByRole("button", { name: "Download calendar" }).click()]);
+  expect(one.suggestedFilename()).toBe("alex-and-sam-county-registrar.ics");
+  expect(summaries(readFileSync(await one.path(), "utf8"))).toEqual(["SUMMARY:Rings to the best man", "SUMMARY:Ceremony"]);
+});
+
+/*
+ * The clocks. A new wedding's used to show British Summer Time as if chosen —
+ * a fallback — and choosing it did nothing, since it was already "selected".
+ */
+test("clocks nobody has set say so, and choosing British Summer Time sets it", async ({ page }) => {
+  await page.goto("/timeline");
+  const clocks = page.getByRole("combobox", { name: "Clocks" });
+  await expect(clocks.locator("option:checked")).toHaveText("Not set");
+  await expect(page.getByText("Set the clocks to see sunset and golden hour.")).toBeVisible();
+
+  await clocks.selectOption({ label: "UTC+1 (BST, CET)" });
+  await expect.poll(async () => (await storedDocument(page)).event?.utcOffsetMin).toBe(60);
+  await expect(page.getByText(/^Sunset \d\d:\d\d/)).toBeVisible();
+});
diff --git a/suite/e2e/tools.spec.ts b/suite/e2e/tools.spec.ts
new file mode 100644
index 00000000..3d087ecd
--- /dev/null
+++ b/suite/e2e/tools.spec.ts
@@ -0,0 +1,67 @@
+import { expect, test } from "@playwright/test";
+import { seedExampleWedding, storedDocument } from "./wedding";
+
+/*
+ * Which tools a wedding shows is the wedding's own choice, kept in it: the
+ * five by default, any of them removable, and a removal only ever hides.
+ */
+
+test("a new wedding has Guests and the five in the header, and adds the rest from Tools", async ({ page }) => {
+  await page.goto("/");
+  const tabs = page.getByRole("navigation", { name: "Tools" });
+  await expect(tabs.getByRole("link")).toHaveText(["Guests", "Seating", "Place cards", "Timeline", "Delegation", "Group shots"]);
+
+  await tabs.getByRole("button", { name: "Add or remove tools" }).click();
+  const panel = page.getByRole("dialog", { name: "Tools" });
+  // Guests is not in the toolbox: every tool is built on it, so it cannot go.
+  await expect(panel.getByRole("button", { name: /Guests/ })).toHaveCount(0);
+  await panel.getByRole("button", { name: "Add Money" }).click();
+  await page.keyboard.press("Escape");
+
+  await expect(tabs.getByRole("link", { name: "Money" })).toBeVisible();
+  await tabs.getByRole("link", { name: "Money" }).click();
+  await expect(page).toHaveURL(/\/money$/);
+});
+
+test("a tool removed from Tools leaves the header, and undo brings it back", async ({ page }) => {
+  await seedExampleWedding(page);
+  await page.goto("/checklist");
+  const tabs = page.getByRole("navigation", { name: "Tools" });
+  await expect(tabs.getByRole("link", { name: "Seating" })).toBeVisible();
+
+  await tabs.getByRole("button", { name: "Add or remove tools" }).click();
+  const panel = page.getByRole("dialog", { name: "Tools" });
+  await panel.getByRole("button", { name: "Remove Seating" }).click();
+  await expect(panel.getByRole("button", { name: "Add Seating" })).toBeVisible();
+  // Closed first: the header is inert behind the panel.
+  await page.keyboard.press("Escape");
+  await expect(panel).toBeHidden();
+
+  await expect(tabs.getByRole("link", { name: "Seating" })).toHaveCount(0);
+  await expect(tabs.getByRole("link", { name: "Timeline" })).toBeVisible();
+
+  await page.getByRole("button", { name: "Undo removing Seating" }).click();
+  await expect(tabs.getByRole("link", { name: "Seating" })).toBeVisible();
+});
+
+test("a removal is kept in the wedding and survives a reload", async ({ page }) => {
+  await seedExampleWedding(page);
+  // Addressable, as every slide-over is.
+  await page.goto("/?panel=tools");
+  const panel = page.getByRole("dialog", { name: "Tools" });
+  await panel.getByRole("button", { name: "Remove Group shots" }).click();
+
+  // Stored before the reload is relied on: the write is what is being tested.
+  await expect
+    .poll(async () => (await storedDocument(page)).tools?.shown)
+    .toEqual(["seating", "place-cards", "timeline", "delegation", "ceremony", "boxes", "bar", "money", "checklist", "binder"]);
+  await page.goto("/");
+
+  const tabs = page.getByRole("navigation", { name: "Tools" });
+  await expect(tabs.getByRole("link", { name: "Delegation" })).toBeVisible();
+  await expect(tabs.getByRole("link", { name: "Group shots" })).toHaveCount(0);
+  // Its area on the front page goes with it; the wedding's own pages stay.
+  const areas = page.getByRole("region", { name: "Where things stand" });
+  await expect(areas.getByRole("link", { name: /Guests/ })).toBeVisible();
+  await expect(areas.getByRole("link", { name: /Group shots/ })).toHaveCount(0);
+});
diff --git a/suite/fixtures/sample-day.cadence.json b/suite/fixtures/sample-day.cadence.json
index 085788a2..c7aeb493 100644
--- a/suite/fixtures/sample-day.cadence.json
+++ b/suite/fixtures/sample-day.cadence.json
@@ -547,7 +547,8 @@
       "notes": ""
     }
   ],
-  "outputs": [
+  "travel": [],
+      "outputs": [
     {
       "id": "run-sheet",
       "label": "Master run-sheet",
diff --git a/suite/lib/bar/actions.test.ts b/suite/lib/bar/actions.test.ts
new file mode 100644
index 00000000..a4211ee8
--- /dev/null
+++ b/suite/lib/bar/actions.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { emptyBar } from "@/lib/model/slices";
+import { chooseKind, choices, resetMix, setFigure, setHave, setPrice, setShare, setShop } from "./actions";
+import { figure, mixOf } from "./sum";
+
+describe("the bar's changes", () => {
+  it("keeps a changed figure, and forgets one put back or typed at its default", () => {
+    const changed = setFigure(emptyBar(), "eveningHours", 5);
+    expect(changed.figures).toEqual({ eveningHours: 5 });
+    expect(figure(changed, "eveningHours")).toBe(5);
+    expect(setFigure(changed, "eveningHours", null).figures).toEqual({});
+    expect(setFigure(changed, "eveningHours", 4).figures).toEqual({});
+  });
+
+  it("keeps a changed mix whole, and forgets it once it is the kind's again", () => {
+    const changed = setShare(emptyBar(), "evening", "spirit", 30);
+    expect(changed.mix.evening).toEqual({ fizz: 0, wine: 40, beer: 40, spirit: 30 });
+    expect(setShare(changed, "evening", "spirit", 20).mix).toEqual({});
+    expect(resetMix(changed, "evening").mix).toEqual({});
+  });
+
+  it("pours a new kind's mix, whatever was changed for the old one", () => {
+    const changed = setShare(emptyBar(), "evening", "spirit", 30);
+    const beerAndWine = chooseKind(changed, "beer-and-wine");
+    expect(beerAndWine.mix).toEqual({});
+    expect(mixOf(beerAndWine, "evening")).toEqual({ fizz: 0, wine: 50, beer: 50, spirit: 0 });
+  });
+
+  it("keeps only the line choices that differ from the line's usual", () => {
+    const priced = setPrice(setShop(emptyBar(), "beer", "supermarket"), "beer", 22.5);
+    expect(priced.lines).toEqual({ beer: { shop: "supermarket", price: 22.5 } });
+    expect(setShop(priced, "beer", "cash-and-carry").lines).toEqual({ beer: { price: 22.5 } });
+    expect(setPrice(setShop(priced, "beer", "cash-and-carry"), "beer", null).lines).toEqual({});
+    expect(setHave(emptyBar(), "ice", 0).lines).toEqual({});
+  });
+
+  it("counts what the couple chose", () => {
+    expect(choices(emptyBar())).toBe(0);
+    expect(choices(setPrice(setFigure(emptyBar(), "eveningGuests", 40), "fizz", 8))).toBe(2);
+  });
+});
diff --git a/suite/lib/bar/actions.ts b/suite/lib/bar/actions.ts
new file mode 100644
index 00000000..0eb5f576
--- /dev/null
+++ b/suite/lib/bar/actions.ts
@@ -0,0 +1,82 @@
+import type { Bar, BarKind, BarLine, Crowd, Figure, LineChoice, MixedPart, Pour, Shop } from "@/lib/model/types";
+import { POURS } from "@/lib/model/types";
+import { FIGURE_DEFAULTS, LINES, MIXES } from "./defaults";
+import { mixOf } from "./sum";
+
+/**
+ * The Bar's changes, each a new bar. A choice equal to its default is not
+ * kept, so putting a figure back and typing its default are the same thing.
+ */
+
+/** A figure changed, or put back with null. */
+export function setFigure(bar: Bar, id: Figure, value: number | null): Bar {
+  const { [id]: _, ...others } = bar.figures;
+  const kept = value === null || value === FIGURE_DEFAULTS[id].value ? others : { ...others, [id]: Math.max(0, value) };
+  return { ...bar, figures: kept };
+}
+
+/** A new kind of bar pours that kind's mix: any mix changed for the old kind goes. */
+export function chooseKind(bar: Bar, kind: BarKind): Bar {
+  return { ...bar, kind, mix: {} };
+}
+
+export function setCrowd(bar: Bar, crowd: Crowd): Bar {
+  return { ...bar, crowd };
+}
+
+/** How many are coming, typed; null goes back to the guest list's count. */
+export function setPeople(bar: Bar, people: number | null): Bar {
+  return { ...bar, people: people === null ? null : Math.max(0, Math.round(people)) };
+}
+
+/** One pour's share of a part's mix. A mix back at the kind's is the kind's again. */
+export function setShare(bar: Bar, part: MixedPart, pour: Pour, value: number): Bar {
+  const mix = { ...mixOf(bar, part), [pour]: Math.max(0, value) };
+  const kinds = MIXES[bar.kind][part];
+  const { [part]: _, ...others } = bar.mix;
+  return { ...bar, mix: POURS.every((p) => mix[p] === kinds[p]) ? others : { ...others, [part]: mix } };
+}
+
+/** A part's mix back to the kind's. */
+export function resetMix(bar: Bar, part: MixedPart): Bar {
+  const { [part]: _, ...others } = bar.mix;
+  return { ...bar, mix: others };
+}
+
+function withLine(bar: Bar, line: BarLine, change: (choice: LineChoice) => LineChoice): Bar {
+  const { [line]: current, ...others } = bar.lines;
+  const next = change({ ...current });
+  return { ...bar, lines: Object.keys(next).length > 0 ? { ...others, [line]: next } : others };
+}
+
+/** A line's price, or none. */
+export function setPrice(bar: Bar, line: BarLine, price: number | null): Bar {
+  return withLine(bar, line, ({ price: _, ...rest }) => (price === null ? rest : { ...rest, price: Math.max(0, price) }));
+}
+
+/** What they already have of a line; nothing is none. */
+export function setHave(bar: Bar, line: BarLine, have: number | null): Bar {
+  return withLine(bar, line, ({ have: _, ...rest }) => (have === null || have <= 0 ? rest : { ...rest, have }));
+}
+
+/** Where a line is bought; its usual shop is not kept. */
+export function setShop(bar: Bar, line: BarLine, shop: Shop): Bar {
+  return withLine(bar, line, ({ shop: _, ...rest }) => (shop === LINES[line].shop ? rest : { ...rest, shop }));
+}
+
+export function setWholeCases(bar: Bar, wholeCases: boolean): Bar {
+  return { ...bar, wholeCases };
+}
+
+/** How many things the couple chose, for knowing whether a wedding holds any of it. */
+export function choices(bar: Bar): number {
+  return (
+    Object.keys(bar.figures).length +
+    Object.keys(bar.mix).length +
+    Object.keys(bar.lines).length +
+    (bar.people !== null ? 1 : 0) +
+    (bar.kind !== "full" ? 1 : 0) +
+    (bar.crowd !== "usual" ? 1 : 0) +
+    (bar.wholeCases ? 0 : 1)
+  );
+}
diff --git a/suite/lib/bar/defaults.ts b/suite/lib/bar/defaults.ts
new file mode 100644
index 00000000..9935ada7
--- /dev/null
+++ b/suite/lib/bar/defaults.ts
@@ -0,0 +1,111 @@
+import type { BarKind, BarLine, Crowd, Figure, MixedPart, Mix, Shop } from "@/lib/model/types";
+
+/**
+ * Every default the Bar starts from, in one place, as agreed with the
+ * maintainer on 2026-09-29 (docs/superpowers/plans/2026-09-29-bar.md). UK
+ * first: 75cl bottles, 70cl spirits, 25ml measures, cases of 6 and 24.
+ *
+ * For 100 coming they give 42 bottles of fizz, 36 of white and 36 of red,
+ * 9 cases of beer, 3 bottles of spirits, 10 litres of mixers, 50 of soft
+ * drinks and 100kg of ice — pinned in `sum.test.ts`, so a change here is seen.
+ */
+
+export interface FigureInfo {
+  value: number;
+  label: string;
+  /** After the number: "%", "hours", "ml". */
+  unit: string;
+  step: number;
+}
+
+export const FIGURE_DEFAULTS: Record<Figure, FigureInfo> = {
+  notDrinkingPct: { value: 20, label: "Not drinking alcohol", unit: "%", step: 1 },
+  eveningGuests: { value: 0, label: "Coming for the evening only", unit: "people", step: 1 },
+  receptionHours: { value: 2, label: "Hours of the drinks reception", unit: "hours", step: 0.25 },
+  receptionPerHour: { value: 1.5, label: "Drinks an hour at the reception", unit: "each", step: 0.25 },
+  toastGlasses: { value: 1, label: "Glasses for the toast", unit: "each", step: 1 },
+  mealGlasses: { value: 2, label: "Glasses of wine with the meal", unit: "each", step: 0.5 },
+  eveningHours: { value: 4, label: "Hours of the evening bar", unit: "hours", step: 0.25 },
+  eveningPerHour: { value: 1, label: "Drinks an hour in the evening", unit: "each", step: 0.25 },
+  redPct: { value: 50, label: "Of the wine, red", unit: "%", step: 5 },
+  fizzGlassMl: { value: 125, label: "A glass of fizz", unit: "ml", step: 5 },
+  wineGlassMl: { value: 175, label: "A glass of wine", unit: "ml", step: 5 },
+  spiritMl: { value: 25, label: "A spirit measure", unit: "ml", step: 5 },
+  mixerMl: { value: 150, label: "Mixer with each spirit", unit: "ml", step: 10 },
+  softMl: { value: 250, label: "A soft drink", unit: "ml", step: 10 },
+  iceKg: { value: 1, label: "Ice for each person", unit: "kg", step: 0.25 },
+};
+
+export const KIND_NAMES: Record<BarKind, string> = {
+  full: "Full bar",
+  "beer-and-wine": "Beer and wine",
+  cocktails: "Signature cocktails, beer and wine",
+  "no-and-low": "No and low",
+};
+
+/** What each kind pours at the reception and in the evening, in percent. */
+export const MIXES: Record<BarKind, Record<MixedPart, Mix>> = {
+  full: {
+    reception: { fizz: 70, wine: 0, beer: 30, spirit: 0 },
+    evening: { fizz: 0, wine: 40, beer: 40, spirit: 20 },
+  },
+  "beer-and-wine": {
+    reception: { fizz: 70, wine: 0, beer: 30, spirit: 0 },
+    evening: { fizz: 0, wine: 50, beer: 50, spirit: 0 },
+  },
+  cocktails: {
+    reception: { fizz: 0, wine: 0, beer: 30, spirit: 70 },
+    evening: { fizz: 0, wine: 40, beer: 40, spirit: 20 },
+  },
+  "no-and-low": {
+    reception: { fizz: 70, wine: 0, beer: 30, spirit: 0 },
+    evening: { fizz: 0, wine: 50, beer: 50, spirit: 0 },
+  },
+};
+
+/** A lighter crowd drinks a fifth less, a heavier one a fifth more. The toast is one glass whoever raises it. */
+export const CROWD_FACTORS: Record<Crowd, number> = { lighter: 0.8, usual: 1, heavier: 1.2 };
+
+export const CROWD_NAMES: Record<Crowd, string> = {
+  lighter: "Lighter than most",
+  usual: "Most crowds",
+  heavier: "Heavier than most",
+};
+
+export interface LineInfo {
+  name: string;
+  /** What one of the line's units is: "bottle", "litre". */
+  unit: string;
+  units: string;
+  /** Rounded up to these on sale or return; 1 where a line is not sold by the case. */
+  caseOf: number;
+  /** How many units a price is for: a case of beer is priced whole. */
+  pricedPer: number;
+  /** "a bottle", "a case of 24". */
+  priceWords: string;
+  /** Beside a price: "/bottle", "/case". */
+  per: string;
+  shop: Shop;
+  /** Its alcohol-free name, for a no and low bar; null where it has none. */
+  alcoholFree: string | null;
+}
+
+export const LINES: Record<BarLine, LineInfo> = {
+  fizz: { name: "Fizz", unit: "bottle", units: "bottles", caseOf: 6, pricedPer: 1, priceWords: "a bottle", per: "/bottle", shop: "wine-merchant", alcoholFree: "Alcohol-free fizz" },
+  white: { name: "White wine", unit: "bottle", units: "bottles", caseOf: 6, pricedPer: 1, priceWords: "a bottle", per: "/bottle", shop: "wine-merchant", alcoholFree: "Alcohol-free white wine" },
+  red: { name: "Red wine", unit: "bottle", units: "bottles", caseOf: 6, pricedPer: 1, priceWords: "a bottle", per: "/bottle", shop: "wine-merchant", alcoholFree: "Alcohol-free red wine" },
+  beer: { name: "Beer and cider", unit: "bottle or can", units: "bottles or cans", caseOf: 24, pricedPer: 24, priceWords: "a case of 24", per: "/case", shop: "cash-and-carry", alcoholFree: "Alcohol-free beer" },
+  spirits: { name: "Spirits", unit: "70cl bottle", units: "70cl bottles", caseOf: 1, pricedPer: 1, priceWords: "a bottle", per: "/bottle", shop: "cash-and-carry", alcoholFree: "Alcohol-free spirits" },
+  mixers: { name: "Mixers", unit: "litre", units: "litres", caseOf: 1, pricedPer: 1, priceWords: "a litre", per: "/litre", shop: "supermarket", alcoholFree: null },
+  soft: { name: "Soft drinks", unit: "litre", units: "litres", caseOf: 1, pricedPer: 1, priceWords: "a litre", per: "/litre", shop: "supermarket", alcoholFree: null },
+  ice: { name: "Ice", unit: "kilo", units: "kilos", caseOf: 1, pricedPer: 1, priceWords: "a kilo", per: "/kilo", shop: "supermarket", alcoholFree: null },
+};
+
+export const SHOP_NAMES: Record<Shop, string> = {
+  "wine-merchant": "Wine merchant",
+  "cash-and-carry": "Cash and carry",
+  supermarket: "Supermarket",
+};
+
+export const BOTTLE_ML = 750;
+export const SPIRIT_BOTTLE_ML = 700;
diff --git a/suite/lib/bar/render/pdf/shoppingList.ts b/suite/lib/bar/render/pdf/shoppingList.ts
new file mode 100644
index 00000000..9e119c11
--- /dev/null
+++ b/suite/lib/bar/render/pdf/shoppingList.ts
@@ -0,0 +1,69 @@
+// Brigade's page, text and font kit, as the packing list uses it: see the
+// note at the top of lib/ensemble/render/pdf/shotSheet.ts.
+import { PDFDocument } from "pdf-lib";
+import { embedFamily } from "@/apps/brigade/render/pdf/embedFonts";
+import type { FontSource } from "@/apps/brigade/render/pdf/fontSource";
+import { addSheet, hexColour, type Colour } from "@/apps/brigade/render/pdf/page";
+import { contentBox, PAGE_SIZES, ptToMm } from "@/apps/brigade/render/pdf/units";
+import type { ShoppingGroup } from "../../rows";
+
+export interface ShoppingListOptions {
+  fontSource: FontSource;
+  coupleNames: string;
+  /** "For 100 coming, and 30 in the evening". */
+  forWhom: string;
+  /** "About 1,206 for what has a price." */
+  spend: string;
+  generatedOn?: string;
+}
+
+const MARGIN_MM = 15;
+const ACCENT = "#46617a";
+const BODY_PT = 10;
+const LEADING = 1.6;
+const TICK_MM = 3.2;
+const NAME_MM = 62;
+const MUTED: Colour = { r: 0.44, g: 0.43, b: 0.41 };
+
+/**
+ * The drinks to buy, by where they are bought, with a box to tick for each —
+ * one page, since there are never more than eight lines.
+ */
+export async function renderShoppingList(groups: ShoppingGroup[], options: ShoppingListOptions): Promise<Uint8Array> {
+  const pdf = await PDFDocument.create();
+  const { regular, bold } = await embedFamily(pdf, await options.fontSource("Lato"));
+  const size = PAGE_SIZES.A4;
+  const box = contentBox(size, MARGIN_MM);
+  const lineMm = ptToMm(BODY_PT * LEADING);
+  const sheet = addSheet(pdf, size);
+  const right = box.xMm + box.widthMm;
+  const textX = box.xMm + TICK_MM + 3;
+
+  const y0 = box.yMm;
+  sheet.text(options.coupleNames ? `Drinks to buy — ${options.coupleNames}` : "Drinks to buy", { xMm: box.xMm, yMm: y0 + 6, font: bold, sizePt: 14 });
+  sheet.line(box.xMm, y0 + 9, right, y0 + 9, { widthPt: 1, colour: hexColour(ACCENT) });
+  sheet.text(options.forWhom, { xMm: box.xMm, yMm: y0 + 15, font: regular, sizePt: BODY_PT, colour: MUTED });
+
+  let y = y0 + 24;
+  for (const group of groups) {
+    sheet.text(group.name, { xMm: box.xMm, yMm: y, font: bold, sizePt: 11 });
+    y += lineMm + 1;
+    for (const row of group.rows) {
+      const top = y - TICK_MM + 0.4;
+      const [x0, x1, y1] = [box.xMm, box.xMm + TICK_MM, top + TICK_MM];
+      sheet.line(x0, top, x1, top);
+      sheet.line(x1, top, x1, y1);
+      sheet.line(x1, y1, x0, y1);
+      sheet.line(x0, y1, x0, top);
+      sheet.text(row.name, { xMm: textX, yMm: y, font: regular, sizePt: BODY_PT });
+      sheet.text([row.amount, row.cases].filter(Boolean).join(" · "), { xMm: textX + NAME_MM, yMm: y, font: regular, sizePt: BODY_PT });
+      if (row.cost !== null) sheet.text(row.cost.toFixed(2), { xMm: right, yMm: y, font: regular, sizePt: BODY_PT, alignRight: true });
+      y += lineMm;
+    }
+    y += lineMm * 0.6;
+  }
+
+  sheet.text(options.spend, { xMm: box.xMm, yMm: y + 2, font: bold, sizePt: BODY_PT });
+  sheet.text(options.generatedOn ?? "", { xMm: box.xMm, yMm: size.heightMm - MARGIN_MM + 4, font: regular, sizePt: 8, colour: MUTED });
+  return pdf.save();
+}
diff --git a/suite/lib/bar/rows.test.ts b/suite/lib/bar/rows.test.ts
new file mode 100644
index 00000000..1ff080f5
--- /dev/null
+++ b/suite/lib/bar/rows.test.ts
@@ -0,0 +1,46 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { migrate } from "@jfrusher/trousseau";
+import { nodeFontSource } from "@/apps/brigade/render/pdf/nodeFontSource";
+import { textOf } from "@/apps/brigade/render/pdf/readPdf";
+import { parseCsv } from "@/lib/data/csv";
+import { readBar } from "@/lib/model/slices";
+import { renderShoppingList } from "./render/pdf/shoppingList";
+import { forWords, shoppingCsv, shoppingList, spendWords } from "./rows";
+import { barSum } from "./sum";
+
+const raw = JSON.parse(readFileSync(join(process.cwd(), "public", "fixtures", "example-wedding.trousseau.json"), "utf8"));
+const doc = migrate(raw);
+const sum = barSum(doc);
+const groups = shoppingList(readBar(doc), sum);
+
+describe("the shopping list", () => {
+  it("is grouped by where things are bought, and leaves out what there is none to buy", () => {
+    expect(groups.map((group) => group.name)).toEqual(["Wine merchant", "Cash and carry", "Supermarket"]);
+    expect(groups[0]!.rows[0]).toEqual({ name: "Fizz", amount: "42 bottles", cases: "7 cases of 6", price: 8.5, cost: 357 });
+    expect(groups[1]!.rows.map((row) => row.amount)).toEqual(["240 bottles or cans", "1 70cl bottle"]);
+    expect(forWords(sum)).toBe("For 100 coming, and 30 in the evening");
+    expect(spendWords(sum)).toBe("About 1,206 for what has a price; 4 to buy with no price yet.");
+  });
+
+  it("is a spreadsheet, one drink to a row", () => {
+    const table = parseCsv(shoppingCsv(groups));
+    expect(table.headers).toEqual(["Where", "Drink", "To buy", "Cases", "Price", "Cost"]);
+    expect(table.rows).toHaveLength(8);
+    expect(table.rows).toContainEqual({ Where: "Cash and carry", Drink: "Beer and cider", "To buy": "240 bottles or cans", Cases: "10 cases of 24", Price: "24.00", Cost: "240.00" });
+    expect(table.rows).toContainEqual({ Where: "Supermarket", Drink: "Ice", "To buy": "130 kilos", Cases: "", Price: "", Cost: "" });
+  });
+
+  it("is a page to tick off, with every drink and the estimate", async () => {
+    const { text, pages } = await textOf(
+      await renderShoppingList(groups, { fontSource: nodeFontSource, coupleNames: "Alex & Sam", forWhom: forWords(sum), spend: spendWords(sum) }),
+    );
+    expect(pages).toBe(1);
+    expect(text).toContain("Drinks to buy — Alex & Sam");
+    expect(text).toContain("For 100 coming, and 30 in the evening");
+    for (const row of groups.flatMap((group) => group.rows)) expect(text).toContain(row.name);
+    expect(text).toContain("42 bottles · 7 cases of 6");
+    expect(text).toContain("About 1,206 for what has a price");
+  });
+});
diff --git a/suite/lib/bar/rows.ts b/suite/lib/bar/rows.ts
new file mode 100644
index 00000000..9086fb46
--- /dev/null
+++ b/suite/lib/bar/rows.ts
@@ -0,0 +1,62 @@
+import { toCsv } from "@/lib/data/csv";
+import type { Bar, Shop } from "@/lib/model/types";
+import { SHOPS } from "@/lib/model/types";
+import { LINES, SHOP_NAMES } from "./defaults";
+import type { BarSum, LineSum } from "./sum";
+
+/** "42 bottles", and "7 cases of 6" when buying whole cases. The page, the list and the CSV all say it this way. */
+export function buyWords(bar: Bar, line: LineSum): { amount: string; cases: string } {
+  const info = LINES[line.line];
+  if (line.buy === 0) return { amount: "", cases: "" };
+  const cases = bar.wholeCases && info.caseOf > 1 ? line.buy / info.caseOf : null;
+  return {
+    amount: `${line.buy} ${line.buy === 1 ? info.unit : info.units}`,
+    cases: cases === null ? "" : `${cases} ${cases === 1 ? "case" : "cases"} of ${info.caseOf}`,
+  };
+}
+
+export interface ShoppingRow {
+  name: string;
+  amount: string;
+  cases: string;
+  price: number | null;
+  cost: number | null;
+}
+
+export interface ShoppingGroup {
+  shop: Shop;
+  name: string;
+  rows: ShoppingRow[];
+}
+
+/** What to buy, by where it is bought, leaving out what there is none to buy of. */
+export function shoppingList(bar: Bar, sum: BarSum): ShoppingGroup[] {
+  return SHOPS.map((shop) => ({
+    shop,
+    name: SHOP_NAMES[shop],
+    rows: sum.lines
+      .filter((line) => line.shop === shop && line.buy > 0)
+      .map((line) => ({ name: line.name, ...buyWords(bar, line), price: line.price, cost: line.cost })),
+  })).filter((group) => group.rows.length > 0);
+}
+
+/** "For 100 coming, and 30 in the evening". */
+export const forWords = (sum: BarSum): string =>
+  `For ${sum.heads.people} coming${sum.heads.evening > 0 ? `, and ${sum.heads.evening} in the evening` : ""}`;
+
+/** "About 1,206 for what has a price; 4 to buy with no price yet." */
+export function spendWords(sum: BarSum): string {
+  if (sum.spend === 0) return "Type prices for an estimate.";
+  const unpriced = sum.unpriced > 0 ? `; ${sum.unpriced} to buy with no price yet` : "";
+  return `About ${Math.round(sum.spend).toLocaleString("en-GB")} for what has a price${unpriced}.`;
+}
+
+const pounds = (n: number | null) => (n === null ? "" : n.toFixed(2));
+
+/** The shopping list, one line to a row, for a spreadsheet. */
+export function shoppingCsv(groups: ShoppingGroup[]): string {
+  return toCsv(
+    ["Where", "Drink", "To buy", "Cases", "Price", "Cost"],
+    groups.flatMap((group) => group.rows.map((row) => [group.name, row.name, row.amount, row.cases, pounds(row.price), pounds(row.cost)])),
+  );
+}
diff --git a/suite/lib/bar/sum.test.ts b/suite/lib/bar/sum.test.ts
new file mode 100644
index 00000000..74dbda5c
--- /dev/null
+++ b/suite/lib/bar/sum.test.ts
@@ -0,0 +1,105 @@
+import { describe, expect, it } from "vitest";
+import { emptyBar } from "@/lib/model/slices";
+import type { Bar, BarLine } from "@/lib/model/types";
+import { chooseKind, setCrowd, setFigure, setHave, setPeople, setPrice, setShare, setWholeCases } from "./actions";
+import { sumBar } from "./sum";
+
+const buy = (bar: Bar, listed: number): Record<BarLine, number> =>
+  Object.fromEntries(sumBar(bar, listed).lines.map((line) => [line.line, line.buy])) as Record<BarLine, number>;
+
+describe("the bar's sum", () => {
+  it("gives the agreed amounts for 100 coming, with every default", () => {
+    // The figures agreed with the maintainer, 2026-09-29: a change to a default is seen here.
+    expect(buy(emptyBar(), 100)).toEqual({ fizz: 42, white: 36, red: 36, beer: 216, spirits: 3, mixers: 10, soft: 50, ice: 100 });
+    const { heads, each } = sumBar(emptyBar(), 100);
+    expect(heads).toEqual({ listed: 100, people: 100, typed: false, evening: 0, drinking: 80, notDrinking: 20 });
+    expect(each).toEqual({ reception: 3, toast: 1, meal: 2, evening: 4 });
+  });
+
+  it("buys single bottles rather than whole cases when not on sale or return", () => {
+    const loose = buy(setWholeCases(emptyBar(), false), 100);
+    expect(loose).toMatchObject({ fizz: 42, white: 34, red: 34, beer: 200 });
+  });
+
+  it("takes off what they already have before rounding up to a case", () => {
+    // 41.3 bottles of fizz, 5 in the cupboard: 36.3 to buy, 37, a case of six makes 42.
+    expect(buy(setHave(emptyBar(), "fizz", 5), 100).fizz).toBe(42);
+    expect(buy(setHave(setWholeCases(emptyBar(), false), "fizz", 5), 100).fizz).toBe(37);
+    expect(buy(setHave(emptyBar(), "ice", 500), 100).ice).toBe(0);
+  });
+
+  it("reads a typed count over the guest list's, and says so", () => {
+    const sum = sumBar(setPeople(emptyBar(), 50), 100);
+    expect(sum.heads).toMatchObject({ listed: 100, people: 50, typed: true });
+    expect(sum.lines.find((line) => line.line === "ice")!.needed).toBe(50);
+  });
+
+  it("buys for evening-only guests in the evening, and nothing earlier", () => {
+    const withEvening = setFigure(setWholeCases(emptyBar(), false), "eveningGuests", 50);
+    const day = sumBar(setWholeCases(emptyBar(), false), 100).lines;
+    const both = sumBar(withEvening, 100).lines;
+    const beer = (lines: typeof day) => lines.find((line) => line.line === "beer")!.needed;
+    // 40 more drinking, four drinks each in the evening, 40% of them beer.
+    expect(beer(both) - beer(day)).toBeCloseTo(40 * 4 * 0.4);
+    const fizz = (lines: typeof day) => lines.find((line) => line.line === "fizz")!.needed;
+    expect(fizz(both)).toBeCloseTo(fizz(day));
+  });
+
+  it("puts a fifth on for a heavier crowd, but never on the toast", () => {
+    const { each } = sumBar(setCrowd(emptyBar(), "heavier"), 100);
+    expect(each.reception).toBeCloseTo(3.6);
+    expect(each.toast).toBe(1);
+    expect(each.meal).toBeCloseTo(2.4);
+  });
+
+  it("pours what the kind of bar pours", () => {
+    const beerAndWine = buy(chooseKind(emptyBar(), "beer-and-wine"), 100);
+    expect(beerAndWine.spirits).toBe(0);
+    expect(beerAndWine.mixers).toBe(0);
+    const cocktails = sumBar(chooseKind(emptyBar(), "cocktails"), 100).lines;
+    // Only the toast is fizz: 80 glasses, 13.3 bottles.
+    expect(cocktails.find((line) => line.line === "fizz")!.needed).toBeCloseTo(80 / 6);
+  });
+
+  it("names every drink alcohol-free at a no and low bar", () => {
+    const names = sumBar(chooseKind(emptyBar(), "no-and-low"), 100).lines.map((line) => line.name);
+    expect(names).toEqual([
+      "Alcohol-free fizz",
+      "Alcohol-free white wine",
+      "Alcohol-free red wine",
+      "Alcohol-free beer",
+      "Alcohol-free spirits",
+      "Mixers",
+      "Soft drinks",
+      "Ice",
+    ]);
+  });
+
+  it("reads a mix as shares of what it adds up to", () => {
+    // Reception at 70 fizz and 70 beer is half and half, not 140%.
+    const even = setShare(emptyBar(), "reception", "beer", 70);
+    const lines = sumBar(setWholeCases(even, false), 100).lines;
+    // Reception: 240 drinks, 120 of them beer; evening: 128 beer.
+    expect(lines.find((line) => line.line === "beer")!.needed).toBeCloseTo(248);
+  });
+
+  it("pours nothing in a part whose mix is all nothing", () => {
+    const none = (["fizz", "beer"] as const).reduce((bar, pour) => setShare(bar, "reception", pour, 0), emptyBar());
+    const lines = sumBar(none, 100).lines;
+    // The toast is all the fizz left.
+    expect(lines.find((line) => line.line === "fizz")!.needed).toBeCloseTo(80 / 6);
+  });
+
+  it("prices a case of beer whole, and leaves unpriced lines out of the spend", () => {
+    const priced = setPrice(setPrice(emptyBar(), "beer", 24), "fizz", 8);
+    const sum = sumBar(priced, 100);
+    expect(sum.lines.find((line) => line.line === "beer")!.cost).toBe(216);
+    expect(sum.spend).toBe(216 + 42 * 8);
+    expect(sum.unpriced).toBe(6);
+  });
+
+  it("buys nothing for nobody", () => {
+    expect(Object.values(buy(emptyBar(), 0)).every((n) => n === 0)).toBe(true);
+    expect(sumBar(emptyBar(), 0).unpriced).toBe(0);
+  });
+});
diff --git a/suite/lib/bar/sum.ts b/suite/lib/bar/sum.ts
new file mode 100644
index 00000000..f0bdc273
--- /dev/null
+++ b/suite/lib/bar/sum.ts
@@ -0,0 +1,164 @@
+import type { Trousseau } from "@jfrusher/trousseau";
+import { cached, isComing, readBar, readGuests } from "@/lib/model/slices";
+import type { Bar, BarLine, Figure, Mix, MixedPart, Pour, Shop } from "@/lib/model/types";
+import { BAR_LINES, POURS } from "@/lib/model/types";
+import { BOTTLE_ML, CROWD_FACTORS, FIGURE_DEFAULTS, LINES, MIXES, SPIRIT_BOTTLE_ML } from "./defaults";
+
+/**
+ * How much to buy, worked out every time from who is coming and the figures —
+ * never stored, so a guest saying no changes the wine.
+ *
+ * Kept fractional to the end: each line is rounded up once, to what a shop
+ * sells, so rounding never compounds.
+ */
+
+/** A figure as the couple left it: their own, or the default. */
+export const figure = (bar: Bar, id: Figure): number => bar.figures[id] ?? FIGURE_DEFAULTS[id].value;
+
+/** A part's mix: the couple's own, or their kind of bar's. */
+export const mixOf = (bar: Bar, part: MixedPart): Mix => bar.mix[part] ?? MIXES[bar.kind][part];
+
+/** A line's name, alcohol-free at a no and low bar. */
+export const lineName = (bar: Bar, line: BarLine): string =>
+  bar.kind === "no-and-low" ? (LINES[line].alcoholFree ?? LINES[line].name) : LINES[line].name;
+
+export type Part = "reception" | "toast" | "meal" | "evening";
+
+export interface Heads {
+  /** Everyone on the guest list who has not said no. */
+  listed: number;
+  /** Who the day is bought for: the list's count, or the couple's own. */
+  people: number;
+  typed: boolean;
+  /** Coming for the evening only. */
+  evening: number;
+  /** Of everyone there in the evening, drinking alcohol. Rounded, for reading. */
+  drinking: number;
+  notDrinking: number;
+}
+
+export interface LineSum {
+  line: BarLine;
+  name: string;
+  /** Exactly what the figures come to, in the line's units. */
+  needed: number;
+  have: number;
+  /** Whole units still to buy: after what they have, and whole cases if they chose. */
+  buy: number;
+  price: number | null;
+  /** What `buy` costs, or null with no price. */
+  cost: number | null;
+  shop: Shop;
+}
+
+export interface BarSum {
+  heads: Heads;
+  /** Drinks each, for those drinking alcohol, the crowd allowed for. */
+  each: Record<Part, number>;
+  lines: LineSum[];
+  /** What the priced lines cost. */
+  spend: number;
+  /** Lines to buy with no price, left out of `spend`. */
+  unpriced: number;
+}
+
+/** Each pour's share of a mix, as a fraction of the whole, so shares need not add to 100. */
+function shares(mix: Mix): Mix {
+  const total = POURS.reduce((sum, pour) => sum + mix[pour], 0);
+  const out = {} as Mix;
+  for (const pour of POURS) out[pour] = total > 0 ? mix[pour] / total : 0;
+  return out;
+}
+
+export function sumBar(bar: Bar, listed: number): BarSum {
+  const f = (id: Figure) => figure(bar, id);
+  const people = bar.people ?? listed;
+  const evening = f("eveningGuests");
+  const everyone = people + evening;
+  const notShare = Math.min(100, f("notDrinkingPct")) / 100;
+  const crowd = CROWD_FACTORS[bar.crowd];
+
+  const base: Record<Part, number> = {
+    reception: f("receptionHours") * f("receptionPerHour"),
+    toast: f("toastGlasses"),
+    meal: f("mealGlasses"),
+    evening: f("eveningHours") * f("eveningPerHour"),
+  };
+  const each: Record<Part, number> = {
+    reception: base.reception * crowd,
+    toast: base.toast,
+    meal: base.meal * crowd,
+    evening: base.evening * crowd,
+  };
+
+  const dayDrinking = people * (1 - notShare);
+  const allDrinking = everyone * (1 - notShare);
+  const reception = dayDrinking * each.reception;
+  const eveningDrinks = allDrinking * each.evening;
+  const atReception = shares(mixOf(bar, "reception"));
+  const inEvening = shares(mixOf(bar, "evening"));
+  const poured: Record<Pour, number> = {
+    fizz: reception * atReception.fizz + dayDrinking * each.toast + eveningDrinks * inEvening.fizz,
+    wine: reception * atReception.wine + dayDrinking * each.meal + eveningDrinks * inEvening.wine,
+    beer: reception * atReception.beer + eveningDrinks * inEvening.beer,
+    spirit: reception * atReception.spirit + eveningDrinks * inEvening.spirit,
+  };
+  // Those not drinking alcohol have a soft drink for each drink, at the usual rate.
+  const soft = people * notShare * (base.reception + base.toast + base.meal) + everyone * notShare * base.evening;
+
+  const wineBottles = (poured.wine * f("wineGlassMl")) / BOTTLE_ML;
+  const red = Math.min(100, f("redPct")) / 100;
+  const needed: Record<BarLine, number> = {
+    fizz: (poured.fizz * f("fizzGlassMl")) / BOTTLE_ML,
+    white: wineBottles * (1 - red),
+    red: wineBottles * red,
+    beer: poured.beer,
+    spirits: (poured.spirit * f("spiritMl")) / SPIRIT_BOTTLE_ML,
+    mixers: (poured.spirit * f("mixerMl")) / 1000,
+    soft: (soft * f("softMl")) / 1000,
+    ice: everyone * f("iceKg"),
+  };
+
+  const lines = BAR_LINES.map((line): LineSum => {
+    const info = LINES[line];
+    const choice = bar.lines[line] ?? {};
+    const have = choice.have ?? 0;
+    // A hair under a whole unit is that unit: 42.0000001 bottles is 42.
+    let buy = Math.max(0, Math.ceil(needed[line] - have - 1e-9));
+    if (bar.wholeCases && info.caseOf > 1) buy = Math.ceil(buy / info.caseOf) * info.caseOf;
+    const price = choice.price ?? null;
+    return {
+      line,
+      name: lineName(bar, line),
+      needed: needed[line],
+      have,
+      buy,
+      price,
+      cost: price === null ? null : (buy / info.pricedPer) * price,
+      shop: choice.shop ?? info.shop,
+    };
+  });
+
+  return {
+    heads: {
+      listed,
+      people,
+      typed: bar.people !== null,
+      evening,
+      drinking: Math.round(allDrinking),
+      notDrinking: Math.round(everyone * notShare),
+    },
+    each,
+    lines,
+    spend: lines.reduce((sum, line) => sum + (line.cost ?? 0), 0),
+    unpriced: lines.filter((line) => line.buy > 0 && line.price === null).length,
+  };
+}
+
+/** The wedding's bar, worked out from its guest list. Cached per document, for selectors. */
+export function barSum(doc: Trousseau): BarSum {
+  return cached(doc, "barSum", () => {
+    const listed = Object.values(readGuests(doc)).filter(isComing).length;
+    return sumBar(readBar(doc), listed);
+  });
+}
diff --git a/suite/lib/boxes/actions.test.ts b/suite/lib/boxes/actions.test.ts
new file mode 100644
index 00000000..41711b43
--- /dev/null
+++ b/suite/lib/boxes/actions.test.ts
@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { emptyBoxes } from "@/lib/model/slices";
+import type { Boxes } from "@/lib/model/types";
+import { addBox, addItem, moveItem, patchItem, removeBox, USUAL_BOXES, withUsualBoxes } from "./actions";
+
+const two = (): Boxes => {
+  const first = addBox(emptyBoxes(), { name: "Getting ready" });
+  const withShoes = addItem(first, first.boxes[0]!.id, "Shoes", 2);
+  return addBox(withShoes, { name: "Overnight" });
+};
+
+describe("boxes", () => {
+  it("numbers a new box on from the highest, not from how many there are", () => {
+    const boxes = two();
+    expect(boxes.boxes.map((box) => box.number)).toEqual([1, 2]);
+    const gap = addBox(removeBox(boxes, boxes.boxes[0]!.id));
+    expect(gap.boxes.map((box) => box.number)).toEqual([2, 3]);
+  });
+
+  it("adds what is packed, and adds nothing for an empty line", () => {
+    const boxes = two();
+    expect(boxes.boxes[0]!.items).toEqual([{ id: expect.any(String), label: "Shoes", quantity: 2, packed: false }]);
+    expect(addItem(boxes, boxes.boxes[0]!.id, "   ")).toBe(boxes);
+  });
+
+  it("moves an item to another box, packed as it was, and leaves it where it is otherwise", () => {
+    const boxes = two();
+    const [ready, overnight] = boxes.boxes;
+    const shoes = ready!.items[0]!;
+    const packed = patchItem(boxes, ready!.id, shoes.id, { packed: true });
+    const moved = moveItem(packed, shoes.id, overnight!.id);
+    expect(moved.boxes[0]!.items).toEqual([]);
+    expect(moved.boxes[1]!.items).toEqual([{ ...shoes, packed: true }]);
+    expect(moveItem(packed, shoes.id, ready!.id)).toBe(packed);
+    expect(moveItem(packed, "no-such-item", overnight!.id)).toBe(packed);
+  });
+});
+
+describe("the usual boxes", () => {
+  it("adds the usual boxes with what goes in them, numbered on from any already there", () => {
+    const boxes = withUsualBoxes(addBox(emptyBoxes(), { name: "Flowers" }));
+    expect(boxes.boxes.map((box) => `${box.number} ${box.name}`)).toEqual([
+      "1 Flowers",
+      ...USUAL_BOXES.map((usual, index) => `${index + 2} ${usual.name}`),
+    ]);
+    expect(boxes.boxes[1]!.items.map((item) => item.label)).toContain("The rings");
+    expect(boxes.boxes.flatMap((box) => box.items).every((item) => !item.packed)).toBe(true);
+  });
+
+  it("never doubles up, matching by name", () => {
+    const once = withUsualBoxes(emptyBoxes());
+    expect(withUsualBoxes(once)).toBe(once);
+  });
+});
diff --git a/suite/lib/boxes/actions.ts b/suite/lib/boxes/actions.ts
new file mode 100644
index 00000000..3f504b6d
--- /dev/null
+++ b/suite/lib/boxes/actions.ts
@@ -0,0 +1,83 @@
+import { newId } from "@/lib/model/ids";
+import type { Box, BoxItem, Boxes } from "@/lib/model/types";
+
+/**
+ * The boxes, edited: boxes in the order they were made, each numbered for its
+ * label, and what is in each. Every edit hands back the same boxes when it
+ * changes nothing, so no empty step lands on the history.
+ */
+
+const nextNumber = (boxes: Boxes) => boxes.boxes.reduce((highest, box) => Math.max(highest, box.number), 0) + 1;
+
+export function addBox(boxes: Boxes, patch: Partial<Omit<Box, "id" | "number">> = {}): Boxes {
+  const box: Box = { id: newId("box"), number: nextNumber(boxes), name: "", items: [], blockId: null, personIds: [], notes: "", ...patch };
+  return { ...boxes, boxes: [...boxes.boxes, box] };
+}
+
+export function patchBox(boxes: Boxes, boxId: string, patch: Partial<Omit<Box, "id" | "items">>): Boxes {
+  return { ...boxes, boxes: boxes.boxes.map((box) => (box.id === boxId ? { ...box, ...patch } : box)) };
+}
+
+export function removeBox(boxes: Boxes, boxId: string): Boxes {
+  return { ...boxes, boxes: boxes.boxes.filter((box) => box.id !== boxId) };
+}
+
+function withItems(boxes: Boxes, boxId: string, change: (items: BoxItem[]) => BoxItem[]): Boxes {
+  return { ...boxes, boxes: boxes.boxes.map((box) => (box.id === boxId ? { ...box, items: change(box.items) } : box)) };
+}
+
+export function addItem(boxes: Boxes, boxId: string, label: string, quantity = 1): Boxes {
+  const clean = label.trim();
+  if (!clean) return boxes;
+  return withItems(boxes, boxId, (items) => [...items, { id: newId("item"), label: clean, quantity, packed: false }]);
+}
+
+export function patchItem(boxes: Boxes, boxId: string, itemId: string, patch: Partial<Omit<BoxItem, "id">>): Boxes {
+  return withItems(boxes, boxId, (items) => items.map((item) => (item.id === itemId ? { ...item, ...patch } : item)));
+}
+
+export function removeItem(boxes: Boxes, boxId: string, itemId: string): Boxes {
+  return withItems(boxes, boxId, (items) => items.filter((item) => item.id !== itemId));
+}
+
+/** An item into another box, at the end of what is in it, packed or not as it was. */
+export function moveItem(boxes: Boxes, itemId: string, toBoxId: string): Boxes {
+  const from = boxes.boxes.find((box) => box.items.some((item) => item.id === itemId));
+  const item = from?.items.find((candidate) => candidate.id === itemId);
+  if (!from || !item || from.id === toBoxId || !boxes.boxes.some((box) => box.id === toBoxId)) return boxes;
+  return withItems(removeItem(boxes, from.id, itemId), toBoxId, (items) => [...items, item]);
+}
+
+/**
+ * The boxes most weddings pack, UK first: a list to change, not a rule. What
+ * the ceremony needs on paper depends on the ceremony, so it is asked about
+ * rather than named.
+ */
+export const USUAL_BOXES: ReadonlyArray<{ name: string; items: string[] }> = [
+  {
+    name: "The rings and the paperwork",
+    items: ["The rings", "Any paperwork the ceremony needs", "Vows and readings", "Envelopes for suppliers' final payments", "Thank-you cards for suppliers"],
+  },
+  {
+    name: "Getting ready",
+    items: ["Outfits, on hangers", "Shoes", "Steamer", "Emergency kit: plasters, safety pins, needle and thread, painkillers", "Phone chargers", "Snacks and water"],
+  },
+  {
+    name: "The day's odds and ends",
+    items: ["Guest book and pens", "Table plan", "Place cards", "Signs", "Card box", "Cake knife", "Favours"],
+  },
+  {
+    name: "Overnight and the day after",
+    items: ["Clothes for the day after", "Toiletries", "Medication", "Passports and travel documents"],
+  },
+];
+
+/** The usual boxes this wedding does not have yet, matched by name, so it can be asked for twice. */
+export function withUsualBoxes(boxes: Boxes): Boxes {
+  const have = new Set(boxes.boxes.map((box) => box.name.trim().toLowerCase()));
+  return USUAL_BOXES.filter((usual) => !have.has(usual.name.toLowerCase())).reduce((next, usual) => {
+    const added = addBox(next, { name: usual.name });
+    const box = added.boxes[added.boxes.length - 1]!;
+    return usual.items.reduce((withItem, label) => addItem(withItem, box.id, label), added);
+  }, boxes);
+}
diff --git a/suite/lib/boxes/render/pdf/labels.ts b/suite/lib/boxes/render/pdf/labels.ts
new file mode 100644
index 00000000..0322123e
--- /dev/null
+++ b/suite/lib/boxes/render/pdf/labels.ts
@@ -0,0 +1,81 @@
+// Brigade's page, text and font kit, as the shot sheet uses it: see the note
+// at the top of lib/ensemble/render/pdf/shotSheet.ts.
+import { PDFDocument } from "pdf-lib";
+import { embedFamily } from "@/apps/brigade/render/pdf/embedFonts";
+import type { FontSource } from "@/apps/brigade/render/pdf/fontSource";
+import { addSheet, type Colour } from "@/apps/brigade/render/pdf/page";
+import { wrap } from "@/apps/brigade/render/pdf/text";
+import { PAGE_SIZES, ptToMm } from "@/apps/brigade/render/pdf/units";
+import { itemText, type BoxRow } from "../../rows";
+
+export interface LabelOptions {
+  fontSource: FontSource;
+}
+
+const LABEL = { widthMm: 105, heightMm: 148.5 };
+const PAD_MM = 8;
+const BODY_PT = 9.5;
+const LEADING = 1.35;
+const MUTED: Colour = { r: 0.44, g: 0.43, b: 0.41 };
+const DANGER: Colour = { r: 0.64, g: 0.23, b: 0.17 };
+const CUT: Colour = { r: 0.75, g: 0.74, b: 0.73 };
+
+/**
+ * A label for each box, four to an A4 sheet, cut along the dashed lines: the
+ * number large enough to read across a room, the name, where it has to be and
+ * by when, who is taking it, and what is in it — as much as fits, then how
+ * many more.
+ */
+export async function renderBoxLabels(rows: BoxRow[], options: LabelOptions): Promise<Uint8Array> {
+  const pdf = await PDFDocument.create();
+  const { regular, bold } = await embedFamily(pdf, await options.fontSource("Lato"));
+  const lineMm = ptToMm(BODY_PT * LEADING);
+  const widthMm = LABEL.widthMm - PAD_MM * 2;
+
+  for (let start = 0; start < Math.max(rows.length, 1); start += 4) {
+    const sheet = addSheet(pdf, PAGE_SIZES.A4);
+    sheet.line(LABEL.widthMm, 0, LABEL.widthMm, PAGE_SIZES.A4.heightMm, { dashed: true, colour: CUT });
+    sheet.line(0, LABEL.heightMm, PAGE_SIZES.A4.widthMm, LABEL.heightMm, { dashed: true, colour: CUT });
+
+    rows.slice(start, start + 4).forEach((row, index) => {
+      const x = (index % 2) * LABEL.widthMm + PAD_MM;
+      const top = Math.floor(index / 2) * LABEL.heightMm + PAD_MM;
+      const bottom = top + LABEL.heightMm - PAD_MM * 2;
+
+      sheet.text(String(row.number), { xMm: x, yMm: top + ptToMm(48), font: bold, sizePt: 48 });
+      let y = top + ptToMm(48) + 4;
+      for (const line of wrap(row.name, bold, 14, widthMm)) {
+        y += ptToMm(14 * LEADING);
+        sheet.text(line, { xMm: x, yMm: y, font: bold, sizePt: 14 });
+      }
+      for (const line of wrap(row.where, regular, 11, widthMm)) {
+        y += ptToMm(11 * LEADING);
+        sheet.text(line, { xMm: x, yMm: y, font: regular, sizePt: 11, colour: row.lost ? DANGER : undefined });
+      }
+      if (row.takenBy.length > 0) {
+        for (const line of wrap(`Taken by ${row.takenBy.join(", ")}`, regular, BODY_PT, widthMm)) {
+          y += lineMm;
+          sheet.text(line, { xMm: x, yMm: y, font: regular, sizePt: BODY_PT, colour: MUTED });
+        }
+      }
+      y += 3;
+      sheet.line(x, y, x + widthMm, y, { widthPt: 0.5, colour: CUT });
+
+      // As much of what is in it as fits, then how many more.
+      const lines = row.items.flatMap((item) => wrap(itemText(item), regular, BODY_PT, widthMm).map((text, i) => ({ text, first: i === 0 })));
+      const room = Math.floor((bottom - y) / lineMm);
+      const shown = lines.length > room ? lines.slice(0, Math.max(room - 1, 0)) : lines;
+      for (const line of shown) {
+        y += lineMm;
+        sheet.text(line.text, { xMm: x, yMm: y, font: regular, sizePt: BODY_PT });
+      }
+      if (shown.length < lines.length) {
+        const more = row.items.length - shown.filter((line) => line.first).length;
+        y += lineMm;
+        sheet.text(`and ${more} more`, { xMm: x, yMm: y, font: bold, sizePt: BODY_PT, colour: MUTED });
+      }
+    });
+  }
+
+  return pdf.save();
+}
diff --git a/suite/lib/boxes/render/pdf/packingList.ts b/suite/lib/boxes/render/pdf/packingList.ts
new file mode 100644
index 00000000..37a36447
--- /dev/null
+++ b/suite/lib/boxes/render/pdf/packingList.ts
@@ -0,0 +1,101 @@
+// Brigade's page, table, text and font kit, as the shot sheet uses it: see the
+// note at the top of lib/ensemble/render/pdf/shotSheet.ts.
+import { PDFDocument } from "pdf-lib";
+import { embedFamily } from "@/apps/brigade/render/pdf/embedFonts";
+import type { FontSource } from "@/apps/brigade/render/pdf/fontSource";
+import { addSheet, hexColour, type Colour } from "@/apps/brigade/render/pdf/page";
+import { paginate } from "@/apps/brigade/render/pdf/table";
+import { wrap } from "@/apps/brigade/render/pdf/text";
+import { contentBox, PAGE_SIZES, ptToMm } from "@/apps/brigade/render/pdf/units";
+import { itemText, type BoxRow } from "../../rows";
+
+export interface PackingListOptions {
+  fontSource: FontSource;
+  coupleNames: string;
+  generatedOn?: string;
+}
+
+const MARGIN_MM = 15;
+const HEADER_MM = 16;
+const FOOTER_MM = 10;
+const ACCENT = "#46617a";
+const BODY_PT = 9.5;
+const LEADING = 1.35;
+const TICK_MM = 3.2;
+const MUTED: Colour = { r: 0.44, g: 0.43, b: 0.41 };
+const DANGER: Colour = { r: 0.64, g: 0.23, b: 0.17 };
+
+type Line =
+  | { kind: "box"; title: string; detail: string; lost: boolean; heightMm: number }
+  | { kind: "item"; lines: string[]; packed: boolean; heightMm: number };
+
+/**
+ * Every box and every thing in it, with a box to tick — the ones already
+ * packed ticked — for packing with a pen in hand rather than a phone.
+ */
+export async function renderPackingList(rows: BoxRow[], options: PackingListOptions): Promise<Uint8Array> {
+  const pdf = await PDFDocument.create();
+  const { regular, bold } = await embedFamily(pdf, await options.fontSource("Lato"));
+  const accent = hexColour(ACCENT);
+  const size = PAGE_SIZES.A4;
+  const box = contentBox(size, MARGIN_MM);
+  const lineMm = ptToMm(BODY_PT * LEADING);
+  const textX = box.xMm + TICK_MM + 3;
+
+  const lines: Line[] = rows.flatMap((row): Line[] => [
+    {
+      kind: "box",
+      title: `Box ${row.number} · ${row.name}`,
+      detail: [row.where, row.takenBy.length > 0 ? `Taken by ${row.takenBy.join(", ")}` : ""].filter(Boolean).join(" · "),
+      lost: row.lost,
+      heightMm: ptToMm(11 * LEADING) + lineMm + 4,
+    },
+    ...row.items.map((item): Line => {
+      const wrapped = wrap(itemText(item), regular, BODY_PT, box.widthMm - (textX - box.xMm));
+      return { kind: "item", lines: wrapped, packed: item.packed, heightMm: wrapped.length * lineMm + 1.2 };
+    }),
+  ]);
+
+  const pages = paginate(lines, box.heightMm - HEADER_MM - FOOTER_MM);
+  pages.forEach((indices, pageIndex) => {
+    const sheet = addSheet(pdf, size);
+    const y0 = box.yMm;
+    sheet.text(options.coupleNames ? `Packing list — ${options.coupleNames}` : "Packing list", { xMm: box.xMm, yMm: y0 + 6, font: bold, sizePt: 14 });
+    sheet.text(`Page ${pageIndex + 1} of ${pages.length}`, {
+      xMm: box.xMm + box.widthMm,
+      yMm: y0 + 6,
+      font: regular,
+      sizePt: 8,
+      colour: MUTED,
+      alignRight: true,
+    });
+    sheet.line(box.xMm, y0 + 9, box.xMm + box.widthMm, y0 + 9, { widthPt: 1, colour: accent });
+
+    let y = y0 + HEADER_MM;
+    for (const index of indices) {
+      const line = lines[index];
+      if (!line) continue;
+      if (line.kind === "box") {
+        sheet.text(line.title, { xMm: box.xMm, yMm: y + ptToMm(11) + 2, font: bold, sizePt: 11 });
+        sheet.text(line.detail, { xMm: box.xMm, yMm: y + ptToMm(11) + 2 + lineMm, font: regular, sizePt: BODY_PT, colour: line.lost ? DANGER : MUTED });
+      } else {
+        const top = y + lineMm - TICK_MM + 0.4;
+        const [x0, x1, y1] = [box.xMm, box.xMm + TICK_MM, top + TICK_MM];
+        sheet.line(x0, top, x1, top);
+        sheet.line(x1, top, x1, y1);
+        sheet.line(x1, y1, x0, y1);
+        sheet.line(x0, y1, x0, top);
+        if (line.packed) {
+          sheet.line(x0 + 0.6, top + TICK_MM * 0.55, x0 + TICK_MM * 0.4, y1 - 0.6, { widthPt: 1 });
+          sheet.line(x0 + TICK_MM * 0.4, y1 - 0.6, x1 - 0.5, top + 0.5, { widthPt: 1 });
+        }
+        line.lines.forEach((text, i) => sheet.text(text, { xMm: textX, yMm: y + lineMm * (i + 1), font: regular, sizePt: BODY_PT }));
+      }
+      y += line.heightMm;
+    }
+
+    sheet.text(options.generatedOn ?? "", { xMm: box.xMm, yMm: size.heightMm - MARGIN_MM + 4, font: regular, sizePt: 8, colour: MUTED });
+  });
+
+  return pdf.save();
+}
diff --git a/suite/lib/boxes/rows.test.ts b/suite/lib/boxes/rows.test.ts
new file mode 100644
index 00000000..4ad0b1ff
--- /dev/null
+++ b/suite/lib/boxes/rows.test.ts
@@ -0,0 +1,67 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { migrate } from "@jfrusher/trousseau";
+import { nodeFontSource } from "@/apps/brigade/render/pdf/nodeFontSource";
+import { textOf } from "@/apps/brigade/render/pdf/readPdf";
+import { parseCsv } from "@/lib/data/csv";
+import { readBoxes, readCrew, readGuests } from "@/lib/model/slices";
+import { renderBoxLabels } from "./render/pdf/labels";
+import { renderPackingList } from "./render/pdf/packingList";
+import { boxesCsv, boxRows, itemText } from "./rows";
+import { dayPlaces } from "./view";
+
+const raw = JSON.parse(readFileSync(join(process.cwd(), "public", "fixtures", "example-wedding.trousseau.json"), "utf8"));
+const doc = migrate(raw);
+const rows = boxRows(readBoxes(doc), dayPlaces(doc), readCrew(doc), readGuests(doc));
+
+describe("boxes, printed", () => {
+  it("are in number order, each with where it goes, by when, and who takes it by name", () => {
+    expect(rows.map((row) => row.number)).toEqual([1, 2, 3, 4]);
+    expect(rows[1]).toMatchObject({ name: "Getting ready", where: "The suite, by 08:00", takenBy: ["Ines Ashdown"] });
+    expect(rows[3]).toMatchObject({ where: "Not for the day", takenBy: [] });
+    expect(itemText({ label: "Shoes", quantity: 2 })).toBe("2 × Shoes");
+    expect(itemText({ label: "Steamer", quantity: 1 })).toBe("Steamer");
+  });
+
+  it("are a spreadsheet, one thing to a row", () => {
+    const table = parseCsv(boxesCsv(rows));
+    expect(table.headers).toEqual(["Box", "Name", "Needed", "Taken by", "Item", "How many", "Packed"]);
+    expect(table.rows).toHaveLength(rows.reduce((sum, row) => sum + row.items.length, 0));
+    expect(table.rows).toContainEqual({
+      Box: "2",
+      Name: "Getting ready",
+      Needed: "The suite, by 08:00",
+      "Taken by": "Ines Ashdown",
+      Item: "Shoes",
+      "How many": "2",
+      Packed: "Yes",
+    });
+  });
+
+  it("are labels, four to a sheet, each with its number, name, where and contents", async () => {
+    const { text, pages } = await textOf(await renderBoxLabels(rows, { fontSource: nodeFontSource }));
+    expect(pages).toBe(1);
+    for (const row of rows) {
+      expect(text).toContain(row.name);
+      expect(text).toContain(row.where);
+    }
+    expect(text).toContain("2 × Shoes");
+    expect(text).toContain("Taken by Ines Ashdown");
+  });
+
+  it("say how many more there are when a box holds more than its label", async () => {
+    const full = { ...rows[0]!, items: Array.from({ length: 60 }, (_, i) => ({ id: `i${i}`, label: `Thing ${i + 1}`, quantity: 1, packed: false })) };
+    const { text } = await textOf(await renderBoxLabels([full], { fontSource: nodeFontSource }));
+    expect(text).toContain("Thing 1");
+    expect(text).not.toContain("Thing 60");
+    expect(text).toMatch(/and \d+ more/);
+  });
+
+  it("are a packing list, every box and every thing in it", async () => {
+    const { text } = await textOf(await renderPackingList(rows, { fontSource: nodeFontSource, coupleNames: "Alex & Sam" }));
+    expect(text).toContain("Packing list — Alex & Sam");
+    expect(text).toContain("Box 2 · Getting ready");
+    for (const item of rows.flatMap((row) => row.items)) expect(text).toContain(item.label);
+  });
+});
diff --git a/suite/lib/boxes/rows.ts b/suite/lib/boxes/rows.ts
new file mode 100644
index 00000000..18ae4d07
--- /dev/null
+++ b/suite/lib/boxes/rows.ts
@@ -0,0 +1,57 @@
+import { toCsv } from "@/lib/data/csv";
+import { personName } from "@/lib/model/slices";
+import type { BoxItem, Boxes, Crew, Guest } from "@/lib/model/types";
+import { neededAt, whereBy, type Place } from "./view";
+
+/** One box as it is printed: the labels, the list and the CSV are made from these, so they agree. */
+export interface BoxRow {
+  number: number;
+  name: string;
+  /** "The suite, by 08:00", "Not for the day". */
+  where: string;
+  lost: boolean;
+  takenBy: string[];
+  items: BoxItem[];
+}
+
+export function boxRows(boxes: Boxes, places: ReadonlyMap<string, Place>, crew: Crew, guests: Record<string, Guest>): BoxRow[] {
+  const people = new Map(crew.people.map((person) => [person.id, person]));
+  return [...boxes.boxes]
+    .sort((a, b) => a.number - b.number)
+    .map((box) => {
+      const { place, lost } = neededAt(box, places);
+      return {
+        number: box.number,
+        name: box.name.trim() || "A box with no name",
+        where: whereBy(place, lost),
+        lost,
+        takenBy: box.personIds.map((id) => {
+          const person = people.get(id);
+          return person ? personName(person, guests) : "Someone no longer in the crew";
+        }),
+        items: box.items,
+      };
+    });
+}
+
+/** "2 × Shoes", or just "Shoes". */
+export const itemText = (item: Pick<BoxItem, "label" | "quantity">) =>
+  item.quantity > 1 ? `${item.quantity} × ${item.label}` : item.label;
+
+/** Every thing in every box, one to a row, for a spreadsheet. */
+export function boxesCsv(rows: BoxRow[]): string {
+  return toCsv(
+    ["Box", "Name", "Needed", "Taken by", "Item", "How many", "Packed"],
+    rows.flatMap((row) =>
+      (row.items.length > 0 ? row.items : [null]).map((item) => [
+        String(row.number),
+        row.name,
+        row.where,
+        row.takenBy.join(", "),
+        item?.label ?? "",
+        item ? String(item.quantity) : "",
+        item ? (item.packed ? "Yes" : "No") : "",
+      ]),
+    ),
+  );
+}
diff --git a/suite/lib/boxes/view.test.ts b/suite/lib/boxes/view.test.ts
new file mode 100644
index 00000000..8489f79d
--- /dev/null
+++ b/suite/lib/boxes/view.test.ts
@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+import { migrate } from "@jfrusher/trousseau";
+import type { Box } from "@/lib/model/types";
+import { dayPlaces, find, neededAt, packing } from "./view";
+
+const box = (patch: Partial<Box>): Box => ({ id: "b1", number: 1, name: "Getting ready", items: [], blockId: null, personIds: [], notes: "", ...patch });
+
+const doc = migrate({
+  timeline: {
+    lanes: ["Main day"],
+    blocks: [
+      { id: "blk-prep", label: "Getting ready", durationMin: 180, anchorMin: 9 * 60, gapMin: 0, bufferMin: 0, lane: "Main day", tags: [], location: "The house", notes: "", outputs: [] },
+    ],
+  },
+});
+
+describe("where a box is needed, and by when", () => {
+  it("is where its block is, by when its block starts", () => {
+    expect(neededAt(box({ blockId: "blk-prep" }), dayPlaces(doc))).toEqual({
+      place: { label: "Getting ready", location: "The house", startMin: 540 },
+      lost: false,
+    });
+  });
+
+  it("is nowhere for a box not for the day, and lost for one whose block has gone", () => {
+    expect(neededAt(box({ blockId: null }), dayPlaces(doc))).toEqual({ place: null, lost: false });
+    expect(neededAt(box({ blockId: "blk-gone" }), dayPlaces(doc))).toEqual({ place: null, lost: true });
+  });
+});
+
+describe("finding things", () => {
+  const boxes = {
+    boxes: [
+      box({ id: "b1", name: "Getting ready", items: [{ id: "i1", label: "Shoes", quantity: 2, packed: true }] }),
+      box({ id: "b2", number: 2, name: "Overnight", items: [{ id: "i2", label: "Spare shoes for dancing", quantity: 1, packed: false }] }),
+    ],
+  };
+
+  it("finds every box a thing is in, whatever the case", () => {
+    expect(find(boxes, "SHOES").map((found) => `${found.box.number}: ${found.item?.label}`)).toEqual(["1: Shoes", "2: Spare shoes for dancing"]);
+  });
+
+  it("wants every word, and finds a box by its own name", () => {
+    expect(find(boxes, "dancing shoes").map((found) => found.item?.label)).toEqual(["Spare shoes for dancing"]);
+    expect(find(boxes, "overnight")).toEqual([{ box: boxes.boxes[1], item: null }]);
+    expect(find(boxes, "   ")).toEqual([]);
+  });
+
+  it("counts packing by the line, not by how many of each", () => {
+    expect(packing({ items: [...boxes.boxes[0]!.items, ...boxes.boxes[1]!.items] })).toEqual({ packed: 1, total: 2 });
+  });
+});
diff --git a/suite/lib/boxes/view.ts b/suite/lib/boxes/view.ts
new file mode 100644
index 00000000..b6190deb
--- /dev/null
+++ b/suite/lib/boxes/view.ts
@@ -0,0 +1,73 @@
+import type { Trousseau } from "@jfrusher/trousseau";
+import { formatClock } from "@/apps/cadence/core/time/minutes";
+import { cached, readTimeline, resolvedDay } from "@/lib/model/slices";
+import type { Box, BoxItem, Boxes } from "@/lib/model/types";
+
+/** Where and when a block of the day is: what a box needed at it is labelled with. */
+export interface Place {
+  label: string;
+  location: string;
+  startMin: number;
+}
+
+/** Every block of the day by id, with where it is and when it starts. */
+export function dayPlaces(doc: Trousseau): ReadonlyMap<string, Place> {
+  return cached(doc, "boxPlaces", () => {
+    const starts = new Map(resolvedDay(doc).map((block) => [block.id, block.startMin]));
+    return new Map(
+      readTimeline(doc)
+        .blocks.filter((block) => starts.has(block.id))
+        .map((block) => [block.id, { label: block.label, location: block.location.trim(), startMin: starts.get(block.id)! }]),
+    );
+  });
+}
+
+/**
+ * Where a box is going and by when: its block's, or nothing for a box not for
+ * the day, or `lost` for one whose block the day no longer has.
+ */
+export function neededAt(box: Box, known: ReadonlyMap<string, Place>): { place: Place | null; lost: boolean } {
+  if (box.blockId === null) return { place: null, lost: false };
+  const place = known.get(box.blockId) ?? null;
+  return { place, lost: place === null };
+}
+
+/** "The suite, by 08:00", or why there is no saying: the page, the labels and the list all say it so. */
+export function whereBy(place: Place | null, lost: boolean): string {
+  if (lost) return "Its part of the day is no longer on the Timeline";
+  if (!place) return "Not for the day";
+  return `${place.location || place.label}, by ${formatClock(place.startMin)}`;
+}
+
+/** Things packed and things in the box, counted by line, not by how many of each. */
+export function packing(box: Pick<Box, "items">): { packed: number; total: number } {
+  return { packed: box.items.filter((item) => item.packed).length, total: box.items.length };
+}
+
+/** Every box's packing together. */
+export function packingOf(boxes: Boxes): { packed: number; total: number } {
+  return boxes.boxes.reduce(
+    (sum, box) => {
+      const one = packing(box);
+      return { packed: sum.packed + one.packed, total: sum.total + one.total };
+    },
+    { packed: 0, total: 0 },
+  );
+}
+
+export interface Found {
+  box: Box;
+  /** The thing that matched, or null when it was the box's own name. */
+  item: BoxItem | null;
+}
+
+/** "Shoes" → the box they are in. Every word must be in the thing, whatever the case. */
+export function find(boxes: Boxes, query: string): Found[] {
+  const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+  if (words.length === 0) return [];
+  const matches = (text: string) => words.every((word) => text.toLowerCase().includes(word));
+  return boxes.boxes.flatMap((box) => [
+    ...(matches(box.name) ? [{ box, item: null }] : []),
+    ...box.items.filter((item) => matches(item.label)).map((item) => ({ box, item })),
+  ]);
+}
diff --git a/suite/lib/cast/actions.test.ts b/suite/lib/cast/actions.test.ts
new file mode 100644
index 00000000..4a50f554
--- /dev/null
+++ b/suite/lib/cast/actions.test.ts
@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { emptyCastSlice } from "@/lib/model/slices";
+import { addCustomRole, removeCustomRole, renameCustomRole, setCastRole, setCustomRoleMembers } from "./actions";
+
+const empty = emptyCastSlice();
+
+describe("roles", () => {
+  it("sets a role's guest ids, replacing whatever was there", () => {
+    const withRole = setCastRole(empty, "a", ["g1"]);
+    expect(withRole.roles.a).toEqual(["g1"]);
+    expect(setCastRole(withRole, "a", []).roles.a).toEqual([]);
+  });
+
+  it("holds each partner's grandparents, as many as there are", () => {
+    expect(setCastRole(empty, "b-grandparents", ["g1", "g2"]).roles["b-grandparents"]).toEqual(["g1", "g2"]);
+  });
+});
+
+describe("custom roles", () => {
+  it("adds a custom role by name", () => {
+    const cast = addCustomRole(empty, "Me and my family");
+    expect(cast.customRoles).toHaveLength(1);
+    expect(cast.customRoles[0]).toMatchObject({ name: "Me and my family", guestIds: [] });
+  });
+
+  it("renames a custom role by id", () => {
+    const cast = addCustomRole(empty, "Old name");
+    const id = cast.customRoles[0]!.id;
+    expect(renameCustomRole(cast, id, "New name").customRoles[0]!.name).toBe("New name");
+  });
+
+  it("removes a custom role by id", () => {
+    const cast = addCustomRole(empty, "Gone");
+    const id = cast.customRoles[0]!.id;
+    expect(removeCustomRole(cast, id).customRoles).toEqual([]);
+  });
+
+  it("sets a custom role's guest ids, replacing whatever was there", () => {
+    const cast = addCustomRole(empty, "Ushers");
+    const id = cast.customRoles[0]!.id;
+    const withMembers = setCustomRoleMembers(cast, id, ["g1", "g2"]);
+    expect(withMembers.customRoles[0]!.guestIds).toEqual(["g1", "g2"]);
+    expect(setCustomRoleMembers(withMembers, id, []).customRoles[0]!.guestIds).toEqual([]);
+  });
+});
diff --git a/suite/lib/cast/actions.ts b/suite/lib/cast/actions.ts
new file mode 100644
index 00000000..f8dc6277
--- /dev/null
+++ b/suite/lib/cast/actions.ts
@@ -0,0 +1,32 @@
+import { newId } from "@/lib/model/ids";
+import type { Cast, CastRole, CastSlice, CustomRole } from "@/lib/model/types";
+
+/**
+ * Who is who, edited: the fixed roles, and roles of the couple's own devising.
+ * The cast is shared by Group shots and Ceremony, so these belong to neither.
+ */
+
+export function setCastRole(cast: CastSlice, role: CastRole, guestIds: string[]): CastSlice {
+  return { ...cast, roles: { ...cast.roles, [role]: guestIds } as Cast };
+}
+
+export function addCustomRole(cast: CastSlice, name: string): CastSlice {
+  const role: CustomRole = { id: newId("crole"), name, guestIds: [] };
+  return { ...cast, customRoles: [...cast.customRoles, role] };
+}
+
+export function renameCustomRole(cast: CastSlice, roleId: string, name: string): CastSlice {
+  return { ...cast, customRoles: cast.customRoles.map((r) => (r.id === roleId ? { ...r, name } : r)) };
+}
+
+/**
+ * A shot or a processional that still names the role is left as it is, and
+ * says so ("Deleted role") — the cast writes only itself.
+ */
+export function removeCustomRole(cast: CastSlice, roleId: string): CastSlice {
+  return { ...cast, customRoles: cast.customRoles.filter((r) => r.id !== roleId) };
+}
+
+export function setCustomRoleMembers(cast: CastSlice, roleId: string, guestIds: string[]): CastSlice {
+  return { ...cast, customRoles: cast.customRoles.map((r) => (r.id === roleId ? { ...r, guestIds } : r)) };
+}
diff --git a/suite/lib/ensemble/resolve.test.ts b/suite/lib/cast/resolve.test.ts
similarity index 77%
rename from suite/lib/ensemble/resolve.test.ts
rename to suite/lib/cast/resolve.test.ts
index 6b7fafb0..1502363e 100644
--- a/suite/lib/ensemble/resolve.test.ts
+++ b/suite/lib/cast/resolve.test.ts
@@ -1,7 +1,7 @@
 import { describe, expect, it } from "vitest";
 import type { Cast, CustomRole, Guest, Seating, Shot } from "@/lib/model/types";
 import { emptyCast } from "@/lib/model/slices";
-import { resolveShot } from "./resolve";
+import { resolveMembers } from "./resolve";
 
 const guest = (id: string, extra: Partial<Guest> = {}): Guest => ({
   id,
@@ -59,10 +59,10 @@ const shot = (members: Shot["members"], extra: Partial<Shot> = {}): Shot => ({
 
 const NAMES = { partners: ["Alex", "Sam"] as [string, string] };
 
-describe("resolveShot: member kinds", () => {
+describe("resolveMembers: member kinds", () => {
   it("resolves a guest member by id", () => {
     const guests = { g1: guest("g1", { firstName: "Charis" }) };
-    const result = resolveShot(shot([{ kind: "guest", ref: "g1" }]), guests, seating(), emptyCast(), [], NAMES);
+    const result = resolveMembers(shot([{ kind: "guest", ref: "g1" }]), guests, seating(), emptyCast(), [], NAMES);
     expect(result.people).toEqual([{ guestId: "g1", name: "Charis", rsvpStatus: "confirmed" }]);
     expect(result.problems).toEqual([]);
   });
@@ -70,7 +70,7 @@ describe("resolveShot: member kinds", () => {
   it("resolves a family member to all its members", () => {
     const guests = { g1: guest("g1", { firstName: "A" }), g2: guest("g2", { firstName: "B" }) };
     const s = seating({ families: { fam1: { id: "fam1", name: "Hartley", memberIds: ["g1", "g2"] } } });
-    const result = resolveShot(shot([{ kind: "family", ref: "fam1" }]), guests, s, emptyCast(), [], NAMES);
+    const result = resolveMembers(shot([{ kind: "family", ref: "fam1" }]), guests, s, emptyCast(), [], NAMES);
     expect(result.people.map((p) => p.name)).toEqual(["A", "B"]);
   });
 
@@ -81,31 +81,31 @@ describe("resolveShot: member kinds", () => {
       g3: guest("g3", { firstName: "C" }),
     };
     const s = seating({ subgroups: { grp1: { id: "grp1", name: "University" } } });
-    const result = resolveShot(shot([{ kind: "group", ref: "grp1" }]), guests, s, emptyCast(), [], NAMES);
+    const result = resolveMembers(shot([{ kind: "group", ref: "grp1" }]), guests, s, emptyCast(), [], NAMES);
     expect(result.people.map((p) => p.name).sort()).toEqual(["A", "B"]);
   });
 
   it("resolves a role member through the cast", () => {
     const guests = { g1: guest("g1", { firstName: "Charis" }) };
     const cast: Cast = { ...emptyCast(), a: ["g1"] };
-    const result = resolveShot(shot([{ kind: "role", ref: "a" }]), guests, seating(), cast, [], NAMES);
+    const result = resolveMembers(shot([{ kind: "role", ref: "a" }]), guests, seating(), cast, [], NAMES);
     expect(result.people.map((p) => p.name)).toEqual(["Charis"]);
   });
 
   it("says which partner's person is missing, by name", () => {
-    const result = resolveShot(shot([{ kind: "role", ref: "b-mother" }]), {}, seating(), emptyCast(), [], NAMES);
+    const result = resolveMembers(shot([{ kind: "role", ref: "b-mother" }]), {}, seating(), emptyCast(), [], NAMES);
     expect(result.problems).toContainEqual({ kind: "dangling", detail: "No one is set as Sam’s mother yet" });
   });
 
   it("resolves a text member with no guest id", () => {
-    const result = resolveShot(shot([{ kind: "text", ref: "the dog" }]), {}, seating(), emptyCast(), [], NAMES);
+    const result = resolveMembers(shot([{ kind: "text", ref: "the dog" }]), {}, seating(), emptyCast(), [], NAMES);
     expect(result.people).toEqual([{ guestId: null, name: "the dog", rsvpStatus: null }]);
   });
 
   it("resolves a customRole member to all its members", () => {
     const guests = { g1: guest("g1", { firstName: "A" }), g2: guest("g2", { firstName: "B" }) };
     const customRoles: CustomRole[] = [{ id: "crole1", name: "Ushers", guestIds: ["g1", "g2"] }];
-    const result = resolveShot(
+    const result = resolveMembers(
       shot([{ kind: "customRole", ref: "crole1" }]),
       guests,
       seating(),
@@ -117,11 +117,11 @@ describe("resolveShot: member kinds", () => {
   });
 });
 
-describe("resolveShot: dedupe and order", () => {
+describe("resolveMembers: dedupe and order", () => {
   it("prints a guest once, at their first position, even named twice", () => {
     const guests = { g1: guest("g1", { firstName: "A" }), g2: guest("g2", { firstName: "B" }) };
     const s = seating({ families: { fam1: { id: "fam1", name: "F", memberIds: ["g1"] } } });
-    const result = resolveShot(
+    const result = resolveMembers(
       shot([{ kind: "guest", ref: "g2" }, { kind: "family", ref: "fam1" }, { kind: "guest", ref: "g1" }]),
       guests,
       s,
@@ -133,19 +133,19 @@ describe("resolveShot: dedupe and order", () => {
   });
 });
 
-describe("resolveShot: problems", () => {
+describe("resolveMembers: problems", () => {
   it("flags a guest member that does not exist", () => {
-    const result = resolveShot(shot([{ kind: "guest", ref: "ghost" }]), {}, seating(), emptyCast(), [], NAMES);
+    const result = resolveMembers(shot([{ kind: "guest", ref: "ghost" }]), {}, seating(), emptyCast(), [], NAMES);
     expect(result.problems).toEqual([{ kind: "dangling", detail: expect.stringContaining("no longer exists") }]);
   });
 
   it("flags a family member that does not exist", () => {
-    const result = resolveShot(shot([{ kind: "family", ref: "ghost" }]), {}, seating(), emptyCast(), [], NAMES);
+    const result = resolveMembers(shot([{ kind: "family", ref: "ghost" }]), {}, seating(), emptyCast(), [], NAMES);
     expect(result.problems).toEqual([{ kind: "dangling", detail: expect.stringContaining("family") }]);
   });
 
   it("flags a role with nobody set", () => {
-    const result = resolveShot(shot([{ kind: "role", ref: "a" }]), {}, seating(), emptyCast(), [], NAMES);
+    const result = resolveMembers(shot([{ kind: "role", ref: "a" }]), {}, seating(), emptyCast(), [], NAMES);
     expect(result.problems).toEqual(
       expect.arrayContaining([{ kind: "dangling", detail: expect.stringContaining("Alex") }]),
     );
@@ -153,24 +153,24 @@ describe("resolveShot: problems", () => {
 
   it("flags a declined guest without dropping them from the shot", () => {
     const guests = { g1: guest("g1", { firstName: "Charis", rsvpStatus: "declined" }) };
-    const result = resolveShot(shot([{ kind: "guest", ref: "g1" }]), guests, seating(), emptyCast(), [], NAMES);
+    const result = resolveMembers(shot([{ kind: "guest", ref: "g1" }]), guests, seating(), emptyCast(), [], NAMES);
     expect(result.people).toHaveLength(1);
     expect(result.problems).toEqual([{ kind: "declined", name: "Charis" }]);
   });
 
   it("flags an empty shot when nothing resolves to a person", () => {
-    const result = resolveShot(shot([]), {}, seating(), emptyCast(), [], NAMES);
+    const result = resolveMembers(shot([]), {}, seating(), emptyCast(), [], NAMES);
     expect(result.problems).toEqual([{ kind: "empty" }]);
   });
 
   it("flags a customRole member that does not exist", () => {
-    const result = resolveShot(shot([{ kind: "customRole", ref: "ghost" }]), {}, seating(), emptyCast(), [], NAMES);
+    const result = resolveMembers(shot([{ kind: "customRole", ref: "ghost" }]), {}, seating(), emptyCast(), [], NAMES);
     expect(result.problems).toEqual([{ kind: "dangling", detail: expect.stringContaining("no longer exists") }]);
   });
 
   it("flags a customRole with nobody set", () => {
     const customRoles: CustomRole[] = [{ id: "crole1", name: "Ushers", guestIds: [] }];
-    const result = resolveShot(
+    const result = resolveMembers(
       shot([{ kind: "customRole", ref: "crole1" }]),
       {},
       seating(),
@@ -184,15 +184,15 @@ describe("resolveShot: problems", () => {
   });
 });
 
-describe("resolveShot: label", () => {
+describe("resolveMembers: label", () => {
   it("keeps a typed label as-is", () => {
-    const result = resolveShot(shot([], { label: "Couple, alone" }), {}, seating(), emptyCast(), [], NAMES);
+    const result = resolveMembers(shot([], { label: "Couple, alone" }), {}, seating(), emptyCast(), [], NAMES);
     expect(result.label).toBe("Couple, alone");
   });
 
   it("builds a blank label from the resolved names", () => {
     const guests = { g1: guest("g1", { firstName: "A" }), g2: guest("g2", { firstName: "B" }) };
-    const result = resolveShot(
+    const result = resolveMembers(
       shot([{ kind: "guest", ref: "g1" }, { kind: "guest", ref: "g2" }]),
       guests,
       seating(),
@@ -204,13 +204,13 @@ describe("resolveShot: label", () => {
   });
 
   it("falls back to a placeholder when a blank label resolves to nobody", () => {
-    const result = resolveShot(shot([]), {}, seating(), emptyCast(), [], NAMES);
-    expect(result.label).toBe("Untitled shot");
+    const result = resolveMembers(shot([]), {}, seating(), emptyCast(), [], NAMES);
+    expect(result.label).toBe("Untitled");
   });
 
   it("builds a blank label from each member's own descriptor, not the people it resolves to", () => {
     const s = seating({ families: { fam1: { id: "fam1", name: "Hartley family", memberIds: [] } } });
-    const result = resolveShot(
+    const result = resolveMembers(
       shot([{ kind: "role", ref: "a" }, { kind: "role", ref: "a-party" }, { kind: "family", ref: "fam1" }]),
       {},
       s,
@@ -223,7 +223,7 @@ describe("resolveShot: label", () => {
 
   it("names a custom role in the built label", () => {
     const customRoles: CustomRole[] = [{ id: "crole1", name: "Me and my family", guestIds: [] }];
-    const result = resolveShot(
+    const result = resolveMembers(
       shot([{ kind: "customRole", ref: "crole1" }]),
       {},
       seating(),
diff --git a/suite/lib/ensemble/resolve.ts b/suite/lib/cast/resolve.ts
similarity index 81%
rename from suite/lib/ensemble/resolve.ts
rename to suite/lib/cast/resolve.ts
index d604a6dc..559c6e56 100644
--- a/suite/lib/ensemble/resolve.ts
+++ b/suite/lib/cast/resolve.ts
@@ -1,7 +1,7 @@
 import { guestName, isComing } from "@/lib/model/slices";
 import type { Event as WeddingEvent } from "@jfrusher/trousseau";
 import { roleLabel } from "@/lib/model/partners";
-import type { Cast, CustomRole, Guest, RsvpStatus, Seating, Shot, ShotMember } from "@/lib/model/types";
+import type { Cast, CustomRole, Guest, RsvpStatus, Seating, ShotMember } from "@/lib/model/types";
 
 export interface ResolvedPerson {
   guestId: string | null;
@@ -9,15 +9,15 @@ export interface ResolvedPerson {
   rsvpStatus: RsvpStatus | null;
 }
 
-export type ShotProblem =
+export type MemberProblem =
   | { kind: "dangling"; detail: string }
   | { kind: "declined"; name: string }
   | { kind: "empty" };
 
-export interface ResolvedShot {
+export interface ResolvedGroup {
   label: string;
   people: ResolvedPerson[];
-  problems: ShotProblem[];
+  problems: MemberProblem[];
 }
 
 /** Whose names a role is spoken in: the partners'. */
@@ -50,24 +50,25 @@ export function memberDescriptor(
 }
 
 /**
- * A shot's members, resolved to the people they name right now.
+ * A group's members — a group shot's, a processional's — resolved to the
+ * people they name right now.
  *
  * Order is preserved as authored, and a guest named twice — once directly,
  * once through a family they belong to — is printed once, at its first
  * position. `guestId` is null for a free-text member, which cannot dedupe
  * against anything and never carries a declined warning.
  */
-export function resolveShot(
-  shot: Shot,
+export function resolveMembers(
+  group: { label: string; members: ShotMember[] },
   guests: Record<string, Guest>,
   seating: Seating,
   cast: Cast,
   customRoles: CustomRole[],
   names: Names,
-): ResolvedShot {
+): ResolvedGroup {
   const people: ResolvedPerson[] = [];
   const seen = new Set<string>();
-  const problems: ShotProblem[] = [];
+  const problems: MemberProblem[] = [];
 
   const addGuest = (guestId: string, source: string) => {
     const guest = guests[guestId];
@@ -82,17 +83,17 @@ export function resolveShot(
     if (!isComing(guest)) problems.push({ kind: "declined", name });
   };
 
-  for (const member of shot.members) {
+  for (const member of group.members) {
     resolveMember(member, guests, seating, cast, customRoles, names, addGuest, problems, people);
   }
 
   if (people.length === 0 && problems.length === 0) problems.push({ kind: "empty" });
 
   const label =
-    shot.label.trim() ||
-    (shot.members.length > 0
-      ? shot.members.map((m) => memberDescriptor(m, guests, seating, customRoles, names)).join(" + ")
-      : "Untitled shot");
+    group.label.trim() ||
+    (group.members.length > 0
+      ? group.members.map((m) => memberDescriptor(m, guests, seating, customRoles, names)).join(" + ")
+      : "Untitled");
 
   return { label, people, problems };
 }
@@ -105,17 +106,17 @@ function resolveMember(
   customRoles: CustomRole[],
   names: Names,
   addGuest: (guestId: string, source: string) => void,
-  problems: ShotProblem[],
+  problems: MemberProblem[],
   people: ResolvedPerson[],
 ): void {
   switch (member.kind) {
     case "guest":
-      addGuest(member.ref, "A shot member");
+      addGuest(member.ref, "A member");
       return;
     case "family": {
       const family = seating.families[member.ref];
       if (!family) {
-        problems.push({ kind: "dangling", detail: "A shot member names a family that no longer exists" });
+        problems.push({ kind: "dangling", detail: "A member names a family that no longer exists" });
         return;
       }
       for (const guestId of family.memberIds) addGuest(guestId, `"${family.name}"`);
@@ -124,7 +125,7 @@ function resolveMember(
     case "group": {
       const group = seating.groups[member.ref] ?? seating.subgroups[member.ref];
       if (!group) {
-        problems.push({ kind: "dangling", detail: "A shot member names a group that no longer exists" });
+        problems.push({ kind: "dangling", detail: "A member names a group that no longer exists" });
         return;
       }
       for (const guest of Object.values(guests)) {
@@ -144,7 +145,7 @@ function resolveMember(
     case "customRole": {
       const role = customRoles.find((r) => r.id === member.ref);
       if (!role) {
-        problems.push({ kind: "dangling", detail: "A shot member names a role that no longer exists" });
+        problems.push({ kind: "dangling", detail: "A member names a role that no longer exists" });
         return;
       }
       if (role.guestIds.length === 0) {
diff --git a/suite/lib/ceremony/actions.test.ts b/suite/lib/ceremony/actions.test.ts
new file mode 100644
index 00000000..34a6b4af
--- /dev/null
+++ b/suite/lib/ceremony/actions.test.ts
@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { emptyCeremony } from "@/lib/model/slices";
+import { addGroup, addMembers, moveGroup, newGroup, patchGroup, removeGroup, removeMember } from "./actions";
+
+const three = [newGroup({ id: "g1" }), newGroup({ id: "g2" }), newGroup({ id: "g3" })].reduce(addGroup, emptyCeremony());
+const order = (ceremony: typeof three) => ceremony.processional.map((group) => group.id);
+
+describe("the processional", () => {
+  it("adds a group at the end, walking alone, with nothing said about it yet", () => {
+    const added = addGroup(emptyCeremony());
+    expect(added.processional).toHaveLength(1);
+    expect(added.processional[0]).toMatchObject({ label: "", members: [], formation: "single", side: "", music: "", cue: "" });
+  });
+
+  it("moves a group, and leaves the order alone for a move off either end", () => {
+    expect(order(moveGroup(three, 2, 0))).toEqual(["g3", "g1", "g2"]);
+    expect(moveGroup(three, 0, -1)).toBe(three);
+    expect(moveGroup(three, 2, 3)).toBe(three);
+  });
+
+  it("changes and removes a group by id", () => {
+    expect(patchGroup(three, "g2", { music: "Canon in D", formation: "pairs" }).processional[1]).toMatchObject({
+      id: "g2",
+      music: "Canon in D",
+      formation: "pairs",
+    });
+    expect(order(removeGroup(three, "g2"))).toEqual(["g1", "g3"]);
+  });
+
+  it("adds several members as one change, and removes one by its place", () => {
+    const withCouple = addMembers(three, "g1", [
+      { kind: "role", ref: "a" },
+      { kind: "role", ref: "b" },
+    ]);
+    expect(withCouple.processional[0]!.members).toHaveLength(2);
+    expect(removeMember(withCouple, "g1", 0).processional[0]!.members).toEqual([{ kind: "role", ref: "b" }]);
+  });
+});
diff --git a/suite/lib/ceremony/actions.ts b/suite/lib/ceremony/actions.ts
new file mode 100644
index 00000000..0f55d877
--- /dev/null
+++ b/suite/lib/ceremony/actions.ts
@@ -0,0 +1,54 @@
+import { newId } from "@/lib/model/ids";
+import type { Ceremony, ShotMember, WalkGroup } from "@/lib/model/types";
+
+/**
+ * The processional, edited: groups in the order they walk, and who is in each.
+ * Order is the list's order, so moving a group is a splice.
+ */
+
+export function newGroup(patch: Partial<WalkGroup> = {}): WalkGroup {
+  return { id: newId("walk"), label: "", members: [], formation: "single", side: "", music: "", cue: "", ...patch };
+}
+
+export function addGroup(ceremony: Ceremony, group: WalkGroup = newGroup()): Ceremony {
+  return { ...ceremony, processional: [...ceremony.processional, group] };
+}
+
+export function patchGroup(ceremony: Ceremony, groupId: string, patch: Partial<Omit<WalkGroup, "id">>): Ceremony {
+  return {
+    ...ceremony,
+    processional: ceremony.processional.map((group) => (group.id === groupId ? { ...group, ...patch } : group)),
+  };
+}
+
+export function removeGroup(ceremony: Ceremony, groupId: string): Ceremony {
+  return { ...ceremony, processional: ceremony.processional.filter((group) => group.id !== groupId) };
+}
+
+/** Moves a group to another place in the order. The same processional back when nothing moves. */
+export function moveGroup(ceremony: Ceremony, fromIndex: number, toIndex: number): Ceremony {
+  const processional = [...ceremony.processional];
+  if (toIndex < 0 || toIndex >= processional.length || fromIndex === toIndex) return ceremony;
+  const [moved] = processional.splice(fromIndex, 1);
+  if (!moved) return ceremony;
+  processional.splice(toIndex, 0, moved);
+  return { ...ceremony, processional };
+}
+
+export function addMembers(ceremony: Ceremony, groupId: string, members: ShotMember[]): Ceremony {
+  return {
+    ...ceremony,
+    processional: ceremony.processional.map((group) =>
+      group.id === groupId ? { ...group, members: [...group.members, ...members] } : group,
+    ),
+  };
+}
+
+export function removeMember(ceremony: Ceremony, groupId: string, index: number): Ceremony {
+  return {
+    ...ceremony,
+    processional: ceremony.processional.map((group) =>
+      group.id === groupId ? { ...group, members: group.members.filter((_, i) => i !== index) } : group,
+    ),
+  };
+}
diff --git a/suite/lib/ceremony/propose.test.ts b/suite/lib/ceremony/propose.test.ts
new file mode 100644
index 00000000..0b7dd3ee
--- /dev/null
+++ b/suite/lib/ceremony/propose.test.ts
@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { setCastRole } from "@/lib/cast/actions";
+import { emptyCastSlice } from "@/lib/model/slices";
+import { suggestOrder } from "./propose";
+
+const shape = (cast: ReturnType<typeof emptyCastSlice>) =>
+  suggestOrder(cast).map((group) => ({
+    who: group.members.map((member) => member.ref).join(" + "),
+    formation: group.formation,
+    side: group.side,
+  }));
+
+describe("suggesting an order", () => {
+  it("walks from the outside in: the officiant, grandparents, parents, the wedding parties, then the couple together", () => {
+    let cast = emptyCastSlice();
+    for (const role of ["a-grandparents", "b-mother", "b-father", "a-mother", "a-party", "b-party"] as const) {
+      cast = setCastRole(cast, role, ["someone"]);
+    }
+    expect(shape(cast)).toEqual([
+      { who: "The officiant", formation: "single", side: "" },
+      { who: "a-grandparents", formation: "pairs", side: "a" },
+      { who: "a-mother", formation: "pairs", side: "a" },
+      { who: "b-mother + b-father", formation: "pairs", side: "b" },
+      { who: "a-party", formation: "pairs", side: "a" },
+      { who: "b-party", formation: "pairs", side: "b" },
+      { who: "a + b", formation: "pairs", side: "" },
+    ]);
+  });
+
+  it("leaves out roles nobody is cast in, but never the couple", () => {
+    expect(shape(emptyCastSlice()).map((group) => group.who)).toEqual(["The officiant", "a + b"]);
+  });
+
+  it("gives every group an id of its own", () => {
+    const ids = suggestOrder(emptyCastSlice()).map((group) => group.id);
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+});
diff --git a/suite/lib/ceremony/propose.ts b/suite/lib/ceremony/propose.ts
new file mode 100644
index 00000000..d67bd8e4
--- /dev/null
+++ b/suite/lib/ceremony/propose.ts
@@ -0,0 +1,31 @@
+import type { CastRole, CastSlice, Formation, Side, WalkGroup } from "@/lib/model/types";
+import { newGroup } from "./actions";
+
+/**
+ * A starting order for the processional, from who is who: the officiant in
+ * place, the grandparents, the parents, the wedding parties, and then the
+ * couple, together.
+ *
+ * A starting point, every part of it the couple's to change. It leaves out a
+ * role nobody has been cast in, and assumes nothing about who walks with whom:
+ * whether one of the couple walks with a parent, or waits at the front, is
+ * theirs to say. The couple are always in it, cast or not, so that a wedding
+ * with nobody in Who's who is told so rather than handed an empty aisle.
+ */
+export function suggestOrder(cast: CastSlice): WalkGroup[] {
+  const walking = (roles: CastRole[], formation: Formation, side: Side): WalkGroup[] => {
+    const present = roles.filter((role) => cast.roles[role].length > 0);
+    return present.length === 0 ? [] : [newGroup({ members: present.map((ref) => ({ kind: "role", ref })), formation, side })];
+  };
+
+  return [
+    newGroup({ members: [{ kind: "text", ref: "The officiant" }], cue: "In place before the music starts" }),
+    ...walking(["a-grandparents"], "pairs", "a"),
+    ...walking(["b-grandparents"], "pairs", "b"),
+    ...walking(["a-mother", "a-father"], "pairs", "a"),
+    ...walking(["b-mother", "b-father"], "pairs", "b"),
+    ...walking(["a-party"], "pairs", "a"),
+    ...walking(["b-party"], "pairs", "b"),
+    newGroup({ members: [{ kind: "role", ref: "a" }, { kind: "role", ref: "b" }], formation: "pairs" }),
+  ];
+}
diff --git a/suite/lib/ceremony/render/pdf/processionalSheet.ts b/suite/lib/ceremony/render/pdf/processionalSheet.ts
new file mode 100644
index 00000000..b4572058
--- /dev/null
+++ b/suite/lib/ceremony/render/pdf/processionalSheet.ts
@@ -0,0 +1,120 @@
+// Brigade's page, table, text and font kit, as the shot sheet uses it: see the
+// note at the top of lib/ensemble/render/pdf/shotSheet.ts.
+import { PDFDocument, type PDFFont } from "pdf-lib";
+import { embedFamily } from "@/apps/brigade/render/pdf/embedFonts";
+import type { FontSource } from "@/apps/brigade/render/pdf/fontSource";
+import { addSheet, hexColour, type Colour, type Sheet } from "@/apps/brigade/render/pdf/page";
+import { paginate } from "@/apps/brigade/render/pdf/table";
+import { wrap } from "@/apps/brigade/render/pdf/text";
+import { contentBox, PAGE_SIZES, ptToMm } from "@/apps/brigade/render/pdf/units";
+import type { ProcessionalRow } from "../../rows";
+
+export interface ProcessionalSheetOptions {
+  fontSource: FontSource;
+  /** "Alex & Sam", or nothing yet. */
+  coupleNames: string;
+  generatedOn?: string;
+}
+
+const MARGIN_MM = 15;
+const HEADER_MM = 16;
+const FOOTER_MM = 10;
+const ACCENT = "#46617a";
+const BODY_PT = 9.5;
+const LEADING = 1.35;
+const NO_COL_MM = 10;
+const HOW_COL_MM = 42;
+const MUSIC_COL_MM = 58;
+
+const MUTED: Colour = { r: 0.44, g: 0.43, b: 0.41 };
+const RULE: Colour = { r: 0.84, g: 0.83, b: 0.82 };
+const DANGER: Colour = { r: 0.64, g: 0.23, b: 0.17 };
+
+interface Line {
+  row: ProcessionalRow;
+  labelLines: string[];
+  peopleLines: string[];
+  howLines: string[];
+  musicLines: string[];
+  cueLines: string[];
+  heightMm: number;
+}
+
+/**
+ * The processional on paper, for the officiant and whoever runs the day: who
+ * walks, in order, how, and what the music is doing. A mark in the margin
+ * where a group names somebody not set, as the screen does.
+ */
+export async function renderProcessionalSheet(rows: ProcessionalRow[], options: ProcessionalSheetOptions): Promise<Uint8Array> {
+  const pdf = await PDFDocument.create();
+  const { regular, bold } = await embedFamily(pdf, await options.fontSource("Lato"));
+  const accent = hexColour(ACCENT);
+  const size = PAGE_SIZES.A4;
+  const box = contentBox(size, MARGIN_MM);
+  const whoColMm = box.widthMm - NO_COL_MM - HOW_COL_MM - MUSIC_COL_MM - 8;
+  const lineMm = ptToMm(BODY_PT * LEADING);
+
+  const lines: Line[] = rows.map((row) => {
+    const labelLines = wrap(row.label, bold, BODY_PT, whoColMm);
+    const peopleLines = row.people.length > 0 ? wrap(row.people.join(", "), regular, BODY_PT, whoColMm) : [];
+    const howLines = wrap(row.how, regular, BODY_PT, HOW_COL_MM);
+    const musicLines = row.music ? wrap(row.music, bold, BODY_PT, MUSIC_COL_MM) : [];
+    const cueLines = row.cue ? wrap(row.cue, regular, BODY_PT, MUSIC_COL_MM) : [];
+    const tall = Math.max(labelLines.length + peopleLines.length, howLines.length, musicLines.length + cueLines.length, 1);
+    return { row, labelLines, peopleLines, howLines, musicLines, cueLines, heightMm: tall * lineMm + 3 };
+  });
+
+  const pages = paginate(lines, box.heightMm - HEADER_MM - FOOTER_MM);
+  pages.forEach((indices, pageIndex) => {
+    const sheet = addSheet(pdf, size);
+    const y0 = box.yMm;
+    const title = options.coupleNames ? `The processional — ${options.coupleNames}` : "The processional";
+    sheet.text(title, { xMm: box.xMm, yMm: y0 + 6, font: bold, sizePt: 14 });
+    sheet.text(`Page ${pageIndex + 1} of ${pages.length}`, {
+      xMm: box.xMm + box.widthMm,
+      yMm: y0 + 6,
+      font: regular,
+      sizePt: 8,
+      colour: MUTED,
+      alignRight: true,
+    });
+    sheet.line(box.xMm, y0 + 9, box.xMm + box.widthMm, y0 + 9, { widthPt: 1, colour: accent });
+
+    let y = y0 + HEADER_MM;
+    for (const index of indices) {
+      const line = lines[index];
+      if (line) y = drawLine(sheet, line, { xMm: box.xMm, widthMm: box.widthMm, whoColMm, lineMm, y, bold, regular });
+    }
+
+    sheet.text(options.generatedOn ?? "", { xMm: box.xMm, yMm: size.heightMm - MARGIN_MM + 4, font: regular, sizePt: 8, colour: MUTED });
+  });
+
+  return pdf.save();
+}
+
+function drawLine(
+  sheet: Sheet,
+  line: Line,
+  at: { xMm: number; widthMm: number; whoColMm: number; lineMm: number; y: number; bold: PDFFont; regular: PDFFont },
+): number {
+  const whoX = at.xMm + NO_COL_MM;
+  const howX = whoX + at.whoColMm + 4;
+  const musicX = howX + HOW_COL_MM + 4;
+  const draw = (texts: string[], xMm: number, font: PDFFont, from = 0) =>
+    texts.forEach((text, i) => {
+      if (text) sheet.text(text, { xMm, yMm: at.y + at.lineMm * (from + i + 1), font, sizePt: BODY_PT });
+    });
+
+  sheet.text(`${line.row.number}.`, { xMm: at.xMm, yMm: at.y + at.lineMm, font: at.regular, sizePt: BODY_PT });
+  draw(line.labelLines, whoX, at.bold);
+  draw(line.peopleLines, whoX, at.regular, line.labelLines.length);
+  draw(line.howLines, howX, at.regular);
+  draw(line.musicLines, musicX, at.bold);
+  draw(line.cueLines, musicX, at.regular, line.musicLines.length);
+
+  if (line.row.trouble) sheet.rect(at.xMm - 3.5, at.y + 1.2, 1.4, at.lineMm * 0.8, { colour: DANGER });
+
+  const bottom = at.y + line.heightMm;
+  sheet.line(at.xMm, bottom - 1, at.xMm + at.widthMm, bottom - 1, { widthPt: 0.5, colour: RULE });
+  return bottom;
+}
diff --git a/suite/lib/ceremony/rows.test.ts b/suite/lib/ceremony/rows.test.ts
new file mode 100644
index 00000000..7fec976d
--- /dev/null
+++ b/suite/lib/ceremony/rows.test.ts
@@ -0,0 +1,46 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { migrate } from "@jfrusher/trousseau";
+import { nodeFontSource } from "@/apps/brigade/render/pdf/nodeFontSource";
+import { textOf } from "@/apps/brigade/render/pdf/readPdf";
+import { readCast, readCeremony, readGuests, readSeating } from "@/lib/model/slices";
+import { renderProcessionalSheet } from "./render/pdf/processionalSheet";
+import { processionalRows, processionalText } from "./rows";
+
+const raw = JSON.parse(readFileSync(join(process.cwd(), "public", "fixtures", "example-wedding.trousseau.json"), "utf8"));
+const doc = migrate(raw);
+const rows = processionalRows(readCeremony(doc).processional, readGuests(doc), readSeating(doc), readCast(doc), doc.event);
+
+describe("the processional, read out", () => {
+  it("names each group, who is in it, how they walk and to which side", () => {
+    expect(rows[0]).toMatchObject({ number: 1, label: "The registrar", people: [], how: "One at a time", cue: "In place before the music starts" });
+    expect(rows[1]!.label).toBe("Alex’s mother + Alex’s father");
+    expect(rows[1]!.people).toHaveLength(2);
+    expect(rows[1]!.how).toBe("In pairs, to Alex’s side");
+    expect(rows.some((row) => row.trouble)).toBe(false);
+  });
+
+  it("is plain text to paste into an email, in order", () => {
+    const text = processionalText(rows, doc.event);
+    expect(text.split("\n").slice(0, 5)).toEqual([
+      "The processional — Alex & Sam",
+      "",
+      "1. The registrar",
+      "   One at a time.",
+      "   In place before the music starts.",
+    ]);
+    expect(text).toContain("6. Alex + Sam");
+    expect(text).toContain("   Music: The Arrival of the Queen of Sheba. The music changes as the couple enter.");
+  });
+});
+
+describe("the processional, printed", () => {
+  it("is one page for the officiant, with every group on it", async () => {
+    const { text, pages } = await textOf(await renderProcessionalSheet(rows, { fontSource: nodeFontSource, coupleNames: "Alex & Sam" }));
+    expect(pages).toBe(1);
+    expect(text).toContain("The processional — Alex & Sam");
+    for (const row of rows) expect(text).toContain(row.label);
+    expect(text).toContain("Canon in D");
+  });
+});
diff --git a/suite/lib/ceremony/rows.ts b/suite/lib/ceremony/rows.ts
new file mode 100644
index 00000000..b186e873
--- /dev/null
+++ b/suite/lib/ceremony/rows.ts
@@ -0,0 +1,62 @@
+import type { Event as WeddingEvent } from "@jfrusher/trousseau";
+import { resolveMembers } from "@/lib/cast/resolve";
+import { coupleTitle, sideLabel } from "@/lib/model/partners";
+import type { CastSlice, Formation, Guest, Seating, WalkGroup } from "@/lib/model/types";
+
+export const FORMATION_WORDS: Record<Formation, string> = {
+  single: "One at a time",
+  pairs: "In pairs",
+  threes: "In threes",
+};
+
+/** One group as it is read out or printed: the page and the email are made from these, so they agree. */
+export interface ProcessionalRow {
+  number: number;
+  label: string;
+  /** The people walking, by name; empty for a group of words alone. */
+  people: string[];
+  /** "In pairs, to Alex’s side". */
+  how: string;
+  music: string;
+  cue: string;
+  trouble: boolean;
+}
+
+export function processionalRows(
+  processional: WalkGroup[],
+  guests: Record<string, Guest>,
+  seating: Seating,
+  cast: CastSlice,
+  event: Pick<WeddingEvent, "partners">,
+): ProcessionalRow[] {
+  return processional.map((group, index) => {
+    const resolved = resolveMembers(group, guests, seating, cast.roles, cast.customRoles, event);
+    const side = sideLabel(group.side, event);
+    const people = resolved.people.map((person) => person.name);
+    return {
+      number: index + 1,
+      label: resolved.label,
+      // Words standing in for somebody — "The officiant" — are the label already.
+      people: people.join(", ") === resolved.label ? [] : people,
+      // "to Alex’s side", "to both sides": a name keeps its capital.
+      how: side ? `${FORMATION_WORDS[group.formation]}, to ${group.side === "both" ? "both sides" : side}` : FORMATION_WORDS[group.formation],
+      music: group.music.trim(),
+      cue: group.cue.trim(),
+      trouble: resolved.problems.length > 0,
+    };
+  });
+}
+
+/** The processional as plain text, to paste into an email to the wedding party. */
+export function processionalText(rows: ProcessionalRow[], event: Pick<WeddingEvent, "partners">): string {
+  const title = coupleTitle(event.partners);
+  const lines = [title ? `The processional — ${title}` : "The processional", ""];
+  for (const row of rows) {
+    lines.push(`${row.number}. ${row.label}`);
+    if (row.people.length > 0) lines.push(`   ${row.people.join(", ")}`);
+    lines.push(`   ${row.how}.`);
+    const music = [row.music && `Music: ${row.music}.`, row.cue && `${row.cue}.`].filter(Boolean).join(" ");
+    if (music) lines.push(`   ${music}`);
+  }
+  return lines.join("\n");
+}
diff --git a/suite/lib/documents/describe.test.ts b/suite/lib/documents/describe.test.ts
index 34877edc..5316bf59 100644
--- a/suite/lib/documents/describe.test.ts
+++ b/suite/lib/documents/describe.test.ts
@@ -53,6 +53,11 @@ describe("what changed between two versions", () => {
     expect(describeChanges(before, after)).toEqual(["The day’s blocks put in a new order"]);
   });
 
+  it("says when somebody added or removed a tool", () => {
+    const after = { ...before, tools: { shown: ["seating"] } };
+    expect(describeChanges(before, after)).toEqual(["Which tools the wedding uses: changed"]);
+  });
+
   it("says nothing of a version that changed nothing", () => {
     expect(describeChanges(before, before)).toEqual([]);
   });
diff --git a/suite/lib/documents/describe.ts b/suite/lib/documents/describe.ts
index fd80be4b..52b056e0 100644
--- a/suite/lib/documents/describe.ts
+++ b/suite/lib/documents/describe.ts
@@ -21,6 +21,11 @@ const WHOLE: Partial<Record<SliceName, string>> = {
   crew: "Suppliers and their people",
   shots: "The group shots",
   stationery: "The card design",
+  tools: "Which tools the wedding uses",
+  cast: "Who is who",
+  ceremony: "The processional",
+  boxes: "The boxes",
+  bar: "The bar",
 };
 
 const COLLECTION: Record<string, { one: string; many: string }> = {
@@ -28,6 +33,7 @@ const COLLECTION: Record<string, { one: string; many: string }> = {
   tables: { one: "table", many: "tables" },
   blocks: { one: "block of the day", many: "blocks of the day" },
   jobs: { one: "job or task", many: "jobs and tasks" },
+  boxes: { one: "box", many: "boxes" },
 };
 
 /** What a part is: "Ada Byron", "Table 3", "Speeches", or a slice in words. */
@@ -40,7 +46,9 @@ export function partName(key: string, value: unknown): string {
         ? [record["firstName"], record["lastName"]].filter((part) => typeof part === "string" && part).join(" ")
         : typeof record["label"] === "string"
           ? record["label"]
-          : "";
+          : typeof record["name"] === "string"
+            ? record["name"]
+            : "";
     const noun = COLLECTION[info.record.collection]?.one ?? "record";
     return name ? `${name} (a ${noun})` : `A ${noun}`;
   }
diff --git a/suite/lib/documents/live.ts b/suite/lib/documents/live.ts
index 56172e7c..ff2686f0 100644
--- a/suite/lib/documents/live.ts
+++ b/suite/lib/documents/live.ts
@@ -2,7 +2,7 @@
 
 import type { RealtimeChannel, SupabaseClient } from "@supabase/supabase-js";
 import { create } from "zustand";
-import { TOOLS, WEDDING_PAGES } from "@/lib/tools";
+import { GUESTS, TOOLS, WEDDING_PAGES } from "@/lib/tools";
 
 /**
  * A wedding's live channel: told the moment the account's copy moves, and
@@ -27,7 +27,7 @@ export const usePresence = create<{ others: Here[] }>(() => ({ others: [] }));
 
 /** The name a page goes by, for saying where someone is. */
 export function pageName(pathname: string): string | null {
-  return [...WEDDING_PAGES, ...TOOLS].find((page) => page.href === pathname)?.name ?? null;
+  return [...WEDDING_PAGES, GUESTS, ...TOOLS].find((page) => page.href === pathname)?.name ?? null;
 }
 
 /** Everyone in `state` but `me`, once each, at the page they were last seen on. */
diff --git a/suite/lib/documents/mergeCloudDocument.test.ts b/suite/lib/documents/mergeCloudDocument.test.ts
index 95e0bbf7..1c1b4cac 100644
--- a/suite/lib/documents/mergeCloudDocument.test.ts
+++ b/suite/lib/documents/mergeCloudDocument.test.ts
@@ -169,3 +169,16 @@ test("the day is this side's own when the timeline and the event are", () => {
 
   expect(merge(base, server, fingerprintParts(base)).raw.day).toEqual({ from: "mine" });
 });
+
+const box = (id: string, packed: boolean) => ({ id, number: 1, name: id, items: [{ id: `${id}-item`, label: "Shoes", quantity: 1, packed }] });
+
+test("two people packing two different boxes both keep what they ticked", () => {
+  const base = doc({ boxes: { boxes: [box("ready", false), box("overnight", false)] } });
+  const local = doc({ boxes: { boxes: [box("ready", true), box("overnight", false)] } });
+  const server = doc({ boxes: { boxes: [box("ready", false), box("overnight", true)] } });
+
+  const result = merge(local, server, fingerprintParts(base));
+
+  expect(result.conflicts).toEqual([]);
+  expect(result.raw.boxes).toEqual({ boxes: [box("ready", true), box("overnight", true)] });
+});
diff --git a/suite/lib/documents/parts.ts b/suite/lib/documents/parts.ts
index a3e6a808..a941d56b 100644
--- a/suite/lib/documents/parts.ts
+++ b/suite/lib/documents/parts.ts
@@ -19,7 +19,8 @@ import { SLICE_NAMES, type SliceName } from "@jfrusher/trousseau";
  *   timeline/blocks/<id>     one block
  *   timeline/blocks#order    the blocks' order
  *   crew, crew/jobs/<id>, crew/jobs#order
- *   event, shots, stationery
+ *   boxes, boxes/boxes/<id>, boxes/boxes#order
+ *   event, shots, stationery, tools, cast, ceremony, bar
  *
  * `day` is not a part: it is published from the timeline and the event, and
  * is worked out again rather than merged — see `mergeCloudDocument`.
@@ -41,6 +42,8 @@ export const KEYED: Partial<Record<SliceName, Keyed>> = {
   seating: { field: "tables", shape: "map" },
   timeline: { field: "blocks", shape: "list" },
   crew: { field: "jobs", shape: "list" },
+  // Two people packing at once tick things in different boxes.
+  boxes: { field: "boxes", shape: "list" },
 };
 
 /** Published from the timeline and the event; worked out again, never merged. */
diff --git a/suite/lib/ensemble/actions.test.ts b/suite/lib/ensemble/actions.test.ts
index 9176cbdd..11674ad0 100644
--- a/suite/lib/ensemble/actions.test.ts
+++ b/suite/lib/ensemble/actions.test.ts
@@ -1,25 +1,20 @@
 import { describe, expect, it } from "vitest";
 import type { Shots } from "@/lib/model/types";
 import {
-  addCustomRole,
   addMember,
   addSection,
   addShot,
   duplicateShot,
   patchShot,
-  removeCustomRole,
   removeMember,
   removeSection,
   removeShot,
-  renameCustomRole,
   renameSection,
   reorderSections,
   reorderShot,
-  setCastRole,
-  setCustomRoleMembers,
 } from "./actions";
 
-const empty: Shots = { cast: {} as Shots["cast"], customRoles: [], sections: [] };
+const empty: Shots = { sections: [] };
 
 describe("sections", () => {
   it("adds a section with the given name", () => {
@@ -133,39 +128,3 @@ describe("members", () => {
     expect(shots.sections[0]!.shots[0]!.members).toEqual([{ kind: "text", ref: "the dog" }]);
   });
 });
-
-describe("cast", () => {
-  it("sets a role's guest ids, replacing whatever was there", () => {
-    const withRole = setCastRole(empty, "a", ["g1"]);
-    expect(withRole.cast.a).toEqual(["g1"]);
-    expect(setCastRole(withRole, "a", []).cast.a).toEqual([]);
-  });
-});
-
-describe("custom roles", () => {
-  it("adds a custom role by name", () => {
-    const shots = addCustomRole(empty, "Me and my family");
-    expect(shots.customRoles).toHaveLength(1);
-    expect(shots.customRoles[0]).toMatchObject({ name: "Me and my family", guestIds: [] });
-  });
-
-  it("renames a custom role by id", () => {
-    const shots = addCustomRole(empty, "Old name");
-    const id = shots.customRoles[0]!.id;
-    expect(renameCustomRole(shots, id, "New name").customRoles[0]!.name).toBe("New name");
-  });
-
-  it("removes a custom role by id", () => {
-    const shots = addCustomRole(empty, "Gone");
-    const id = shots.customRoles[0]!.id;
-    expect(removeCustomRole(shots, id).customRoles).toEqual([]);
-  });
-
-  it("sets a custom role's guest ids, replacing whatever was there", () => {
-    const shots = addCustomRole(empty, "Ushers");
-    const id = shots.customRoles[0]!.id;
-    const withMembers = setCustomRoleMembers(shots, id, ["g1", "g2"]);
-    expect(withMembers.customRoles[0]!.guestIds).toEqual(["g1", "g2"]);
-    expect(setCustomRoleMembers(withMembers, id, []).customRoles[0]!.guestIds).toEqual([]);
-  });
-});
diff --git a/suite/lib/ensemble/actions.ts b/suite/lib/ensemble/actions.ts
index 590027c1..060a95d6 100644
--- a/suite/lib/ensemble/actions.ts
+++ b/suite/lib/ensemble/actions.ts
@@ -1,5 +1,5 @@
 import { newId } from "@/lib/model/ids";
-import type { Cast, CastRole, CustomRole, Shot, ShotMember, ShotSection, Shots } from "@/lib/model/types";
+import type { Shot, ShotMember, ShotSection, Shots } from "@/lib/model/types";
 
 /**
  * The shot list: sections holding shots holding members. A shot lives inside
@@ -105,27 +105,3 @@ function patchShotMembers(
     })),
   };
 }
-
-export function setCastRole(shots: Shots, role: CastRole, guestIds: string[]): Shots {
-  return { ...shots, cast: { ...shots.cast, [role]: guestIds } as Cast };
-}
-
-export function addCustomRole(shots: Shots, name: string): Shots {
-  const role: CustomRole = { id: newId("crole"), name, guestIds: [] };
-  return { ...shots, customRoles: [...shots.customRoles, role] };
-}
-
-export function renameCustomRole(shots: Shots, roleId: string, name: string): Shots {
-  return { ...shots, customRoles: shots.customRoles.map((r) => (r.id === roleId ? { ...r, name } : r)) };
-}
-
-export function removeCustomRole(shots: Shots, roleId: string): Shots {
-  return { ...shots, customRoles: shots.customRoles.filter((r) => r.id !== roleId) };
-}
-
-export function setCustomRoleMembers(shots: Shots, roleId: string, guestIds: string[]): Shots {
-  return {
-    ...shots,
-    customRoles: shots.customRoles.map((r) => (r.id === roleId ? { ...r, guestIds } : r)),
-  };
-}
diff --git a/suite/lib/ensemble/exports.test.ts b/suite/lib/ensemble/exports.test.ts
index 17e2e56c..3859dcb0 100644
--- a/suite/lib/ensemble/exports.test.ts
+++ b/suite/lib/ensemble/exports.test.ts
@@ -59,6 +59,8 @@ const emptyCast: Cast = {
   "a-father": [],
   "b-mother": [],
   "b-father": [],
+  "a-grandparents": [],
+  "b-grandparents": [],
   "a-party": [],
   "b-party": [],
 };
diff --git a/suite/lib/ensemble/exports.ts b/suite/lib/ensemble/exports.ts
index 31a43e00..93f5f0a3 100644
--- a/suite/lib/ensemble/exports.ts
+++ b/suite/lib/ensemble/exports.ts
@@ -1,7 +1,7 @@
 import { toCsv } from "@/lib/data/csv";
 import type { Event as WeddingEvent } from "@jfrusher/trousseau";
 import type { Cast, CustomRole, Guest, Seating, ShotSection } from "@/lib/model/types";
-import { resolveShot } from "./resolve";
+import { resolveMembers } from "@/lib/cast/resolve";
 
 /** Section, number, shot, the resolved names, and the note. The sheet a photographer prints. */
 export function shotListCsv(
@@ -19,7 +19,7 @@ export function shotListCsv(
   for (const section of sections) {
     for (const shot of section.shots) {
       number += 1;
-      const resolved = resolveShot(shot, guests, seating, cast, customRoles, names);
+      const resolved = resolveMembers(shot, guests, seating, cast, customRoles, names);
       rows.push([section.name, String(number), resolved.label, resolved.people.map((p) => p.name).join(", "), shot.notes]);
     }
   }
diff --git a/suite/lib/ensemble/render/pdf/shotSheet.test.ts b/suite/lib/ensemble/render/pdf/shotSheet.test.ts
index 2791f6a6..7f7b2eff 100644
--- a/suite/lib/ensemble/render/pdf/shotSheet.test.ts
+++ b/suite/lib/ensemble/render/pdf/shotSheet.test.ts
@@ -56,6 +56,8 @@ const emptyCast: Cast = {
   "a-father": [],
   "b-mother": [],
   "b-father": [],
+  "a-grandparents": [],
+  "b-grandparents": [],
   "a-party": [],
   "b-party": [],
 };
diff --git a/suite/lib/ensemble/render/pdf/shotSheet.ts b/suite/lib/ensemble/render/pdf/shotSheet.ts
index cb39c474..7a1a8a77 100644
--- a/suite/lib/ensemble/render/pdf/shotSheet.ts
+++ b/suite/lib/ensemble/render/pdf/shotSheet.ts
@@ -9,7 +9,7 @@ import { paginate } from "@/apps/brigade/render/pdf/table";
 import { wrap } from "@/apps/brigade/render/pdf/text";
 import { contentBox, PAGE_SIZES, ptToMm } from "@/apps/brigade/render/pdf/units";
 import type { Cast, CustomRole, Guest, Seating, ShotSection } from "@/lib/model/types";
-import { resolveShot } from "@/lib/ensemble/resolve";
+import { resolveMembers } from "@/lib/cast/resolve";
 
 export interface ShotSheetOptions {
   fontSource: FontSource;
@@ -75,7 +75,7 @@ export async function renderShotSheet(
 
     for (const shot of section.shots) {
       shotNumber += 1;
-      const resolved = resolveShot(shot, guests, seating, cast, customRoles, { partners: options.partners });
+      const resolved = resolveMembers(shot, guests, seating, cast, customRoles, { partners: options.partners });
       const labelLines = wrap(resolved.label, bold, BODY_PT, labelColMm);
       const peopleLines = wrap(resolved.people.map((p) => p.name).join(", ") || "—", regular, BODY_PT, peopleColMm);
       const notesLines = wrap(shot.notes, regular, BODY_PT, NOTES_COL_MM);
diff --git a/suite/lib/export/weddingPack.ts b/suite/lib/export/weddingPack.ts
index 135292d7..5d32244e 100644
--- a/suite/lib/export/weddingPack.ts
+++ b/suite/lib/export/weddingPack.ts
@@ -9,8 +9,10 @@ import { PDFDocument } from "pdf-lib";
  * chances to be holding a version of one of them from last Tuesday.
  *
  * So they are printed together, in the order you would want them in a binder:
- * what the room looks like, what happens when, who is doing what, and who to
- * photograph.
+ * what the room looks like, what happens when, who walks down the aisle, who
+ * is doing what, what is packed where, and who to photograph. The processional
+ * and the packing list are Ceremony's and Boxes', and are in the pack only
+ * once there is one.
  *
  * The place cards are deliberately not here. They print on 85×55 card stock
  * through a sheet layout of their own, and an A4 binder and a tray of card are
diff --git a/suite/lib/library/items.test.ts b/suite/lib/library/items.test.ts
index 674c665c..c23325ee 100644
--- a/suite/lib/library/items.test.ts
+++ b/suite/lib/library/items.test.ts
@@ -2,7 +2,7 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, it } from "vitest";
-import { applyTo, extract } from "./items";
+import { adds, applyTo, extract } from "./items";
 
 const example = JSON.parse(readFileSync(join(process.cwd(), "public", "fixtures", "example-wedding.trousseau.json"), "utf8"));
 const names = Object.values(example.guests as Record<string, { firstName: string; lastName: string }>).flatMap((guest) => [
@@ -77,3 +77,139 @@ describe("putting it into another wedding", () => {
     expect(crew.jobs.find((job) => job.label === "Order the cake")?.dueOn).toBe("2029-05-04");
   });
 });
+
+describe("a processional", () => {
+  const withGuestWalking = {
+    ...example,
+    ceremony: {
+      processional: [
+        ...(example.ceremony.processional as object[]),
+        {
+          id: "walk-extra",
+          label: "",
+          members: [
+            { kind: "guest", ref: Object.keys(example.guests)[0] },
+            { kind: "customRole", ref: "crole-readers" },
+            { kind: "family", ref: "fam-1" },
+            { kind: "role", ref: "b-grandparents" },
+          ],
+          formation: "pairs",
+          side: "b",
+          music: "",
+          cue: "",
+        },
+      ],
+    },
+  };
+
+  it("is kept by roles, words and music, with nobody named and nothing of this wedding's own", () => {
+    const kept = extract("processional", withGuestWalking)!;
+    const groups = kept["processional"] as Array<{ members: Array<{ kind: string }> }>;
+    expect(groups).toHaveLength(7);
+    expect(groups[5]).toMatchObject({ formation: "pairs", side: "", music: "The Arrival of the Queen of Sheba" });
+    expect(groups[6]!.members).toEqual([{ kind: "role", ref: "b-grandparents" }]);
+    expect(groups.flatMap((group) => group.members).every((member) => member.kind === "role" || member.kind === "text")).toBe(true);
+    expect(JSON.stringify(kept)).not.toContain('"id"');
+    expect(mentionsAnyGuest(kept)).toEqual([]);
+  });
+
+  it("is nothing to keep from a wedding with no processional", () => {
+    expect(extract("processional", { ...example, ceremony: { processional: [] } })).toBeNull();
+  });
+
+  it("goes into another wedding as its processional, each group with an id of its own", () => {
+    const kept = extract("processional", example)!;
+    const [[slice, value]] = applyTo("processional", kept, { ceremony: { processional: [{ id: "old" }] } }) as [[string, { processional: Array<{ id: string }> }]];
+    expect(slice).toBe("ceremony");
+    expect(value.processional).toHaveLength(6);
+    expect(new Set(value.processional.map((group) => group.id)).size).toBe(6);
+    expect(value.processional.map((group) => group.id)).not.toContain("old");
+  });
+});
+
+describe("a set of boxes", () => {
+  it("is kept as its boxes and what goes in each: not who takes them, when, what is packed or its notes", () => {
+    const kept = extract("boxes", example)!;
+    const boxes = kept["boxes"] as Array<Record<string, unknown>>;
+    expect(boxes).toHaveLength(4);
+    expect(boxes[1]).toEqual({
+      number: 2,
+      name: "Getting ready",
+      items: [
+        { label: "Outfits, on hangers", quantity: 2 },
+        { label: "Shoes", quantity: 2 },
+        { label: "Steamer", quantity: 1 },
+        { label: "Emergency kit: plasters, safety pins, needle and thread, painkillers", quantity: 1 },
+        { label: "Phone chargers", quantity: 2 },
+      ],
+    });
+    const text = JSON.stringify(kept);
+    for (const gone of ['"personIds"', '"blockId"', '"packed"', '"notes"', '"id"', "best man"]) expect(text).not.toContain(gone);
+    expect(mentionsAnyGuest(kept)).toEqual([]);
+  });
+
+  it("adds to a wedding the boxes it has none of by name, numbered on, with nothing packed, and asks nothing first", () => {
+    const kept = extract("boxes", example)!;
+    const into = { boxes: { boxes: [{ id: "mine", number: 7, name: "getting ready", items: [] }] } };
+    const [[slice, value]] = applyTo("boxes", kept, into) as [[string, { boxes: Array<Record<string, unknown>> }]];
+    expect(slice).toBe("boxes");
+    expect(value.boxes.map((box) => `${box["number"]} ${box["name"]}`)).toEqual([
+      "7 getting ready",
+      "8 The rings and the paperwork",
+      "9 The day's odds and ends",
+      "10 Overnight and the day after",
+    ]);
+    const items = value.boxes.slice(1).flatMap((box) => box["items"] as Array<{ id: string; packed: boolean }>);
+    expect(items.every((item) => item.packed === false && typeof item.id === "string")).toBe(true);
+    expect(adds("boxes")).toBe(true);
+    expect(adds("room")).toBe(false);
+  });
+});
+
+describe("bar settings", () => {
+  const settled = {
+    ...example,
+    bar: {
+      ...example.bar,
+      kind: "beer-and-wine",
+      people: 120,
+      figures: { eveningGuests: 30, eveningHours: 5 },
+      lines: { fizz: { price: 8.5, have: 12, shop: "supermarket" }, spirits: { have: 2 } },
+      unknown: "from a newer build",
+    },
+  };
+
+  it("are kept without the guest count, the evening guests or what the couple already has", () => {
+    expect(extract("bar", settled)).toEqual({
+      kind: "beer-and-wine",
+      crowd: "usual",
+      figures: { eveningHours: 5 },
+      mix: {},
+      lines: { fizz: { price: 8.5, shop: "supermarket" } },
+      wholeCases: true,
+    });
+  });
+
+  it("are nothing to keep from a wedding that changed nothing", () => {
+    expect(extract("bar", { ...example, bar: {} })).toBeNull();
+    // Only a guest count and evening guests: nothing another wedding could use.
+    expect(extract("bar", { ...example, bar: { people: 80, figures: { eveningGuests: 20 } } })).toBeNull();
+  });
+
+  it("replace this wedding's, keeping its head count, its evening guests and what it already has", () => {
+    const kept = extract("bar", settled)!;
+    const into = { bar: { kind: "cocktails", people: 60, figures: { eveningGuests: 10, toastGlasses: 2 }, lines: { ice: { have: 20 }, red: { price: 9 } } } };
+    const [[slice, value]] = applyTo("bar", kept, into) as [[string, Record<string, unknown>]];
+    expect(slice).toBe("bar");
+    expect(value).toEqual({
+      kind: "beer-and-wine",
+      crowd: "usual",
+      people: 60,
+      figures: { eveningHours: 5, eveningGuests: 10 },
+      mix: {},
+      lines: { fizz: { price: 8.5, shop: "supermarket" }, ice: { have: 20 } },
+      wholeCases: true,
+    });
+    expect(adds("bar")).toBe(false);
+  });
+});
diff --git a/suite/lib/library/items.ts b/suite/lib/library/items.ts
index 30755087..99fc1b7e 100644
--- a/suite/lib/library/items.ts
+++ b/suite/lib/library/items.ts
@@ -1,18 +1,28 @@
-import type { SliceName } from "@jfrusher/trousseau";
+import { migrate, type SliceName } from "@jfrusher/trousseau";
+import { choices } from "@/lib/bar/actions";
 import { daysUntil } from "@/lib/dates";
+import { emptyBar, readBar } from "@/lib/model/slices";
 
 /**
  * What a planner keeps from one wedding to use in another, and how it goes
  * into the next: a card design without its rows, a running order without its
  * date or its suppliers' numbers, a room without its guests, a checklist
- * without its dates — each task kept as so many days before the day.
+ * without its dates — each task kept as so many days before the day — a
+ * processional with its roles and music and nobody named, a set of boxes
+ * with what goes in each, but not who takes them or when, and bar settings
+ * without the guest count or what a couple already has.
  *
  * Nothing personal leaves a wedding this way. Each kind is built from a
  * whitelist of what it is, never by removing what it is not, so a field a tool
  * adds later stays out until someone decides it belongs.
  */
 
-export const KINDS = ["cards", "day", "room", "checklist"] as const;
+export const KINDS = ["cards", "day", "room", "checklist", "processional", "boxes", "bar"] as const;
+
+/** Kinds that add to a wedding rather than replace what it has, so ask nothing first. */
+const ADDING = ["checklist", "boxes"] as const satisfies readonly Kind[];
+export type Adding = (typeof ADDING)[number];
+export const adds = (kind: Kind): kind is Adding => (ADDING as readonly Kind[]).includes(kind);
 export type Kind = (typeof KINDS)[number];
 
 export const KIND_NAMES: Record<Kind, string> = {
@@ -20,6 +30,9 @@ export const KIND_NAMES: Record<Kind, string> = {
   day: "Running order",
   room: "Room",
   checklist: "Checklist",
+  processional: "Processional",
+  boxes: "Boxes",
+  bar: "Bar settings",
 };
 
 type Raw = Record<string, unknown>;
@@ -88,6 +101,49 @@ export function extract(kind: Kind, raw: Raw): Raw | null {
         });
       return tasks.length > 0 ? { tasks } : null;
     }
+    case "processional": {
+      const groups = Array.isArray(record(raw["ceremony"])["processional"]) ? (record(raw["ceremony"])["processional"] as unknown[]) : [];
+      if (groups.length === 0) return null;
+      return {
+        processional: groups.map(record).map((group) => ({
+          ...pick(group, ["label", "formation", "side", "music", "cue"]),
+          // Who walks by what they are to the couple, or by the words typed
+          // for them: never a guest, a family, a group or a role of this
+          // wedding's own devising, none of which exist in another wedding.
+          members: (Array.isArray(group["members"]) ? (group["members"] as unknown[]) : [])
+            .map(record)
+            .filter((member) => member["kind"] === "role" || member["kind"] === "text")
+            .map((member) => pick(member, ["kind", "ref"])),
+        })),
+      };
+    }
+    case "bar": {
+      // Read through the Bar's own reader, so only figures, shares, prices
+      // and shops it knows are kept. Not how many are coming, the evening
+      // guests or what this couple already has: those are this wedding's.
+      const bar = readBar(migrate(raw));
+      const { eveningGuests: _eveningGuests, ...figures } = bar.figures;
+      const lines = Object.fromEntries(
+        Object.entries(bar.lines)
+          .map(([line, choice]) => [line, pick(choice as Raw, ["price", "shop"])] as const)
+          .filter(([, choice]) => Object.keys(choice).length > 0),
+      );
+      const kept = { kind: bar.kind, crowd: bar.crowd, figures, mix: bar.mix, lines, wholeCases: bar.wholeCases };
+      return choices({ ...emptyBar(), ...kept }) === 0 ? null : kept;
+    }
+    case "boxes": {
+      const boxes = Array.isArray(record(raw["boxes"])["boxes"]) ? (record(raw["boxes"])["boxes"] as unknown[]) : [];
+      if (boxes.length === 0) return null;
+      return {
+        // What each box is and what goes in it. Not who takes it, which part
+        // of the day it is for, what is packed or its notes: those are this
+        // wedding's.
+        boxes: boxes.map(record).map((box) => ({
+          ...pick(box, ["number", "name"]),
+          items: (Array.isArray(box["items"]) ? (box["items"] as unknown[]) : []).map(record).map((item) => pick(item, ["label", "quantity"])),
+        })),
+      };
+    }
   }
 }
 
@@ -146,5 +202,57 @@ export function applyTo(kind: Kind, content: Raw, raw: Raw): Array<[SliceName, u
         }));
       return [["crew", { ...crew, jobs: [...jobs, ...added] }]];
     }
+    case "boxes": {
+      // Added, as the usual boxes are: only boxes this wedding has no box of
+      // that name for, numbered on from its highest, nothing yet packed.
+      const current = record(raw["boxes"]);
+      const boxes = Array.isArray(current["boxes"]) ? (current["boxes"] as Raw[]) : [];
+      const have = new Set(boxes.map((box) => String(box["name"] ?? "").trim().toLowerCase()));
+      let number = boxes.reduce((highest, box) => Math.max(highest, typeof box["number"] === "number" ? box["number"] : 0), 0);
+      const added = (content["boxes"] as Raw[])
+        .filter((box) => !have.has(String(box["name"] ?? "").trim().toLowerCase()))
+        .map((box) => ({
+          id: newId("box"),
+          number: ++number,
+          name: box["name"],
+          items: (box["items"] as Raw[]).map((item) => ({ id: newId("item"), label: item["label"], quantity: item["quantity"], packed: false })),
+          blockId: null,
+          personIds: [],
+          notes: "",
+        }));
+      return [["boxes", { ...current, boxes: [...boxes, ...added] }]];
+    }
+    case "bar": {
+      // The settings replace this wedding's; its head count, its evening
+      // guests and what it already has stay.
+      const current = readBar(migrate(raw));
+      const evening = current.figures.eveningGuests;
+      const lines = { ...(content["lines"] as Raw) };
+      for (const [line, choice] of Object.entries(current.lines)) {
+        if (choice.have !== undefined) lines[line] = { ...record(lines[line]), have: choice.have };
+      }
+      return [
+        [
+          "bar",
+          {
+            ...record(raw["bar"]),
+            ...content,
+            people: current.people,
+            figures: { ...(content["figures"] as Raw), ...(evening === undefined ? {} : { eveningGuests: evening }) },
+            lines,
+          },
+        ],
+      ];
+    }
+    case "processional":
+      return [
+        [
+          "ceremony",
+          {
+            ...record(raw["ceremony"]),
+            processional: (content["processional"] as Raw[]).map((group) => ({ ...group, id: newId("walk") })),
+          },
+        ],
+      ];
   }
 }
diff --git a/suite/lib/library/migrations.test.ts b/suite/lib/library/migrations.test.ts
index cdfb0442..53d86652 100644
--- a/suite/lib/library/migrations.test.ts
+++ b/suite/lib/library/migrations.test.ts
@@ -45,11 +45,15 @@ test("a saved design is removed, never edited in place", async () => {
   expect((await db.query("delete from library_items where id = $1", [id])).affectedRows).toBe(1);
 });
 
-test("a name is required, and only the four kinds are kept", async () => {
+test("a name is required, and only the seven kinds are kept", async () => {
   const planner = await userExists(db, "planner@example.com");
   await actAs(db, planner);
   await expect(save(planner, "")).rejects.toThrow();
   await expect(
     db.query("insert into library_items (owner, kind, name, content) values ($1, 'guests', 'All of them', '{}')", [planner]),
   ).rejects.toThrow();
+  await db.query("insert into library_items (owner, kind, name, content) values ($1, 'processional', 'Church, both sides', '{}')", [planner]);
+  await db.query("insert into library_items (owner, kind, name, content) values ($1, 'boxes', 'For a barn', '{}')", [planner]);
+  await db.query("insert into library_items (owner, kind, name, content) values ($1, 'bar', 'Beer and wine, a heavy crowd', '{}')", [planner]);
+  expect((await db.query("select kind from library_items order by kind")).rows).toEqual([{ kind: "bar" }, { kind: "boxes" }, { kind: "processional" }]);
 });
diff --git a/suite/lib/model/content.test.ts b/suite/lib/model/content.test.ts
index b8f94389..6afe1034 100644
--- a/suite/lib/model/content.test.ts
+++ b/suite/lib/model/content.test.ts
@@ -25,6 +25,7 @@ test.each([
   ["a guest", { guests: { g1: { id: "g1", firstName: "Ann" } } }],
   ["a group shot", { shots: { ...empty.shots, sections: [{ id: "s", name: "Family", shots: [{ id: "x", label: "", members: [], notes: "" }] }] } }],
   ["a crew member", { crew: { teams: [], people: [{ id: "p1", name: "Jo" }], jobs: [], budget: null } }],
+  ["a group in the processional", { ceremony: { processional: [{ id: "w1", label: "", members: [] }] } }],
 ])("%s is content", (_, part) => {
   expect(hasContent(summarise({ ...empty, ...part }))).toBe(true);
 });
diff --git a/suite/lib/model/content.ts b/suite/lib/model/content.ts
index f9aa477c..631d966c 100644
--- a/suite/lib/model/content.ts
+++ b/suite/lib/model/content.ts
@@ -1,5 +1,6 @@
 import { migrate } from "@jfrusher/trousseau";
-import { readCrew, readGuests, readSeating, readShots } from "./slices";
+import { choices } from "@/lib/bar/actions";
+import { readBar, readBoxes, readCeremony, readCrew, readGuests, readSeating, readShots } from "./slices";
 
 /**
  * What a wedding holds, in the terms a person would recognise it by.
@@ -19,6 +20,11 @@ export interface WeddingSummary {
   crew: number;
   jobs: number;
   shots: number;
+  /** Groups in the processional. */
+  walking: number;
+  boxes: number;
+  /** Things chosen on the Bar: a figure changed, a price typed. */
+  bar: number;
   /** Names on a card design that came from a file rather than the room. */
   cards: number;
 }
@@ -37,6 +43,9 @@ export function summarise(raw: unknown): WeddingSummary {
     crew: crew.people.length,
     jobs: crew.jobs.length,
     shots: readShots(doc).sections.reduce((sum, section) => sum + section.shots.length, 0),
+    walking: readCeremony(doc).processional.length,
+    boxes: readBoxes(doc).boxes.length,
+    bar: choices(readBar(doc)),
     cards: Array.isArray(stationery.rows) ? stationery.rows.length : 0,
   };
 }
@@ -58,6 +67,9 @@ export function describe(summary: WeddingSummary): string {
     summary.crew && plural(summary.crew, "person", "people") + " in the crew",
     summary.jobs && plural(summary.jobs, "job"),
     summary.shots && plural(summary.shots, "group shot"),
+    summary.walking && `${plural(summary.walking, "group")} in the processional`,
+    summary.boxes && plural(summary.boxes, "box", "boxes"),
+    summary.bar && plural(summary.bar, "choice", "choices") + " for the bar",
   ].filter(Boolean);
   const name = summary.names || "A wedding with no names yet";
   return parts.length > 0 ? `${name} — ${parts.join(", ")}` : name;
diff --git a/suite/lib/model/overview.test.ts b/suite/lib/model/overview.test.ts
index 55f8c990..9417b10c 100644
--- a/suite/lib/model/overview.test.ts
+++ b/suite/lib/model/overview.test.ts
@@ -29,6 +29,13 @@ describe("the front page's measures", () => {
     expect(areas["group-shots"].summary).toBe("26 shots");
     // Nineteen tasks before the day, seven of them done.
     expect(areas.checklist).toMatchObject({ summary: "12 to do", detail: "7 done" });
+    // 100 coming and 30 for the evening; fizz, wine and beer priced, and 4 lines not.
+    expect(areas.bar).toMatchObject({ summary: "Drinks for 100, and 30 in the evening", detail: "About 1,206, 4 lines with no price" });
+  });
+
+  it("leaves out the areas of tools the wedding does not show, and always keeps the guests", () => {
+    const removed = { ...raw, tools: { shown: ["timeline", "money"] } };
+    expect(overview(migrate(removed), removed).map((area) => area.id)).toEqual(["guests", "money", "timeline"]);
   });
 
   it("says there is nothing yet, rather than that nothing is wrong, on an empty wedding", () => {
diff --git a/suite/lib/model/overview.ts b/suite/lib/model/overview.ts
index a11de208..728d1fe8 100644
--- a/suite/lib/model/overview.ts
+++ b/suite/lib/model/overview.ts
@@ -1,11 +1,14 @@
 import type { Trousseau } from "@jfrusher/trousseau";
 import { formatClock } from "@/apps/cadence/core/time/minutes";
-import { resolveShot } from "@/lib/ensemble/resolve";
+import { resolveMembers } from "@/lib/cast/resolve";
 import { money } from "@/lib/money/money";
 import { todayIso } from "@/lib/dates";
 import { checklist } from "@/lib/checklist/checklist";
 import { stationery } from "./readiness";
-import { isComing, readCrew, readGuests, readSeating, readShots, resolvedDay } from "./slices";
+import { isComing, readBoxes, readCast, readCeremony, readCrew, readGuests, readSeating, readShots, resolvedDay } from "./slices";
+import { dayPlaces, neededAt, packingOf } from "@/lib/boxes/view";
+import { hiddenToolIds } from "./toolbox";
+import { barSum } from "@/lib/bar/sum";
 
 /**
  * How far along each part of the wedding is, for the front page.
@@ -15,7 +18,18 @@ import { isComing, readCrew, readGuests, readSeating, readShots, resolvedDay } f
  * how much of it is done, so the page reads as the wedding's state rather than
  * as a list of ways into it.
  */
-export type AreaId = "guests" | "money" | "checklist" | "seating" | "place-cards" | "timeline" | "delegation" | "group-shots";
+export type AreaId =
+  | "guests"
+  | "money"
+  | "checklist"
+  | "seating"
+  | "place-cards"
+  | "timeline"
+  | "delegation"
+  | "group-shots"
+  | "ceremony"
+  | "boxes"
+  | "bar";
 
 export interface Area {
   id: AreaId;
@@ -145,12 +159,13 @@ function delegation(doc: Trousseau): Area {
 
 function groupShots(doc: Trousseau): Area {
   const shots = readShots(doc);
+  const cast = readCast(doc);
   const all = shots.sections.flatMap((section) => section.shots);
   if (all.length === 0) return { id: "group-shots", summary: "No shots yet", detail: "", progress: null };
   const guestList = readGuests(doc);
   const room = readSeating(doc);
   const troubled = all.filter(
-    (shot) => resolveShot(shot, guestList, room, shots.cast, shots.customRoles, doc.event).problems.length > 0,
+    (shot) => resolveMembers(shot, guestList, room, cast.roles, cast.customRoles, doc.event).problems.length > 0,
   ).length;
   return {
     id: "group-shots",
@@ -160,6 +175,53 @@ function groupShots(doc: Trousseau): Area {
   };
 }
 
+function ceremony(doc: Trousseau): Area {
+  const processional = readCeremony(doc).processional;
+  if (processional.length === 0) return { id: "ceremony", summary: "No processional yet", detail: "", progress: null };
+  const guestList = readGuests(doc);
+  const room = readSeating(doc);
+  const cast = readCast(doc);
+  const troubled = processional.filter(
+    (group) => resolveMembers(group, guestList, room, cast.roles, cast.customRoles, doc.event).problems.length > 0,
+  ).length;
+  return {
+    id: "ceremony",
+    summary: plural(processional.length, "group walking", "groups walking"),
+    detail: troubled > 0 ? `${troubled} to look at` : "",
+    progress: null,
+  };
+}
+
+function boxes(doc: Trousseau): Area {
+  const all = readBoxes(doc);
+  if (all.boxes.length === 0) return { id: "boxes", summary: "No boxes yet", detail: "", progress: null };
+  const { packed, total } = packingOf(all);
+  const known = dayPlaces(doc);
+  const lost = all.boxes.filter((box) => neededAt(box, known).lost).length;
+  return {
+    id: "boxes",
+    summary: plural(all.boxes.length, "box", "boxes"),
+    detail: [total > 0 ? `${packed} of ${total} packed` : "Nothing in them yet", lost > 0 ? `${lost} to look at` : ""].filter(Boolean).join(" · "),
+    progress: total > 0 ? packed / total : null,
+  };
+}
+
+function bar(doc: Trousseau): Area {
+  const { heads, spend, unpriced } = barSum(doc);
+  if (heads.people + heads.evening === 0) return { id: "bar", summary: "No guests to buy for yet", detail: "", progress: null };
+  const priced = spend > 0 ? `About ${Math.round(spend).toLocaleString()}${unpriced > 0 ? `, ${plural(unpriced, "line", "lines")} with no price` : ""}` : "No prices yet";
+  return {
+    id: "bar",
+    summary: `Drinks for ${heads.people}${heads.evening > 0 ? `, and ${heads.evening} in the evening` : ""}`,
+    detail: priced,
+    progress: null,
+  };
+}
+
+/** Every area, less those of the tools the wedding has removed. */
 export function overview(doc: Trousseau, raw: unknown, today: string = todayIso()): Area[] {
-  return [guests(doc), costs(doc), tasks(doc, today), seating(doc), placeCards(doc, raw), timeline(doc), delegation(doc), groupShots(doc)];
+  const hidden = hiddenToolIds(doc);
+  return [guests(doc), costs(doc), tasks(doc, today), seating(doc), placeCards(doc, raw), timeline(doc), delegation(doc), groupShots(doc), ceremony(doc), boxes(doc), bar(doc)].filter(
+    (area) => !hidden.has(area.id),
+  );
 }
diff --git a/suite/lib/model/partners.ts b/suite/lib/model/partners.ts
index 941d6cda..63024b56 100644
--- a/suite/lib/model/partners.ts
+++ b/suite/lib/model/partners.ts
@@ -52,13 +52,14 @@ export function sideShort(side: Exclude<Side, "">, event: Pick<WeddingEvent, "pa
   return "Both";
 }
 
-/** A group-shot role in words: "Alex", "Sam’s mother", "Alex’s wedding party". */
+/** A role in words: "Alex", "Sam’s mother", "Sam’s grandparents", "Alex’s wedding party". */
 export function roleLabel(role: CastRole, event: Pick<WeddingEvent, "partners">): string {
   const [a, b] = partnerNames(event);
   const name = role.startsWith("a") ? a : b;
   if (role === "a" || role === "b") return name;
   if (role.endsWith("-mother")) return `${possessive(name)} mother`;
   if (role.endsWith("-father")) return `${possessive(name)} father`;
+  if (role.endsWith("-grandparents")) return `${possessive(name)} grandparents`;
   return `${possessive(name)} wedding party`;
 }
 
diff --git a/suite/lib/model/readiness.test.ts b/suite/lib/model/readiness.test.ts
index 874162c4..057df514 100644
--- a/suite/lib/model/readiness.test.ts
+++ b/suite/lib/model/readiness.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it } from "vitest";
 import { emptyTrousseau, migrate } from "@jfrusher/trousseau";
 import { readiness } from "./readiness";
+import { TOOLS } from "@/lib/tools";
 
 /**
  * These only fire on the gaps between tools, so what is worth holding is that
@@ -8,8 +9,11 @@ import { readiness } from "./readiness";
  * are not so eager they fire on a wedding nobody has started yet.
  */
 
+// Every tool shown, so each check here is heard; what hiding a tool does has tests of its own.
+const EVERY_TOOL = { tools: { shown: TOOLS.map((tool) => tool.id) } };
+
 const wedding = (raw: Record<string, unknown>) => {
-  const full = { ...emptyTrousseau(), ...raw };
+  const full = { ...emptyTrousseau(), ...EVERY_TOOL, ...raw };
   return readiness(migrate(full), full);
 };
 
@@ -41,6 +45,24 @@ describe("what is left to do", () => {
     expect(ids({ guests: { g1: { id: "g1", firstName: "Charis" } } })).toEqual([]);
   });
 
+  it("says nothing of money or tasks to a wedding that has never added Money or the Checklist", () => {
+    const crew = {
+      teams: [{ id: "tm1", name: "Florist", cost: 500, deposit: null, balanceDueOn: "2000-01-01", balancePaidOn: "" }],
+      people: [],
+      jobs: [{ id: "j1", blockId: null, label: "Book the cars", personIds: [], status: "todo", dueOn: "2000-01-01" }],
+    };
+    const left = (raw: Record<string, unknown>) => wedding(raw).map((item) => item.href);
+    expect(left({ guests: GUESTS, ...TABLES, crew })).toEqual(expect.arrayContaining(["/money", "/checklist"]));
+    expect(left({ guests: GUESTS, ...TABLES, crew, tools: {} })).toEqual([]);
+  });
+
+  it("says nothing about a tool the wedding has removed", () => {
+    const guests = { ...GUESTS, g2: { id: "g2", firstName: "Tobias", rsvpStatus: "confirmed" } };
+    const inSeating = (raw: Record<string, unknown>) => wedding(raw).filter((item) => item.href === "/seating");
+    expect(inSeating({ guests, ...TABLES })).not.toEqual([]);
+    expect(inSeating({ guests, ...TABLES, tools: { shown: ["timeline"] } })).toEqual([]);
+  });
+
   describe("place cards against the room", () => {
     const design = (extra: Record<string, unknown>) => ({
       guests: GUESTS,
@@ -179,7 +201,7 @@ describe("jobs with nobody on them", () => {
 
 describe("the checklist", () => {
   const on = (today: string, jobs: unknown[]) => {
-    const full = { ...emptyTrousseau(), guests: GUESTS, crew: { jobs } };
+    const full = { ...emptyTrousseau(), ...EVERY_TOOL, guests: GUESTS, crew: { jobs } };
     return readiness(migrate(full), full, today).find((entry) => entry.id === "tasks-overdue");
   };
 
@@ -201,6 +223,7 @@ describe("payments", () => {
   const on = (today: string, balanceDueOn: string, balancePaidOn = "") => {
     const full = {
       ...emptyTrousseau(),
+      ...EVERY_TOOL,
       guests: GUESTS,
       crew: { teams: [{ id: "t1", name: "Granary Kitchen", cost: 9400, deposit: 2000, balanceDueOn, balancePaidOn }] },
     };
@@ -274,3 +297,44 @@ describe("money and confirmations", () => {
     ).not.toContain("unconfirmed-teams");
   });
 });
+
+describe("the processional", () => {
+  const walking = (members: unknown[]) => ({ ceremony: { processional: [{ id: "w1", members }] } });
+
+  it("says when it names a role nobody is cast in", () => {
+    const found = wedding({ guests: GUESTS, ...TABLES, ...walking([{ kind: "role", ref: "a-mother" }]) });
+    expect(found.find((item) => item.id === "ceremony-dangling")).toMatchObject({ severity: "blocking", href: "/ceremony" });
+  });
+
+  it("says nothing when everybody in it is somebody", () => {
+    const cast = { cast: { roles: { "a-mother": ["g1"] }, customRoles: [] } };
+    expect(ids({ guests: GUESTS, ...TABLES, ...cast, ...walking([{ kind: "role", ref: "a-mother" }]) })).not.toContain("ceremony-dangling");
+  });
+
+  it("says nothing while Ceremony is not one of the wedding's tools", () => {
+    const hidden = { tools: { shown: ["seating"] } };
+    expect(ids({ guests: GUESTS, ...TABLES, ...hidden, ...walking([{ kind: "role", ref: "a-mother" }]) })).not.toContain("ceremony-dangling");
+  });
+});
+
+describe("the boxes", () => {
+  const boxesNeededAt = (blockId: string | null, packed = false) => ({
+    boxes: { boxes: [{ id: "b1", number: 1, name: "Getting ready", blockId, personIds: [], items: [{ id: "i1", label: "Shoes", quantity: 1, packed }] }] },
+  });
+  const onDay = (today: string, raw: Record<string, unknown>) => {
+    const full = { ...emptyTrousseau(), ...EVERY_TOOL, guests: GUESTS, event: { ...emptyTrousseau().event, date: "2028-06-01" }, ...raw };
+    return readiness(migrate(full), full, today).map((item) => item.id);
+  };
+
+  it("says when a box is needed for a part of the day the Timeline no longer has", () => {
+    expect(onDay("2028-01-01", boxesNeededAt("blk-gone"))).toContain("boxes-lost");
+    expect(onDay("2028-01-01", boxesNeededAt(null))).not.toContain("boxes-lost");
+  });
+
+  it("says there is packing left only in the last week, and not once it is done or the day has passed", () => {
+    expect(onDay("2028-05-01", boxesNeededAt(null))).not.toContain("boxes-unpacked");
+    expect(onDay("2028-05-28", boxesNeededAt(null))).toContain("boxes-unpacked");
+    expect(onDay("2028-05-28", boxesNeededAt(null, true))).not.toContain("boxes-unpacked");
+    expect(onDay("2028-06-02", boxesNeededAt(null))).not.toContain("boxes-unpacked");
+  });
+});
diff --git a/suite/lib/model/readiness.ts b/suite/lib/model/readiness.ts
index fee4e3b2..0d49d658 100644
--- a/suite/lib/model/readiness.ts
+++ b/suite/lib/model/readiness.ts
@@ -1,6 +1,8 @@
 import type { Trousseau } from "@jfrusher/trousseau";
-import { guestName, isComing, readCrew, readGuests, readSeating, readShots, readTimeline } from "./slices";
-import { resolveShot } from "@/lib/ensemble/resolve";
+import { guestName, isComing, readBoxes, readCast, readCeremony, readCrew, readGuests, readSeating, readShots, readTimeline } from "./slices";
+import { dayPlaces, neededAt, packingOf } from "@/lib/boxes/view";
+import { hiddenToolIds } from "./toolbox";
+import { resolveMembers } from "@/lib/cast/resolve";
 import { DUE_SOON_DAYS, money } from "@/lib/money/money";
 import { daysUntil, longDate, todayIso } from "@/lib/dates";
 import { checklist } from "@/lib/checklist/checklist";
@@ -25,12 +27,25 @@ import { checklist } from "@/lib/checklist/checklist";
 
 export type Severity = "blocking" | "advisory";
 
+/** How close to the day unpacked boxes are worth saying so. */
+export const PACKING_DAYS = 7;
+
 export interface Readiness {
   id: string;
   severity: Severity;
   message: string;
   /** Where the fix is, so a row can take you there. */
-  href: "/guests" | "/money" | "/checklist" | "/seating" | "/place-cards" | "/timeline" | "/delegation" | "/group-shots";
+  href:
+    | "/guests"
+    | "/money"
+    | "/checklist"
+    | "/seating"
+    | "/place-cards"
+    | "/timeline"
+    | "/delegation"
+    | "/group-shots"
+    | "/ceremony"
+    | "/boxes";
   action: string;
 }
 
@@ -225,9 +240,10 @@ export function readiness(doc: Trousseau, raw: unknown, today: string = todayIso
    * double-reporting this module exists to avoid.
    */
   const shots = readShots(doc);
+  const cast = readCast(doc);
   const dangling = shots.sections
     .flatMap((section) => section.shots)
-    .flatMap((shot) => resolveShot(shot, guests, seating, shots.cast, shots.customRoles, doc.event).problems)
+    .flatMap((shot) => resolveMembers(shot, guests, seating, cast.roles, cast.customRoles, doc.event).problems)
     .filter((problem) => problem.kind === "dangling").length;
 
   if (dangling > 0) {
@@ -243,6 +259,58 @@ export function readiness(doc: Trousseau, raw: unknown, today: string = todayIso
     });
   }
 
+  // The same for the processional, read from the same cast.
+  const walkingNobody = readCeremony(doc)
+    .processional.flatMap((group) => resolveMembers(group, guests, seating, cast.roles, cast.customRoles, doc.event).problems)
+    .filter((problem) => problem.kind === "dangling").length;
+
+  if (walkingNobody > 0) {
+    out.push({
+      id: "ceremony-dangling",
+      severity: "blocking",
+      message:
+        walkingNobody === 1
+          ? "The processional names someone who is not set, or no longer exists."
+          : `The processional names ${walkingNobody} people or roles who are not set, or no longer exist.`,
+      href: "/ceremony",
+      action: "Fix the processional",
+    });
+  }
+
+  // A box needed for a block the day no longer has: its label would say
+  // neither where nor when. The Timeline changed, and Boxes cannot see that.
+  const boxes = readBoxes(doc);
+  const known = dayPlaces(doc);
+  const lost = boxes.boxes.filter((box) => neededAt(box, known).lost).length;
+  if (lost > 0) {
+    out.push({
+      id: "boxes-lost",
+      severity: "blocking",
+      message:
+        lost === 1
+          ? "A box is needed for a part of the day that is no longer on the Timeline."
+          : `${lost} boxes are needed for parts of the day that are no longer on the Timeline.`,
+      href: "/boxes",
+      action: "Say where they are needed",
+    });
+  }
+
+  // The last week: packing is a thing done before the day, like a task.
+  const daysToGo = doc.event.date ? daysUntil(doc.event.date, today) : null;
+  const { packed, total } = packingOf(boxes);
+  if (daysToGo !== null && daysToGo >= 0 && daysToGo <= PACKING_DAYS && packed < total) {
+    const left = total - packed;
+    out.push({
+      id: "boxes-unpacked",
+      severity: "advisory",
+      message: `${left} ${left === 1 ? "thing is" : "things are"} still to pack, and the day is ${
+        daysToGo === 0 ? "today" : daysToGo === 1 ? "tomorrow" : `in ${daysToGo} days`
+      }.`,
+      href: "/boxes",
+      action: "Finish packing",
+    });
+  }
+
   const accounts = money(crew);
   if (accounts.budget !== null && accounts.left !== null && accounts.left < 0) {
     out.push({
@@ -317,5 +385,9 @@ export function readiness(doc: Trousseau, raw: unknown, today: string = todayIso
     });
   }
 
-  return out;
+  // A tool the wedding has removed is one it is not using: nothing in it is
+  // left to do. Here rather than in the page, so the planner's Weddings page,
+  // which runs this on the server, says the same.
+  const hidden = hiddenToolIds(doc);
+  return out.filter((item) => !hidden.has(item.href.slice(1)));
 }
diff --git a/suite/lib/model/selectors.test.ts b/suite/lib/model/selectors.test.ts
index a9451e45..82fb7b8b 100644
--- a/suite/lib/model/selectors.test.ts
+++ b/suite/lib/model/selectors.test.ts
@@ -1,6 +1,8 @@
 import { expect, test } from "vitest";
 import { emptyTrousseau, migrate } from "@jfrusher/trousseau";
-import { readCrew, readGuests, readSeating, readShots, readTimeline, resolvedDay, timelineDoc } from "./slices";
+import { readBar, readBoxes, readCast, readCeremony, readCrew, readGuests, readSeating, readShots, readTimeline, resolvedDay, timelineDoc } from "./slices";
+import { hiddenToolIds, shownTools } from "./toolbox";
+import { barSum } from "@/lib/bar/sum";
 
 /**
  * Every slice reader must return the same object for the same document.
@@ -20,6 +22,7 @@ const doc = migrate({
   crew: { teams: [], people: [], jobs: [] },
   shots: { cast: {}, sections: [{ id: "sec1", name: "Family", shots: [] }] },
   stationery: { rowSource: "plan" },
+  tools: { shown: ["seating", "timeline"] },
 });
 
 test.each([
@@ -28,8 +31,15 @@ test.each([
   ["timeline", () => readTimeline(doc)],
   ["crew", () => readCrew(doc)],
   ["shots", () => readShots(doc)],
+  ["cast", () => readCast(doc)],
+  ["ceremony", () => readCeremony(doc)],
+  ["boxes", () => readBoxes(doc)],
+  ["bar", () => readBar(doc)],
+  ["the bar's sum", () => barSum(doc)],
   ["timelineDoc", () => timelineDoc(doc)],
   ["resolved day", () => resolvedDay(doc)],
+  ["shown tools", () => shownTools(doc)],
+  ["hidden tools", () => hiddenToolIds(doc)],
 ])("reading %s twice returns the same object", (_name, read) => {
   expect(read()).toBe(read());
 });
diff --git a/suite/lib/model/slices.test.ts b/suite/lib/model/slices.test.ts
index c642dec2..4051c289 100644
--- a/suite/lib/model/slices.test.ts
+++ b/suite/lib/model/slices.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
-import { emptyTrousseau } from "@jfrusher/trousseau";
-import { coerceGuests, readCrew } from "./slices";
+import { emptyTrousseau, migrate } from "@jfrusher/trousseau";
+import { coerceGuests, personName, readBoxes, readCast, readCeremony, readCrew, readShots, readTimeline } from "./slices";
 
 describe("coerceGuests keeps what it has no opinion about", () => {
   it("preserves fields owned by a tool rather than by the suite", () => {
@@ -102,3 +102,86 @@ describe("readCrew", () => {
     expect(crew.jobs[0]!.blockId).toBe("b1");
   });
 });
+
+describe("readTimeline's travel", () => {
+  it("keeps a journey with two places and a time, and drops one missing either", () => {
+    const doc = migrate({
+      timeline: {
+        travel: [
+          { between: ["The house", "The venue"], minutes: 15 },
+          { between: ["The house", ""], minutes: 10 },
+          { between: ["The house"], minutes: 10 },
+          { between: ["Church", "The venue"], minutes: 0 },
+          { between: ["Church", "The venue"], minutes: "20" },
+          "Church to the venue",
+        ],
+      },
+    });
+    expect(readTimeline(doc).travel).toEqual([{ between: ["The house", "The venue"], minutes: 15 }]);
+  });
+
+  it("is empty on a wedding that has never typed one", () => {
+    expect(readTimeline(emptyTrousseau()).travel).toEqual([]);
+  });
+});
+
+describe("readCast", () => {
+  it("reads who is who from its own slice", () => {
+    const cast = readCast(migrate({ cast: { roles: { "b-grandparents": ["g1", "g2"] }, customRoles: [{ id: "c1", name: "Readers", guestIds: [] }] } }));
+    expect(cast.roles["b-grandparents"]).toEqual(["g1", "g2"]);
+    expect(cast.roles.a).toEqual([]);
+    expect(cast.customRoles).toEqual([{ id: "c1", name: "Readers", guestIds: [] }]);
+  });
+
+  it("reads a document written before the cast had a slice, old role names and all", () => {
+    // The server reads stored documents nobody has opened since, so these
+    // must not read as having no cast.
+    const doc = migrate({ shots: { cast: { bride: ["g1"] }, customRoles: [{ id: "c1", name: "Readers", guestIds: [] }], sections: [] } });
+    expect(readCast(doc).roles.a).toEqual(["g1"]);
+    expect(readCast(doc).customRoles).toHaveLength(1);
+    expect(readShots(doc)).toEqual({ sections: [] });
+  });
+
+  it("is empty on a wedding with no cast anywhere", () => {
+    expect(readCast(emptyTrousseau()).customRoles).toEqual([]);
+    expect(Object.values(readCast(emptyTrousseau()).roles).every((ids) => ids.length === 0)).toBe(true);
+  });
+});
+
+describe("readCeremony", () => {
+  it("reads a processional, filling in what a group does not say, and converting old role names", () => {
+    const doc = migrate({
+      ceremony: {
+        processional: [
+          { id: "w1", members: [{ kind: "role", ref: "bride" }], formation: "threes", side: "b", music: "Canon in D" },
+          { id: "w2", formation: "sideways", side: "left" },
+          { label: "No id, so not a group" },
+        ],
+      },
+    });
+    expect(readCeremony(doc).processional).toEqual([
+      { id: "w1", label: "", members: [{ kind: "role", ref: "a" }], formation: "threes", side: "b", music: "Canon in D", cue: "" },
+      { id: "w2", label: "", members: [], formation: "single", side: "", music: "", cue: "" },
+    ]);
+  });
+});
+
+describe("readBoxes", () => {
+  it("reads boxes, filling in what a box does not say, and never a quantity below one", () => {
+    const doc = migrate({
+      boxes: { boxes: [{ id: "b1", name: "Getting ready", items: [{ id: "i1", label: "Shoes", quantity: 0 }, { label: "No id" }], blockId: 7 }, { name: "No id" }] },
+    });
+    expect(readBoxes(doc).boxes).toEqual([
+      { id: "b1", number: 1, name: "Getting ready", items: [{ id: "i1", label: "Shoes", quantity: 1, packed: false }], blockId: null, personIds: [], notes: "" },
+    ]);
+  });
+});
+
+describe("personName", () => {
+  const guests = { g1: { ...coerceGuests({ g1: { id: "g1", firstName: "Ines", lastName: "Ashdown" } })["g1"]! } };
+  it("names somebody who is a guest as the guest list does, and anyone else as the crew does", () => {
+    expect(personName({ name: "Old spelling", guestId: "g1" }, guests)).toBe("Ines Ashdown");
+    expect(personName({ name: "Rosa Wilde", guestId: null }, guests)).toBe("Rosa Wilde");
+    expect(personName({ name: "Kept", guestId: "g-deleted" }, guests)).toBe("Kept");
+  });
+});
diff --git a/suite/lib/model/slices.ts b/suite/lib/model/slices.ts
index 16f2ef0f..b4aec004 100644
--- a/suite/lib/model/slices.ts
+++ b/suite/lib/model/slices.ts
@@ -32,10 +32,25 @@ import {
   defaultStyles,
   emptyDoc,
 } from "@/apps/cadence/core/model/defaults";
-import { CAST_ROLES } from "./types";
+import { BAR_KINDS, BAR_LINES, CAST_ROLES, CROWDS, FIGURES, MIXED_PARTS, POURS, SHOPS } from "./types";
 import type {
+  Bar,
+  BarKind,
+  BarLine,
+  Crowd,
+  Figure,
+  LineChoice,
+  Mix,
+  MixedPart,
+  Shop,
   Cast,
   CastRole,
+  Box,
+  BoxItem,
+  Boxes,
+  CastSlice,
+  Ceremony,
+  WalkGroup,
   Constraint,
   Crew,
   CustomRole,
@@ -45,6 +60,7 @@ import type {
   Guest,
   NamedGroup,
   Obstacle,
+  Person,
   PerSideSeats,
   RoomSpec,
   Seating,
@@ -209,6 +225,16 @@ export function guestName(guest: Guest): string {
   return [guest.firstName, guest.lastName].filter(Boolean).join(" ").trim();
 }
 
+/**
+ * A crew member's name. Somebody who is also a guest is named by the guest
+ * list, so a spelling corrected there is corrected everywhere they are named;
+ * linked to a guest since deleted, they keep the name they had.
+ */
+export function personName(person: Pick<Person, "name" | "guestId">, guests: Record<string, Guest>): string {
+  const guest = person.guestId ? guests[person.guestId] : undefined;
+  return guest ? guestName(guest) || person.name : person.name;
+}
+
 /**
  * Everyone on the list who has not said no: who needs a seat, a card and a
  * meal. Someone who declined stays on the list, and is none of those.
@@ -540,8 +566,9 @@ export function readTimeline(doc: Trousseau): Timeline {
         coupleNames: doc.event.coupleNames || str(storedDay["coupleNames"]),
         venueName: doc.event.venueName || str(storedDay["venueName"]),
         curfewMin: doc.event.curfewMin ?? num(storedDay["curfewMin"], fallbackDay.curfewMin),
+        // Never a likely value: unset stays unset, and the Day panel says so.
         utcOffsetMin:
-          doc.event.utcOffsetMin ?? num(storedDay["utcOffsetMin"], fallbackDay.utcOffsetMin),
+          doc.event.utcOffsetMin ?? (typeof storedDay["utcOffsetMin"] === "number" ? storedDay["utcOffsetMin"] : null),
         // The venue's coordinates are Cadence's alone: nothing else needs them,
         // and they drive only the golden-hour advisory.
         latitude: num(storedDay["latitude"], fallbackDay.latitude),
@@ -580,6 +607,16 @@ export function readTimeline(doc: Trousseau): Timeline {
           notes: str(t["notes"]),
         };
       }),
+      // Two places and a time, or nothing: a journey with half of it missing
+      // could only ever be guessed at.
+      travel: list(raw["travel"], (j) => {
+        if (!isRecord(j) || !Array.isArray(j["between"])) return null;
+        const [from, to] = j["between"];
+        const minutes = j["minutes"];
+        if (typeof from !== "string" || typeof to !== "string" || !from.trim() || !to.trim()) return null;
+        if (typeof minutes !== "number" || !Number.isFinite(minutes) || minutes <= 0) return null;
+        return { between: [from, to] as [string, string], minutes };
+      }),
       outputs: readOutputs(raw["outputs"]),
       styles: isRecord(raw["styles"])
         ? { ...defaultStyles(), ...(raw["styles"] as ReturnType<typeof defaultStyles>) }
@@ -762,7 +799,7 @@ export function emptyCast(): Cast {
   return cast;
 }
 
-function readCast(raw: unknown): Cast {
+function readRoles(raw: unknown): Cast {
   const cast = emptyCast();
   if (!isRecord(raw)) return cast;
   for (const role of CAST_ROLES) {
@@ -820,7 +857,7 @@ function readSection(raw: unknown): ShotSection | null {
 }
 
 export function emptyShots(): Shots {
-  return { cast: emptyCast(), customRoles: [], sections: [] };
+  return { sections: [] };
 }
 
 export function readShots(doc: Trousseau): Shots {
@@ -828,10 +865,175 @@ export function readShots(doc: Trousseau): Shots {
     const raw: Record<string, unknown> = isRecord((doc as Record<string, unknown>)["shots"])
       ? ((doc as Record<string, unknown>)["shots"] as Record<string, unknown>)
       : {};
+    return { sections: list(raw["sections"], readSection) };
+  });
+}
+
+// cast ------------------------------------------------------------------------
+
+const holdsOwnCast = (own: unknown): own is Record<string, unknown> =>
+  isRecord(own) && ("roles" in own || "customRoles" in own);
+const holdsOldCast = (shots: unknown): shots is Record<string, unknown> =>
+  isRecord(shots) && ("cast" in shots || "customRoles" in shots);
+
+/**
+ * True when the cast is still inside `shots`, where it lived before two tools
+ * shared it. `reconcileLoadedDocument` moves it to its own slice.
+ */
+export function hasLegacyCast(raw: unknown): boolean {
+  return isRecord(raw) && !holdsOwnCast(raw["cast"]) && holdsOldCast(raw["shots"]);
+}
+
+export function emptyCastSlice(): CastSlice {
+  return { roles: emptyCast(), customRoles: [] };
+}
+
+/**
+ * Who is who: the `cast` slice, or — in a document written before it had a
+ * slice of its own — the cast still inside `shots`, old role names and all.
+ *
+ * Read from either, rather than only after the load-time pass has moved it,
+ * because the planner's Weddings page runs What is left over stored documents
+ * on the server, and a wedding nobody has opened since must not read as having
+ * no cast.
+ */
+export function readCast(doc: Trousseau): CastSlice {
+  return cached(doc, "cast", () => {
+    const record = doc as Record<string, unknown>;
+    const own = record["cast"];
+    const shots = record["shots"];
+    const source = holdsOwnCast(own)
+      ? { roles: own["roles"], customRoles: own["customRoles"] }
+      : holdsOldCast(shots)
+        ? { roles: shots["cast"], customRoles: shots["customRoles"] }
+        : {};
+    return { roles: readRoles(source.roles), customRoles: list(source.customRoles, readCustomRole) };
+  });
+}
+
+// ceremony --------------------------------------------------------------------
+
+function readWalkGroup(raw: unknown): WalkGroup | null {
+  if (!isRecord(raw) || typeof raw["id"] !== "string") return null;
+  const formation = raw["formation"];
+  const side = raw["side"];
+  return {
+    id: raw["id"],
+    label: str(raw["label"]),
+    members: list(raw["members"], readMember),
+    formation: formation === "pairs" || formation === "threes" ? formation : "single",
+    side: side === "a" || side === "b" || side === "both" ? side : "",
+    music: str(raw["music"]),
+    cue: str(raw["cue"]),
+  };
+}
+
+export function emptyCeremony(): Ceremony {
+  return { processional: [] };
+}
+
+export function readCeremony(doc: Trousseau): Ceremony {
+  return cached(doc, "ceremony", () => {
+    const raw = (doc as Record<string, unknown>)["ceremony"];
+    return { processional: list(isRecord(raw) ? raw["processional"] : null, readWalkGroup) };
+  });
+}
+
+// boxes -----------------------------------------------------------------------
+
+function readBoxItem(raw: unknown): BoxItem | null {
+  if (!isRecord(raw) || typeof raw["id"] !== "string") return null;
+  return {
+    id: raw["id"],
+    label: str(raw["label"]),
+    quantity: Math.max(1, Math.round(num(raw["quantity"], 1))),
+    packed: bool(raw["packed"], false),
+  };
+}
+
+function readBox(raw: unknown, index: number): Box | null {
+  if (!isRecord(raw) || typeof raw["id"] !== "string") return null;
+  return {
+    id: raw["id"],
+    number: num(raw["number"], index + 1),
+    name: str(raw["name"]),
+    items: list(raw["items"], readBoxItem),
+    blockId: typeof raw["blockId"] === "string" ? raw["blockId"] : null,
+    personIds: list(raw["personIds"], (id) => (typeof id === "string" ? id : null)),
+    notes: str(raw["notes"]),
+  };
+}
+
+export function emptyBoxes(): Boxes {
+  return { boxes: [] };
+}
+
+export function readBoxes(doc: Trousseau): Boxes {
+  return cached(doc, "boxes", () => {
+    const raw = (doc as Record<string, unknown>)["boxes"];
+    const stored = isRecord(raw) && Array.isArray(raw["boxes"]) ? raw["boxes"] : [];
+    return { boxes: stored.map(readBox).filter((box): box is Box => box !== null) };
+  });
+}
+
+// bar -------------------------------------------------------------------------
+
+const amount = (v: unknown): number | null => (typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : null);
+
+function readMix(raw: unknown): Mix | null {
+  if (!isRecord(raw)) return null;
+  const mix = {} as Mix;
+  for (const pour of POURS) mix[pour] = amount(raw[pour]) ?? 0;
+  return mix;
+}
+
+function readLineChoice(raw: unknown): LineChoice | null {
+  if (!isRecord(raw)) return null;
+  const choice: LineChoice = {};
+  const price = amount(raw["price"]);
+  const have = amount(raw["have"]);
+  if (price !== null) choice.price = price;
+  if (have !== null && have > 0) choice.have = have;
+  if (SHOPS.includes(raw["shop"] as Shop)) choice.shop = raw["shop"] as Shop;
+  return Object.keys(choice).length > 0 ? choice : null;
+}
+
+export function emptyBar(): Bar {
+  return { kind: "full", crowd: "usual", people: null, figures: {}, mix: {}, lines: {}, wholeCases: true };
+}
+
+/** The bar as the couple left it: only their choices, each checked; the rest is the defaults'. */
+export function readBar(doc: Trousseau): Bar {
+  return cached(doc, "bar", () => {
+    const raw = (doc as Record<string, unknown>)["bar"];
+    if (!isRecord(raw)) return emptyBar();
+    const figures: Partial<Record<Figure, number>> = {};
+    const storedFigures = isRecord(raw["figures"]) ? raw["figures"] : {};
+    for (const figure of FIGURES) {
+      const value = amount(storedFigures[figure]);
+      if (value !== null) figures[figure] = value;
+    }
+    const mix: Partial<Record<MixedPart, Mix>> = {};
+    const storedMix = isRecord(raw["mix"]) ? raw["mix"] : {};
+    for (const part of MIXED_PARTS) {
+      const read = readMix(storedMix[part]);
+      if (read) mix[part] = read;
+    }
+    const lines: Partial<Record<BarLine, LineChoice>> = {};
+    const storedLines = isRecord(raw["lines"]) ? raw["lines"] : {};
+    for (const line of BAR_LINES) {
+      const read = readLineChoice(storedLines[line]);
+      if (read) lines[line] = read;
+    }
+    const people = amount(raw["people"]);
     return {
-      cast: readCast(raw["cast"]),
-      customRoles: list(raw["customRoles"], readCustomRole),
-      sections: list(raw["sections"], readSection),
+      kind: BAR_KINDS.includes(raw["kind"] as BarKind) ? (raw["kind"] as BarKind) : "full",
+      crowd: CROWDS.includes(raw["crowd"] as Crowd) ? (raw["crowd"] as Crowd) : "usual",
+      people: people === null ? null : Math.round(people),
+      figures,
+      mix,
+      lines,
+      wholeCases: bool(raw["wholeCases"], true),
     };
   });
 }
diff --git a/suite/lib/model/toolbox.test.ts b/suite/lib/model/toolbox.test.ts
new file mode 100644
index 00000000..d18c2ef6
--- /dev/null
+++ b/suite/lib/model/toolbox.test.ts
@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { emptyTrousseau, migrate } from "@jfrusher/trousseau";
+import { TOOLS } from "@/lib/tools";
+import { hiddenToolIds, shownTools, withTool } from "./toolbox";
+
+const ids = (doc: Parameters<typeof shownTools>[0]) => shownTools(doc).map((tool) => tool.id);
+
+describe("shownTools", () => {
+  it("shows the five when the wedding has never chosen, and leaves the rest in the toolbox", () => {
+    const doc = emptyTrousseau();
+    expect(ids(doc)).toEqual(["seating", "place-cards", "timeline", "delegation", "group-shots"]);
+    expect([...hiddenToolIds(doc)]).toEqual(["ceremony", "boxes", "bar", "money", "checklist", "binder"]);
+    expect(shownTools(doc)).toBe(shownTools(emptyTrousseau()));
+  });
+
+  it("shows what is stored, in the registry's order rather than the stored one", () => {
+    const doc = migrate({ tools: { shown: ["group-shots", "seating"] } });
+    expect(ids(doc)).toEqual(["seating", "group-shots"]);
+    expect([...hiddenToolIds(doc)]).toEqual(["place-cards", "timeline", "delegation", "ceremony", "boxes", "bar", "money", "checklist", "binder"]);
+  });
+
+  it("shows nothing when everything has been removed", () => {
+    expect(ids(migrate({ tools: { shown: [] } }))).toEqual([]);
+  });
+
+  it("ignores an id this build does not know", () => {
+    expect(ids(migrate({ tools: { shown: ["florist", "timeline"] } }))).toEqual(["timeline"]);
+  });
+
+  it("every tool's address is its id", () => {
+    for (const tool of TOOLS) expect(tool.href).toBe(`/${tool.id}`);
+  });
+});
+
+describe("withTool", () => {
+  it("removing from a wedding that never chose keeps the other four", () => {
+    expect(withTool({}, "seating", false)).toEqual({
+      shown: ["place-cards", "timeline", "delegation", "group-shots"],
+    });
+  });
+
+  it("adding one of the rest to a wedding that never chose keeps the five", () => {
+    expect(withTool({}, "money", true)).toEqual({
+      shown: ["seating", "place-cards", "timeline", "delegation", "group-shots", "money"],
+    });
+  });
+
+  it("adding back puts it in the list once", () => {
+    const removed = { tools: withTool({}, "seating", false) };
+    const added = withTool(removed, "seating", true);
+    expect(added["shown"]).toEqual(["place-cards", "timeline", "delegation", "group-shots", "seating"]);
+    expect(withTool({ tools: added }, "seating", true)["shown"]).toEqual(added["shown"]);
+  });
+
+  it("keeps an id this build does not know, and the slice's other keys", () => {
+    const raw = { tools: { shown: ["florist", "seating", "timeline"], note: "from a newer build" } };
+    expect(withTool(raw, "seating", false)).toEqual({ shown: ["florist", "timeline"], note: "from a newer build" });
+  });
+});
diff --git a/suite/lib/model/toolbox.ts b/suite/lib/model/toolbox.ts
new file mode 100644
index 00000000..acafef4d
--- /dev/null
+++ b/suite/lib/model/toolbox.ts
@@ -0,0 +1,55 @@
+import type { Trousseau } from "@jfrusher/trousseau";
+import { TOOLS, type Tool, type ToolId } from "@/lib/tools";
+import { cached } from "./slices";
+
+/**
+ * Which tools the wedding shows — the same for both partners and the planner,
+ * because it is kept in the wedding, in the `tools` slice.
+ *
+ * Nothing stored means the tools that are on by default, which is every
+ * wedding until somebody adds or removes one. Removing a tool only hides it:
+ * what was made in it stays in its own slice, untouched, and is there again
+ * when it is added back.
+ */
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+/** What a wedding that has never chosen shows. */
+const DEFAULT_TOOLS = TOOLS.filter((tool) => tool.defaultOn);
+
+/** The ids as stored, from a parsed or a raw document, or null when the wedding has never chosen. */
+function storedIds(doc: unknown): string[] | null {
+  const slice = isRecord(doc) ? doc["tools"] : null;
+  const shown = isRecord(slice) ? slice["shown"] : null;
+  return Array.isArray(shown) ? shown.filter((id): id is string => typeof id === "string") : null;
+}
+
+/** The tools the wedding shows, in the registry's order. */
+export function shownTools(doc: Trousseau): readonly Tool[] {
+  return cached(doc, "shownTools", () => {
+    const ids = storedIds(doc);
+    return ids === null ? DEFAULT_TOOLS : TOOLS.filter((tool) => ids.includes(tool.id));
+  });
+}
+
+/** The ids of the tools the wedding does not show — removed, or never added — for everything that lists a tool's work. */
+export function hiddenToolIds(doc: Trousseau): ReadonlySet<string> {
+  return cached(doc, "hiddenToolIds", () => {
+    const shown = shownTools(doc);
+    return new Set(TOOLS.filter((tool) => !shown.includes(tool)).map((tool) => tool.id));
+  });
+}
+
+/**
+ * The `tools` slice with one tool added or taken away.
+ *
+ * Built from the stored document rather than the registry, so an id this build
+ * does not know — a tool a newer version added — is kept, and an older build
+ * removing Seating never removes the newer one's tool with it.
+ */
+export function withTool(raw: unknown, id: ToolId, show: boolean): Record<string, unknown> {
+  const slice = isRecord(raw) && isRecord(raw["tools"]) ? raw["tools"] : {};
+  const others = (storedIds(raw) ?? DEFAULT_TOOLS.map((tool) => tool.id)).filter((stored) => stored !== id);
+  return { ...slice, shown: show ? [...others, id] : others };
+}
diff --git a/suite/lib/model/types.ts b/suite/lib/model/types.ts
index 52bee2cb..79422cd9 100644
--- a/suite/lib/model/types.ts
+++ b/suite/lib/model/types.ts
@@ -291,11 +291,21 @@ export interface Crew {
 // group shots ------------------------------------------------------------------
 
 /**
- * Where a shot's people come from — the couple, a parent, the wedding party —
- * by which partner they belong to. Named in words by `roleLabel`, after the
- * partners: `b-mother` is "Sam's mother".
+ * Who somebody is to the couple — one of them, a parent, a grandparent, the
+ * wedding party — by which partner they belong to. Named in words by
+ * `roleLabel`, after the partners: `b-mother` is "Sam's mother".
  */
-export type CastRole = "a" | "b" | "a-mother" | "a-father" | "b-mother" | "b-father" | "a-party" | "b-party";
+export type CastRole =
+  | "a"
+  | "b"
+  | "a-mother"
+  | "a-father"
+  | "b-mother"
+  | "b-father"
+  | "a-grandparents"
+  | "b-grandparents"
+  | "a-party"
+  | "b-party";
 
 export const CAST_ROLES: readonly CastRole[] = [
   "a",
@@ -304,11 +314,13 @@ export const CAST_ROLES: readonly CastRole[] = [
   "a-father",
   "b-mother",
   "b-father",
+  "a-grandparents",
+  "b-grandparents",
   "a-party",
   "b-party",
 ];
 
-/** Roles that hold at most one person. The wedding parties hold many. */
+/** Roles that hold at most one person. Grandparents and the wedding parties hold many. */
 export const SINGLE_ROLES: ReadonlySet<CastRole> = new Set(["a", "b", "a-mother", "a-father", "b-mother", "b-father"]);
 
 /** Guest ids per role. Singular roles hold 0 or 1; party roles hold many. */
@@ -344,9 +356,173 @@ export interface ShotSection {
   shots: Shot[];
 }
 
-/** The `shots` slice. Ensemble's model. */
+/** The `shots` slice. Ensemble's model: the list itself, whoever is in it. */
 export interface Shots {
-  cast: Cast;
-  customRoles: CustomRole[];
   sections: ShotSection[];
 }
+
+/**
+ * The `cast` slice: who is who, shared by Group shots and Ceremony, so a
+ * mother named once is the same mother in the photographs and down the aisle.
+ */
+export interface CastSlice {
+  roles: Cast;
+  customRoles: CustomRole[];
+}
+
+// ceremony --------------------------------------------------------------------
+
+/** How a group walks: one at a time, side by side in pairs, or in threes. */
+export type Formation = "single" | "pairs" | "threes";
+
+export const FORMATIONS: readonly Formation[] = ["single", "pairs", "threes"];
+
+/**
+ * One group in the processional, in the order they walk. Its members are the
+ * kinds a group shot's are — a role, a guest, a family, words — and resolve
+ * the same way, from the one cast.
+ */
+export interface WalkGroup {
+  id: string;
+  /** Blank means the printed label is built from the members instead. */
+  label: string;
+  members: ShotMember[];
+  formation: Formation;
+  /** Which side of the aisle they go to: a partner's, both, or not said. */
+  side: Side;
+  /** What they walk to, as the couple would write it: "Canon in D". */
+  music: string;
+  /** When: "The music changes as the couple enter". */
+  cue: string;
+}
+
+/** The `ceremony` slice. Ceremony's own. */
+export interface Ceremony {
+  processional: WalkGroup[];
+}
+
+// boxes -----------------------------------------------------------------------
+
+/** One thing packed, or to be. */
+export interface BoxItem {
+  id: string;
+  label: string;
+  quantity: number;
+  packed: boolean;
+}
+
+/**
+ * A box for the day: what is in it, and the part of the day it is needed for.
+ * Where and when are that block's — its location and its start — never typed
+ * onto the box, so moving the block moves the box.
+ */
+export interface Box {
+  id: string;
+  /** Printed large on its label. */
+  number: number;
+  name: string;
+  items: BoxItem[];
+  /** The block it is needed for, or null: not for the day — the honeymoon bag. */
+  blockId: string | null;
+  /** Who gets it there: people from the crew. */
+  personIds: string[];
+  notes: string;
+}
+
+/** The `boxes` slice. Boxes' own. */
+export interface Boxes {
+  boxes: Box[];
+}
+
+// bar -------------------------------------------------------------------------
+
+/** The kind of bar, which sets what the reception and the evening pour. */
+export type BarKind = "full" | "beer-and-wine" | "cocktails" | "no-and-low";
+export const BAR_KINDS: readonly BarKind[] = ["full", "beer-and-wine", "cocktails", "no-and-low"];
+
+/** A lighter or heavier crowd than most. */
+export type Crowd = "lighter" | "usual" | "heavier";
+export const CROWDS: readonly Crowd[] = ["lighter", "usual", "heavier"];
+
+/** What is poured in a part of the day with a mix. A cocktail is a spirit and a mixer. */
+export type Pour = "fizz" | "wine" | "beer" | "spirit";
+export const POURS: readonly Pour[] = ["fizz", "wine", "beer", "spirit"];
+
+/** The parts of the day that pour a mix; the toast is fizz and the meal is wine. */
+export type MixedPart = "reception" | "evening";
+export const MIXED_PARTS: readonly MixedPart[] = ["reception", "evening"];
+
+/** A share of each pour, in percent. */
+export type Mix = Record<Pour, number>;
+
+/** Every figure the sum uses that has a default. */
+export type Figure =
+  | "notDrinkingPct"
+  | "eveningGuests"
+  | "receptionHours"
+  | "receptionPerHour"
+  | "toastGlasses"
+  | "mealGlasses"
+  | "eveningHours"
+  | "eveningPerHour"
+  | "redPct"
+  | "fizzGlassMl"
+  | "wineGlassMl"
+  | "spiritMl"
+  | "mixerMl"
+  | "softMl"
+  | "iceKg";
+export const FIGURES: readonly Figure[] = [
+  "notDrinkingPct",
+  "eveningGuests",
+  "receptionHours",
+  "receptionPerHour",
+  "toastGlasses",
+  "mealGlasses",
+  "eveningHours",
+  "eveningPerHour",
+  "redPct",
+  "fizzGlassMl",
+  "wineGlassMl",
+  "spiritMl",
+  "mixerMl",
+  "softMl",
+  "iceKg",
+];
+
+/** What is bought, a line of the shopping list. */
+export type BarLine = "fizz" | "white" | "red" | "beer" | "spirits" | "mixers" | "soft" | "ice";
+export const BAR_LINES: readonly BarLine[] = ["fizz", "white", "red", "beer", "spirits", "mixers", "soft", "ice"];
+
+/** Where a line is bought. */
+export type Shop = "wine-merchant" | "cash-and-carry" | "supermarket";
+export const SHOPS: readonly Shop[] = ["wine-merchant", "cash-and-carry", "supermarket"];
+
+/** What the couple chose for one line; anything absent is the default. */
+export interface LineChoice {
+  /** Per bottle, per case of beer, per litre or per kilo. */
+  price?: number;
+  /** Already theirs, in the line's own units: bottles, cans, litres, kilos. */
+  have?: number;
+  shop?: Shop;
+}
+
+/**
+ * The `bar` slice. Bar's own.
+ *
+ * Only what the couple chose: every figure they have not changed is its
+ * default, read from `lib/bar/defaults`, so putting one back is forgetting it.
+ * Nothing worked out is kept — who is coming is the guest list's, live.
+ */
+export interface Bar {
+  kind: BarKind;
+  crowd: Crowd;
+  /** How many are coming, typed over the guest list's count; null reads the list. */
+  people: number | null;
+  figures: Partial<Record<Figure, number>>;
+  /** A part's mix, where it was changed from the kind's. */
+  mix: Partial<Record<MixedPart, Mix>>;
+  lines: Partial<Record<BarLine, LineChoice>>;
+  /** Round up to whole cases, for buying on sale or return. */
+  wholeCases: boolean;
+}
diff --git a/suite/lib/model/useSuite.ts b/suite/lib/model/useSuite.ts
index 190e72ed..420e0379 100644
--- a/suite/lib/model/useSuite.ts
+++ b/suite/lib/model/useSuite.ts
@@ -9,6 +9,10 @@ import {
 } from "@/lib/store/useTrousseauStore";
 import {
   publishDay,
+  readBar,
+  readBoxes,
+  readCast,
+  readCeremony,
   readCrew,
   readGuests,
   readSeating,
@@ -18,7 +22,7 @@ import {
   timelineDoc,
 } from "./slices";
 import { coupleTitle } from "./partners";
-import type { Crew, Guest, Seating, Shots } from "./types";
+import type { Bar, Boxes, CastSlice, Ceremony, Crew, Guest, Seating, Shots } from "./types";
 import type { Timeline } from "./timeline";
 
 /**
@@ -36,6 +40,10 @@ export const useSeating = (): Seating => useTrousseauStore((s) => readSeating(s.
 export const useTimeline = (): Timeline => useTrousseauStore((s) => readTimeline(s.doc));
 export const useCrew = (): Crew => useTrousseauStore((s) => readCrew(s.doc));
 export const useShots = (): Shots => useTrousseauStore((s) => readShots(s.doc));
+export const useCast = (): CastSlice => useTrousseauStore((s) => readCast(s.doc));
+export const useCeremony = (): Ceremony => useTrousseauStore((s) => readCeremony(s.doc));
+export const useBoxes = (): Boxes => useTrousseauStore((s) => readBoxes(s.doc));
+export const useBar = (): Bar => useTrousseauStore((s) => readBar(s.doc));
 export const useResolvedDay = () => useTrousseauStore((s) => resolvedDay(s.doc));
 export const useTimelineDoc = () => useTrousseauStore((s) => timelineDoc(s.doc));
 export const useStatus = (): TrousseauState["status"] => useTrousseauStore((s) => s.status);
@@ -70,6 +78,11 @@ export interface SuiteWriters {
   setTimeline: (next: Timeline, options?: WriteOptions) => void;
   setCrew: (next: Crew, options?: WriteOptions) => void;
   setShots: (next: Shots, options?: WriteOptions) => void;
+  /** Who is who, shared by Group shots and Ceremony. */
+  setCast: (next: CastSlice, options?: WriteOptions) => void;
+  setCeremony: (next: Ceremony, options?: WriteOptions) => void;
+  setBoxes: (next: Boxes, options?: WriteOptions) => void;
+  setBar: (next: Bar, options?: WriteOptions) => void;
   /** Both halves of a seat, as one undo step. */
   setPlan: (
     guests: Record<string, Guest>,
@@ -122,6 +135,22 @@ export function useWriters(): SuiteWriters {
       setSlice("shots", next, options),
     [setSlice],
   );
+  const setCast = useCallback(
+    (next: CastSlice, options: WriteOptions = { label: "who is who" }) => setSlice("cast", next, options),
+    [setSlice],
+  );
+  const setCeremony = useCallback(
+    (next: Ceremony, options: WriteOptions = { label: "the processional" }) => setSlice("ceremony", next, options),
+    [setSlice],
+  );
+  const setBoxes = useCallback(
+    (next: Boxes, options: WriteOptions = { label: "the boxes" }) => setSlice("boxes", next, options),
+    [setSlice],
+  );
+  const setBar = useCallback(
+    (next: Bar, options: WriteOptions = { label: "the bar" }) => setSlice("bar", next, options),
+    [setSlice],
+  );
   const setPlan = useCallback(
     (
       guests: Record<string, Guest>,
@@ -138,5 +167,5 @@ export function useWriters(): SuiteWriters {
     [setSlices],
   );
 
-  return { setEvent, setGuests, setSeating, setTimeline, setCrew, setShots, setPlan };
+  return { setEvent, setGuests, setSeating, setTimeline, setCrew, setShots, setCast, setCeremony, setBoxes, setBar, setPlan };
 }
diff --git a/suite/lib/palette/search.test.ts b/suite/lib/palette/search.test.ts
index 3b323b80..dbaa19ef 100644
--- a/suite/lib/palette/search.test.ts
+++ b/suite/lib/palette/search.test.ts
@@ -13,17 +13,27 @@ describe("finding anything by name", () => {
     expect(search(all, "").map((entry) => entry.name)).toEqual([
       "Overview",
       "Guests",
-      "Money",
-      "Checklist",
-      "Binder",
       "Seating",
       "Place cards",
       "Timeline",
       "Delegation",
       "Group shots",
+      "Ceremony",
+      "Boxes",
+      "Bar",
+      "Money",
+      "Checklist",
+      "Binder",
     ]);
   });
 
+  it("does not offer a tool the wedding has removed", () => {
+    const pages = entries(migrate({ ...raw, tools: { shown: ["seating"] } }))
+      .filter((entry) => entry.kind === "Page")
+      .map((entry) => entry.name);
+    expect(pages).toEqual(["Overview", "Guests", "Seating"]);
+  });
+
   it("finds a guest and says where they sit, opening the list found to them by id", () => {
     const [zainab] = search(all, "zainab thist");
     expect(zainab).toMatchObject({ kind: "Guest", name: "Zainab Thistlewood", detail: "No table yet" });
diff --git a/suite/lib/palette/search.ts b/suite/lib/palette/search.ts
index 7679429c..6b6548c6 100644
--- a/suite/lib/palette/search.ts
+++ b/suite/lib/palette/search.ts
@@ -2,7 +2,8 @@ import type { Trousseau } from "@jfrusher/trousseau";
 import { formatClock } from "@/apps/cadence/core/time/minutes";
 import { guestName, readCrew, readGuests, readSeating, readTimeline, resolvedDay } from "@/lib/model/slices";
 import { longDate } from "@/lib/dates";
-import { TOOLS, WEDDING_PAGES } from "@/lib/tools";
+import { GUESTS, WEDDING_PAGES } from "@/lib/tools";
+import { shownTools } from "@/lib/model/toolbox";
 
 /**
  * Everything in the wedding that can be gone to by name — a page, a guest, a
@@ -30,7 +31,7 @@ export function entries(doc: Trousseau): Entry[] {
   const people = new Map(crew.people.map((person) => [person.id, person.name]));
 
   return [
-    ...[...WEDDING_PAGES, ...TOOLS].map((page) => ({ kind: "Page" as const, name: page.name, detail: "", href: page.href })),
+    ...[...WEDDING_PAGES, GUESTS, ...shownTools(doc)].map((page) => ({ kind: "Page" as const, name: page.name, detail: "", href: page.href })),
     ...Object.values(guests).map((guest) => {
       const name = guestName(guest);
       const table = guest.assignedTableId ? tables[guest.assignedTableId]?.label : "";
diff --git a/suite/lib/seating/normalise.test.ts b/suite/lib/seating/normalise.test.ts
index 3b97c0c2..df2355d7 100644
--- a/suite/lib/seating/normalise.test.ts
+++ b/suite/lib/seating/normalise.test.ts
@@ -59,13 +59,31 @@ test("group-shot roles stored as bride and groom are stored as the partners'", (
       sections: [{ id: "s", name: "Family", shots: [{ id: "x", label: "", notes: "", members: [{ kind: "role", ref: "groomsmen" }] }] }],
     },
   });
-  const shots = raw["shots"] as { cast: Record<string, string[]>; sections: Array<{ shots: Array<{ members: unknown[] }> }> };
-  expect(shots.cast["a"]).toEqual(["g1"]);
-  expect(shots.cast["b-mother"]).toEqual(["g2"]);
-  expect(shots.cast["bride"]).toBeUndefined();
+  const shots = raw["shots"] as { sections: Array<{ shots: Array<{ members: unknown[] }> }> };
+  const cast = raw["cast"] as { roles: Record<string, string[]> };
+  expect(cast.roles["a"]).toEqual(["g1"]);
+  expect(cast.roles["b-mother"]).toEqual(["g2"]);
+  expect(cast.roles["bride"]).toBeUndefined();
   expect(shots.sections[0]!.shots[0]!.members).toEqual([{ kind: "role", ref: "b-party" }]);
 });
 
+test("a cast kept inside the shots moves to a slice of its own, without an undo step", () => {
+  const raw = load({
+    ...emptyTrousseau(),
+    shots: {
+      cast: { "a-mother": ["g1"] },
+      customRoles: [{ id: "crole-1", name: "Readers", guestIds: ["g2"] }],
+      sections: [],
+    },
+  });
+  expect(raw["cast"]).toMatchObject({
+    roles: { "a-mother": ["g1"] },
+    customRoles: [{ id: "crole-1", name: "Readers", guestIds: ["g2"] }],
+  });
+  expect(raw["shots"]).toEqual({ sections: [] });
+  expect(useTrousseauStore.getState().past).toEqual([]);
+});
+
 test("a wedding titled with two names learns who the two partners are", () => {
   const doc = emptyTrousseau();
   const raw = load({ ...doc, event: { ...doc.event, coupleNames: "Alex & Sam" } });
diff --git a/suite/lib/seating/normalise.ts b/suite/lib/seating/normalise.ts
index e9596162..b1e342d5 100644
--- a/suite/lib/seating/normalise.ts
+++ b/suite/lib/seating/normalise.ts
@@ -1,5 +1,5 @@
 import { splitTitle } from "@/lib/model/partners";
-import { hasLegacyGuests, hasLegacyShots, readGuests, readSeating, readShots } from "@/lib/model/slices";
+import { hasLegacyCast, hasLegacyGuests, hasLegacyShots, readCast, readGuests, readSeating, readShots } from "@/lib/model/slices";
 import type { Guest, Seating } from "@/lib/model/types";
 import { useTrousseauStore } from "@/lib/store/useTrousseauStore";
 
@@ -49,11 +49,11 @@ function reconcile(plan: Plan): Plan {
  *
  * The same pass converts what older versions stored differently: diets as the
  * file's words rather than a key, sides and group-shot roles as "bride" and
- * "groom" rather than after the partners, and the partners themselves only as
- * a title.
+ * "groom" rather than after the partners, the partners themselves only as a
+ * title, and the cast inside the shots rather than in a slice of its own.
  */
 export function reconcileLoadedDocument(): void {
-  const { doc, raw, status, setSlice } = useTrousseauStore.getState();
+  const { doc, raw, status, setSlice, setSlices } = useTrousseauStore.getState();
   if (status !== "ready") return;
 
   const before = readGuests(doc);
@@ -66,7 +66,19 @@ export function reconcileLoadedDocument(): void {
   if (after.guests !== before || hasLegacyGuests(raw["guests"])) {
     setSlice("guests", after.guests, { silent: true });
   }
-  if (hasLegacyShots(raw["shots"])) setSlice("shots", readShots(doc), { silent: true });
+  // The cast moves out of the shots into its own slice, both read from the
+  // same document and written together, so nothing is between the two.
+  if (hasLegacyCast(raw)) {
+    setSlices(
+      [
+        ["cast", readCast(doc)],
+        ["shots", readShots(doc)],
+      ],
+      { silent: true },
+    );
+  } else if (hasLegacyShots(raw["shots"])) {
+    setSlice("shots", readShots(doc), { silent: true });
+  }
 
   // A wedding named before the partners were stored apart: "Alex & Sam" is
   // two people, and each side of the family is named after one of them.
diff --git a/suite/lib/tools.ts b/suite/lib/tools.ts
index 31960619..af20b3c4 100644
--- a/suite/lib/tools.ts
+++ b/suite/lib/tools.ts
@@ -1,13 +1,26 @@
-import { Armchair, Banknote, Camera, ClipboardList, Clock, Contact, LayoutDashboard, ListChecks, Smartphone, Users, type LucideIcon } from "lucide-react";
+import { Armchair, Banknote, Camera, ClipboardList, Clock, Contact, Footprints, LayoutDashboard, ListChecks, Package, Smartphone, Users, Wine, type LucideIcon } from "lucide-react";
 
-/** The five tools, in the order the day is planned in. Nav and landing share this. */
-export interface Tool {
-  href: "/seating" | "/place-cards" | "/timeline" | "/delegation" | "/group-shots";
+/** What a wedding stores to say it shows a tool. Never renamed: it is data. */
+export type ToolId =
+  | "seating"
+  | "place-cards"
+  | "timeline"
+  | "delegation"
+  | "group-shots"
+  | "ceremony"
+  | "boxes"
+  | "bar"
+  | "money"
+  | "checklist"
+  | "binder";
+
+/** A way into one part of the wedding, as a tab in the header. */
+export interface Tab {
+  href: string;
   name: string;
-  tagline: string;
   icon: LucideIcon;
   /**
-   * The token class carrying this tool's palette.
+   * The token class carrying this tab's palette.
    *
    * The tab is where a tool is identified now that the wordmarks have gone, so
    * the active one is underlined in the colour that tool uses throughout. The
@@ -17,48 +30,131 @@ export interface Tool {
   tokens: string;
 }
 
+/** Something a wedding can add from the toolbox, or remove. */
+export interface Tool extends Tab {
+  id: ToolId;
+  href: `/${ToolId}`;
+  tagline: string;
+  /** Shown in a wedding that has never chosen. */
+  defaultOn: boolean;
+}
+
+/**
+ * The guest list: always the first tab, and never removable, because every
+ * tool is built on it.
+ */
+export const GUESTS: Tab = { href: "/guests", name: "Guests", icon: Users, tokens: "tableaux-tokens" };
+
+/**
+ * Every tool, in the order the header draws them: the five in the order the
+ * day is planned in, on by default, then those a wedding adds when it wants
+ * them.
+ */
 export const TOOLS: readonly Tool[] = [
   {
+    id: "seating",
     href: "/seating",
     tokens: "tableaux-tokens",
     name: "Seating",
     tagline: "Build the room, then put people in it.",
     icon: Armchair,
+    defaultOn: true,
   },
   {
+    id: "place-cards",
     href: "/place-cards",
     tokens: "plaque-tokens",
     name: "Place cards",
     tagline: "Print-ready cards from the plan you just made.",
     icon: Contact,
+    defaultOn: true,
   },
   {
+    id: "timeline",
     href: "/timeline",
     tokens: "cadence-tokens",
     name: "Timeline",
     tagline: "The run of the day, and what collides.",
     icon: Clock,
+    defaultOn: true,
   },
   {
+    id: "delegation",
     href: "/delegation",
     tokens: "brigade-tokens",
     name: "Delegation",
     tagline: "The jobs, and the hands doing them.",
     icon: ClipboardList,
+    defaultOn: true,
   },
   {
+    id: "group-shots",
     href: "/group-shots",
     tokens: "ensemble-tokens",
     name: "Group shots",
     tagline: "The family photo list, built from who's who.",
     icon: Camera,
+    defaultOn: true,
+  },
+  {
+    id: "ceremony",
+    href: "/ceremony",
+    tokens: "ensemble-tokens",
+    name: "Ceremony",
+    tagline: "Who walks down the aisle, in what order, and to what.",
+    icon: Footprints,
+    defaultOn: false,
+  },
+  {
+    id: "boxes",
+    href: "/boxes",
+    tokens: "brigade-tokens",
+    name: "Boxes",
+    tagline: "What is packed in which box, and where each has to be, by when.",
+    icon: Package,
+    defaultOn: false,
+  },
+  {
+    id: "bar",
+    href: "/bar",
+    tokens: "brigade-tokens",
+    name: "Bar",
+    tagline: "How much drink to buy, in bottles and cases, and roughly what it costs.",
+    icon: Wine,
+    defaultOn: false,
+  },
+  {
+    id: "money",
+    href: "/money",
+    tokens: "brigade-tokens",
+    name: "Money",
+    tagline: "What each supplier costs, what is paid, and what falls due.",
+    icon: Banknote,
+    defaultOn: false,
+  },
+  {
+    id: "checklist",
+    href: "/checklist",
+    tokens: "brigade-tokens",
+    name: "Checklist",
+    tagline: "What to have done before the day, each with a date.",
+    icon: ListChecks,
+    defaultOn: false,
+  },
+  {
+    id: "binder",
+    href: "/binder",
+    tokens: "cadence-tokens",
+    name: "Binder",
+    tagline: "The day on your phone, with or without signal.",
+    icon: Smartphone,
+    defaultOn: false,
   },
 ];
 
 /**
- * The wedding's own pages, as against the tools: views over the whole of it.
- * They sit under the wedding's name in the header, and each joins this list
- * as it is built.
+ * The wedding's own pages, as against its tools: views over the whole of it,
+ * under the wedding's name in the header.
  */
 export interface WeddingPage {
   href: string;
@@ -66,10 +162,4 @@ export interface WeddingPage {
   icon: LucideIcon;
 }
 
-export const WEDDING_PAGES: readonly WeddingPage[] = [
-  { href: "/", name: "Overview", icon: LayoutDashboard },
-  { href: "/guests", name: "Guests", icon: Users },
-  { href: "/money", name: "Money", icon: Banknote },
-  { href: "/checklist", name: "Checklist", icon: ListChecks },
-  { href: "/binder", name: "Binder", icon: Smartphone },
-];
+export const WEDDING_PAGES: readonly WeddingPage[] = [{ href: "/", name: "Overview", icon: LayoutDashboard }];
diff --git a/suite/lib/tour/exampleWedding.fixture.test.ts b/suite/lib/tour/exampleWedding.fixture.test.ts
index 79120700..e7f4cb08 100644
--- a/suite/lib/tour/exampleWedding.fixture.test.ts
+++ b/suite/lib/tour/exampleWedding.fixture.test.ts
@@ -3,10 +3,13 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { expect, test } from "vitest";
 import { migrate } from "@jfrusher/trousseau";
-import { readCrew, readGuests, readSeating, readShots, readTimeline } from "@/lib/model/slices";
+import { readBoxes, readCast, readCeremony, readCrew, readGuests, readSeating, readShots, readTimeline } from "@/lib/model/slices";
+import { dayPlaces, neededAt, packingOf } from "@/lib/boxes/view";
 import { readiness } from "@/lib/model/readiness";
-import { resolveShot } from "@/lib/ensemble/resolve";
+import { resolveMembers } from "@/lib/cast/resolve";
 import { computeWarnings } from "@/apps/tableaux/utils/warnings";
+import { shownTools } from "@/lib/model/toolbox";
+import { TOOLS } from "@/lib/tools";
 
 /*
  * The example wedding exists to show what Trousseau does once a wedding is
@@ -76,10 +79,11 @@ test("there is a crew, with jobs hanging off the day", () => {
 
 test("the shot list names real people, with nobody missing from it", () => {
   const shots = readShots(doc);
+  const cast = readCast(doc);
   const all = shots.sections.flatMap((s) => s.shots);
   expect(all.length).toBeGreaterThanOrEqual(12);
   for (const shot of all) {
-    const resolved = resolveShot(shot, readGuests(doc), seating, shots.cast, shots.customRoles, doc.event);
+    const resolved = resolveMembers(shot, readGuests(doc), seating, cast.roles, cast.customRoles, doc.event);
     expect(resolved.problems.filter((p) => p.kind !== "declined"), resolved.label).toEqual([]);
   }
 });
@@ -90,3 +94,31 @@ test("the place cards are drawn from the room, and agree with it", () => {
   expect(stationery.rows?.length).toBeGreaterThan(0);
   expect(readiness(doc, raw).filter((r) => r.severity === "blocking")).toEqual([]);
 });
+
+test("every tool is shown, including those a new wedding adds itself, so there is nothing it cannot demonstrate", () => {
+  expect(shownTools(doc)).toEqual(TOOLS);
+});
+
+test("the processional names real people, from the same cast as the group shots", () => {
+  const processional = readCeremony(doc).processional;
+  expect(processional.length).toBeGreaterThanOrEqual(5);
+  const cast = readCast(doc);
+  for (const group of processional) {
+    const resolved = resolveMembers(group, readGuests(doc), seating, cast.roles, cast.customRoles, doc.event);
+    expect(resolved.problems.filter((p) => p.kind !== "declined"), resolved.label).toEqual([]);
+  }
+});
+
+test("the boxes are each needed somewhere on the day, taken by somebody in the crew, and partly packed", () => {
+  const { boxes } = readBoxes(doc);
+  expect(boxes.length).toBeGreaterThanOrEqual(4);
+  const known = dayPlaces(doc);
+  const crew = new Set(readCrew(doc).people.map((person) => person.id));
+  for (const box of boxes) {
+    expect(neededAt(box, known).lost, box.name).toBe(false);
+    for (const id of box.personIds) expect(crew.has(id), `${box.name}: ${id}`).toBe(true);
+  }
+  const { packed, total } = packingOf({ boxes });
+  expect(packed).toBeGreaterThan(0);
+  expect(packed).toBeLessThan(total);
+});
diff --git a/suite/lib/tour/useTour.test.tsx b/suite/lib/tour/useTour.test.tsx
index 9868e9d3..fe71f4e3 100644
--- a/suite/lib/tour/useTour.test.tsx
+++ b/suite/lib/tour/useTour.test.tsx
@@ -9,8 +9,13 @@ const { TourProvider, useTour } = await import("./useTour");
 const { CHAPTERS } = await import("./steps");
 const { ConfirmProvider } = await import("@/components/ui/Confirm");
 const { TakeTheTour, HowThisWorks } = await import("@/components/shell/TourButtons");
+const { useTrousseauStore } = await import("@/lib/store/useTrousseauStore");
+const { migrate } = await import("@jfrusher/trousseau");
 
-afterEach(() => cleanup());
+afterEach(() => {
+  cleanup();
+  useTrousseauStore.setState({ doc: migrate({}) });
+});
 
 /** What the tour card would show, without the card's modal dialog. */
 function Probe() {
@@ -52,6 +57,16 @@ test("Take a tour runs every chapter, one after another", async () => {
   expect(screen.getByTestId("at").textContent).toBe("closed");
 });
 
+test("Take a tour leaves out the chapters of tools the wedding has removed", async () => {
+  useTrousseauStore.setState({ doc: migrate({ tools: { shown: ["timeline"] } }) });
+  const kept = CHAPTERS.filter((chapter) => ["shell", "guests", "timeline"].includes(chapter.id));
+  const total = kept.reduce((sum, chapter) => sum + chapter.steps.length, 0);
+  renderTour(<TakeTheTour />);
+  // "Take the tour again" by now: the test before this one has seen it.
+  await act(async () => fireEvent.click(screen.getByRole("button", { name: /Take (a|the) tour/ })));
+  expect(screen.getByTestId("at").textContent).toBe(`/ 1/${total}`);
+});
+
 test("How this page works explains the page you are on, and only that", () => {
   renderTour(<HowThisWorks />);
   fireEvent.click(screen.getByRole("button", { name: "How this page works" }));
diff --git a/suite/lib/tour/useTour.tsx b/suite/lib/tour/useTour.tsx
index 5ea3118f..4d827159 100644
--- a/suite/lib/tour/useTour.tsx
+++ b/suite/lib/tour/useTour.tsx
@@ -2,6 +2,8 @@
 
 import { createContext, useCallback, useContext, useMemo, useState } from "react";
 import { useRouter } from "next/navigation";
+import { useTrousseauStore } from "@/lib/store/useTrousseauStore";
+import { hiddenToolIds } from "@/lib/model/toolbox";
 import { CHAPTERS, type ChapterId, type TourChapter, type TourStep } from "./steps";
 
 /**
@@ -87,7 +89,12 @@ export function TourProvider({ children }: { children: React.ReactNode }) {
     (id: ChapterId) => begin(walkOf(CHAPTERS.filter((chapter) => chapter.id === id))),
     [begin],
   );
-  const startAll = useCallback(() => begin(walkOf(CHAPTERS)), [begin]);
+  // Every chapter but those of the tools the wedding has removed.
+  const hidden = useTrousseauStore((s) => hiddenToolIds(s.doc));
+  const startAll = useCallback(
+    () => begin(walkOf(CHAPTERS.filter((chapter) => !hidden.has(chapter.id)))),
+    [begin, hidden],
+  );
 
   const next = useCallback(() => {
     if (open) go({ walk: open.walk, index: open.index + 1 });
diff --git a/suite/public/fixtures/example-wedding.trousseau.json b/suite/public/fixtures/example-wedding.trousseau.json
index c9eb0a27..93113dd5 100644
--- a/suite/public/fixtures/example-wedding.trousseau.json
+++ b/suite/public/fixtures/example-wedding.trousseau.json
@@ -4573,37 +4573,6 @@
     "sheetCollapsed": false
   },
   "shots": {
-    "cast": {
-      "a": [
-        "g_ex000"
-      ],
-      "b": [
-        "g_ex001"
-      ],
-      "a-mother": [
-        "g_ex002"
-      ],
-      "a-father": [
-        "g_ex003"
-      ],
-      "b-mother": [
-        "g_ex004"
-      ],
-      "b-father": [
-        "g_ex005"
-      ],
-      "a-party": [
-        "g_vofkec66",
-        "g_4lnex3bq",
-        "g_q18mutww"
-      ],
-      "b-party": [
-        "g_8in4f7z4",
-        "g_wkewk4ut",
-        "g_8gp2bi4e"
-      ]
-    },
-    "customRoles": [],
     "sections": [
       {
         "id": "sec_dovdlg5o",
@@ -5626,5 +5595,338 @@
     },
     "fonts": []
   },
+  "tools": {
+    "shown": [
+      "seating",
+      "place-cards",
+      "timeline",
+      "delegation",
+      "group-shots",
+      "ceremony",
+      "boxes",
+      "bar",
+      "money",
+      "checklist",
+      "binder"
+    ]
+  },
+  "cast": {
+    "roles": {
+      "a": [
+        "g_ex000"
+      ],
+      "b": [
+        "g_ex001"
+      ],
+      "a-mother": [
+        "g_ex002"
+      ],
+      "a-father": [
+        "g_ex003"
+      ],
+      "b-mother": [
+        "g_ex004"
+      ],
+      "b-father": [
+        "g_ex005"
+      ],
+      "a-party": [
+        "g_vofkec66",
+        "g_4lnex3bq",
+        "g_q18mutww"
+      ],
+      "b-party": [
+        "g_8in4f7z4",
+        "g_wkewk4ut",
+        "g_8gp2bi4e"
+      ]
+    },
+    "customRoles": []
+  },
+  "ceremony": {
+    "processional": [
+      {
+        "id": "walk-registrar",
+        "label": "",
+        "members": [
+          {
+            "kind": "text",
+            "ref": "The registrar"
+          }
+        ],
+        "formation": "single",
+        "side": "",
+        "music": "",
+        "cue": "In place before the music starts"
+      },
+      {
+        "id": "walk-a-parents",
+        "label": "",
+        "members": [
+          {
+            "kind": "role",
+            "ref": "a-mother"
+          },
+          {
+            "kind": "role",
+            "ref": "a-father"
+          }
+        ],
+        "formation": "pairs",
+        "side": "a",
+        "music": "Air on the G String",
+        "cue": "Take their seats"
+      },
+      {
+        "id": "walk-b-parents",
+        "label": "",
+        "members": [
+          {
+            "kind": "role",
+            "ref": "b-mother"
+          },
+          {
+            "kind": "role",
+            "ref": "b-father"
+          }
+        ],
+        "formation": "pairs",
+        "side": "b",
+        "music": "Air on the G String",
+        "cue": ""
+      },
+      {
+        "id": "walk-a-party",
+        "label": "",
+        "members": [
+          {
+            "kind": "role",
+            "ref": "a-party"
+          }
+        ],
+        "formation": "pairs",
+        "side": "a",
+        "music": "Canon in D",
+        "cue": ""
+      },
+      {
+        "id": "walk-b-party",
+        "label": "",
+        "members": [
+          {
+            "kind": "role",
+            "ref": "b-party"
+          }
+        ],
+        "formation": "pairs",
+        "side": "b",
+        "music": "Canon in D",
+        "cue": ""
+      },
+      {
+        "id": "walk-couple",
+        "label": "",
+        "members": [
+          {
+            "kind": "role",
+            "ref": "a"
+          },
+          {
+            "kind": "role",
+            "ref": "b"
+          }
+        ],
+        "formation": "pairs",
+        "side": "",
+        "music": "The Arrival of the Queen of Sheba",
+        "cue": "The music changes as the couple enter"
+      }
+    ]
+  },
+  "boxes": {
+    "boxes": [
+      {
+        "id": "box-rings",
+        "number": 1,
+        "name": "The rings and the paperwork",
+        "blockId": "blk-ceremony",
+        "personIds": [
+          "p_ex00p"
+        ],
+        "notes": "Stays with the best man from the morning.",
+        "items": [
+          {
+            "id": "item-rings-1",
+            "label": "The rings",
+            "quantity": 2,
+            "packed": false
+          },
+          {
+            "id": "item-rings-2",
+            "label": "Any paperwork the ceremony needs",
+            "quantity": 1,
+            "packed": false
+          },
+          {
+            "id": "item-rings-3",
+            "label": "Vows and readings",
+            "quantity": 1,
+            "packed": true
+          },
+          {
+            "id": "item-rings-4",
+            "label": "Envelopes for suppliers' final payments",
+            "quantity": 3,
+            "packed": false
+          }
+        ]
+      },
+      {
+        "id": "box-getting-ready",
+        "number": 2,
+        "name": "Getting ready",
+        "blockId": "blk-prep",
+        "personIds": [
+          "p_ex00q"
+        ],
+        "notes": "",
+        "items": [
+          {
+            "id": "item-ready-1",
+            "label": "Outfits, on hangers",
+            "quantity": 2,
+            "packed": true
+          },
+          {
+            "id": "item-ready-2",
+            "label": "Shoes",
+            "quantity": 2,
+            "packed": true
+          },
+          {
+            "id": "item-ready-3",
+            "label": "Steamer",
+            "quantity": 1,
+            "packed": false
+          },
+          {
+            "id": "item-ready-4",
+            "label": "Emergency kit: plasters, safety pins, needle and thread, painkillers",
+            "quantity": 1,
+            "packed": false
+          },
+          {
+            "id": "item-ready-5",
+            "label": "Phone chargers",
+            "quantity": 2,
+            "packed": false
+          }
+        ]
+      },
+      {
+        "id": "box-odds-and-ends",
+        "number": 3,
+        "name": "The day's odds and ends",
+        "blockId": "blk-breakfast",
+        "personIds": [
+          "p_ex00r"
+        ],
+        "notes": "",
+        "items": [
+          {
+            "id": "item-odds-1",
+            "label": "Table plan",
+            "quantity": 1,
+            "packed": true
+          },
+          {
+            "id": "item-odds-2",
+            "label": "Place cards",
+            "quantity": 106,
+            "packed": false
+          },
+          {
+            "id": "item-odds-3",
+            "label": "Guest book and pens",
+            "quantity": 1,
+            "packed": false
+          },
+          {
+            "id": "item-odds-4",
+            "label": "Card box",
+            "quantity": 1,
+            "packed": false
+          },
+          {
+            "id": "item-odds-5",
+            "label": "Cake knife",
+            "quantity": 1,
+            "packed": false
+          },
+          {
+            "id": "item-odds-6",
+            "label": "Favours",
+            "quantity": 100,
+            "packed": false
+          }
+        ]
+      },
+      {
+        "id": "box-overnight",
+        "number": 4,
+        "name": "Overnight and the day after",
+        "blockId": null,
+        "personIds": [],
+        "notes": "",
+        "items": [
+          {
+            "id": "item-overnight-1",
+            "label": "Clothes for the day after",
+            "quantity": 2,
+            "packed": false
+          },
+          {
+            "id": "item-overnight-2",
+            "label": "Toiletries",
+            "quantity": 1,
+            "packed": false
+          },
+          {
+            "id": "item-overnight-3",
+            "label": "Passports and travel documents",
+            "quantity": 2,
+            "packed": false
+          }
+        ]
+      }
+    ]
+  },
+  "bar": {
+    "kind": "full",
+    "crowd": "usual",
+    "people": null,
+    "figures": {
+      "eveningGuests": 30
+    },
+    "mix": {},
+    "lines": {
+      "fizz": {
+        "price": 8.5
+      },
+      "white": {
+        "price": 7
+      },
+      "red": {
+        "price": 7.5
+      },
+      "beer": {
+        "price": 24
+      },
+      "spirits": {
+        "have": 2
+      }
+    },
+    "wholeCases": true
+  },
   "sources": {}
 }
diff --git a/supabase/migrations/20260929000004_library_processional.sql b/supabase/migrations/20260929000004_library_processional.sql
new file mode 100644
index 00000000..988b026f
--- /dev/null
+++ b/supabase/migrations/20260929000004_library_processional.sql
@@ -0,0 +1,11 @@
+-- The library keeps a processional too: its order, who walks by what they are
+-- to the couple, how, and the music — nobody by name, as the application
+-- strips guests, families and the wedding's own roles before it is saved.
+--
+-- The kinds are widened in place. Every item already saved is one of the four
+-- it held, so none is refused by the new rule; dropped by name so the
+-- migration can run twice.
+alter table public.library_items drop constraint if exists library_items_kind_check;
+alter table public.library_items
+  add constraint library_items_kind_check
+  check (kind in ('cards', 'day', 'room', 'checklist', 'processional'));
diff --git a/supabase/migrations/20260929000005_library_boxes.sql b/supabase/migrations/20260929000005_library_boxes.sql
new file mode 100644
index 00000000..b57005a9
--- /dev/null
+++ b/supabase/migrations/20260929000005_library_boxes.sql
@@ -0,0 +1,10 @@
+-- The library keeps a set of boxes too: their names and what goes in each,
+-- without who takes them, when they are needed or what is packed, which the
+-- application strips before it is saved.
+--
+-- Widened in place, as the processional was: every saved item is one of the
+-- kinds already allowed, and dropping by name lets the migration run twice.
+alter table public.library_items drop constraint if exists library_items_kind_check;
+alter table public.library_items
+  add constraint library_items_kind_check
+  check (kind in ('cards', 'day', 'room', 'checklist', 'processional', 'boxes'));
diff --git a/supabase/migrations/20260929000006_library_bar.sql b/supabase/migrations/20260929000006_library_bar.sql
new file mode 100644
index 00000000..ab8e9b49
--- /dev/null
+++ b/supabase/migrations/20260929000006_library_bar.sql
@@ -0,0 +1,10 @@
+-- The library keeps bar settings too: the kind of bar, the figures, the mix,
+-- the prices and the shops, without how many are coming or what a couple
+-- already has, which the application strips before it is saved.
+--
+-- Widened in place, as the boxes were: every saved item is one of the kinds
+-- already allowed, and dropping by name lets the migration run twice.
+alter table public.library_items drop constraint if exists library_items_kind_check;
+alter table public.library_items
+  add constraint library_items_kind_check
+  check (kind in ('cards', 'day', 'room', 'checklist', 'processional', 'boxes', 'bar'));