One Canonical State

"Change the trip once, and every view redraws. That is not a UI trick — it is the whole architecture."

The Model Underneath

Under every screen in Waystone sits a single canonical travel state. Its aggregate root is the Journey — it owns the lifecycle, the travelers, the destination scope, the dates, the current plan revision, the departure baseline, and the links to consultation threads. Hanging off it are the days, the places and their journey-scoped meanings, the routes, the recommendations, the decisions, and the record of what happened. That structured state is the model. Everything you can see — the itinerary, the globe, the journey map, the daily log — is a view of it.

This Is Polymorphism, Not Plumbing

If you have done the OO Quest, this will feel familiar, because it is the same idea Dad sees everywhere: one model, many polymorphic views. The itinerary reads the days and their order. The map reads the places and routes. The globe reads which journeys touched which parts of the world. The log reads the day entries. Each view asks the same canonical state a different question and renders the answer its own way — and crucially, no view edits the model. Views are readers. When the model changes, they all redraw from the new truth, because none of them was holding a private copy to fall out of sync.

Why This Is the Honest Design

The alternative — letting each screen keep its own copy of the trip — is the road to disagreement. The map says one thing, the itinerary says another, and now you have two trips that both claim to be real. By making every surface a projection of one model, Waystone guarantees there is only ever one trip. The cost of that guarantee is discipline: you must resist the temptation to let a view quietly store something "just for convenience." Every private stash is a future divergence. The map storing nothing is not a limitation — it is the promise that the map is always telling the truth.

Code

One model, many readers (shape sketch)·text

Journey (the canonical model)
  lifecycle, travelers, dates, plan_revision, baseline
  |- days[]        (local-calendar containers)
  |- places[]      (+ journey-scoped Waystone meanings)
  |- routes[]      (planned + actual geometry)
  |- decisions[]   (what Dad chose, and why)
  '- events[]      (real-world units within days)

     ^        ^        ^        ^
 itinerary  globe     map      log        <- views
 reads      reads     reads    reads
 days       journeys  places   entries

# Every view reads the model. No view edits it.
# Change the model once; every view redraws from the new truth.

Exercise

Look at an app you use that shows the same data in more than one way — a calendar with month/week/day views, a project tool with board/list/timeline. Ask: is there one model underneath that every view reads, or does each view maintain its own state that can drift? Find a moment where two views of the same data disagreed. That disagreement is a private copy leaking.

Hint

The clean test: if editing in one view instantly and correctly updates every other view, there's one model underneath. If you ever have to 'refresh' or 'sync' a second view, it was holding its own copy — and copies drift.