From 9c9e78f6f90175130b26fb3d034184627dcb4d11 Mon Sep 17 00:00:00 2001
From: Kartios <kartitripathi@gmail.com>
Date: Fri, 7 Aug 2026 05:50:32 -0700
Subject: [PATCH] The Southland gets a door, and the people in it move
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

**Mateo Court**, a courtyard block in the Arts District — a third pack and
a third *kind* of building. Two office floors and a shed already existed,
so this is the plan the format had not been shown: a ring of rooms round
an open-air yard with **no corridor anywhere**. Every door opens onto the
yard, and the yard does the job a corridor does in the other two. It is
also the first pack whose `ceiling: null` means there is genuinely no
ceiling at any height rather than "take the lid off so the shot can see
in", and the first sited off the Bay Area board at all.

That last part needed a fix, not just a coordinate. `OFFICE_MARKERS` was
gated on `id === "sf"`, which was correct for exactly as long as every
office was in the Bay Area — it would have kept the Los Angeles building
off the Los Angeles board and pinned it to San Francisco's. The gate is
the board's own bounds now, which is the same question asked honestly.

Every door through the 0.25 m courtyard skin is 1.2 m rather than the
usual 0.9, and that is not a style choice: `blocked` inflates by the
walker's radius *and* the wall's thickness, so a 0.9 m leaf through a wall
that thick seals the room behind it while rendering perfectly. Two rooms
were sealed exactly that way on the first pass. The test says so, because
a well-meaning edit back to 0.9 for consistency would do it again.

**People move.** `samplePresenceAt` thinned the roster by hour, which
fixed a building that was full at 1 a.m., but everybody was still pinned
to their own desk all day. Occupancy is a hand-written booking table now:
meetings fill a room for a plausible length, the kitchen island fills at
lunch, and a `Presence` binds to a seat id — so "in a meeting" means
occupying a meeting-room seat, and the whole thing is choosing seat ids
rather than inventing positions.

The flood fill that checks a pack is walkable existed three times over.
One copy now, since the third is where a divergence lives.

**Films.** A new `office-dusk` reel — six hours over Lumbridge HQ catching
the moment the house lights take over from the sun, which is the one thing
only a time-lapse can show and which did not exist. The three existing
reels are re-rendered rather than re-captioned: `films.ts` in v4 named a
commit eleven behind HEAD, so the published reels were shot before there
were any clouds and before the city drew office pins.

Reviewers caught roughly a dozen false statements in the new prose across
these files — a room census that did not add up, a wall-thickness count,
a claim that every room has daylight when one does not, and a cost figure
saying `updateSun` runs once a second when it runs once a minute. The
consequential ones are fixed. In a codebase where the comments are the
design record, a confident wrong number is a defect.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 scripts/brand-assets/films.mjs |  146 ++-
 src/adapters/sample.ts         |  828 +++++++++++++---
 src/main.ts                    |   30 +-
 src/offices/mateo-court.ts     | 1650 ++++++++++++++++++++++++++++++++
 src/offices/sites.ts           |   21 +-
 src/test/office.test.ts        |  174 +++-
 6 files changed, 2700 insertions(+), 149 deletions(-)
 create mode 100644 src/offices/mateo-court.ts

diff --git a/scripts/brand-assets/films.mjs b/scripts/brand-assets/films.mjs
index 2967640..d0d2f86 100644
--- a/scripts/brand-assets/films.mjs
+++ b/scripts/brand-assets/films.mjs
@@ -84,13 +84,24 @@ const deliverSize = (spec) => {
 };
 
 /**
- * `chapter` and `expect` work exactly as they do in `shots.mjs` — an index into
- * the chapter list, and the `shortLabel` it is asserted to be.
+ * `door`, `chapter` and `expect` work exactly as they do in `shots.mjs`: which
+ * building the engine is showing, an index into the chapter list, and the
+ * `shortLabel` that index is asserted to be before the shutter opens.
  *
- * `from` and `to` are the ends of the day the camera watches. They are not
- * midnight to midnight: the hours either side of dawn and dusk are the whole
- * point and the small hours are eighteen identical dark frames, so the window
- * is cropped to the part that moves.
+ * What is deliberately *not* carried over is `shots.mjs`'s `office` field and
+ * the picker press behind it. Every film below is of the building its door opens
+ * on, so that press would be a capture path no film exercises — and an untried
+ * step in a pipeline is worse than an absent one, because it looks like coverage.
+ * A Frontier Valley film means porting those fifteen lines along with it; the
+ * office entry at the bottom says why the hangar is the second office film to
+ * shoot rather than the first.
+ *
+ * `from` and `to` are the ends of the stretch of day the camera watches, and
+ * every film crops to the part of it that moves. For the city films that means
+ * dropping the small hours, which are dark frames indistinguishable from each
+ * other; for `office-dusk` it means a window narrow enough that the lights
+ * coming on lasts half a second instead of one frame. `hero-soma` is the
+ * exception, and argues for itself on its own entry.
  */
 const FILMS = [
   {
@@ -108,7 +119,7 @@ const FILMS = [
     poster: 0.86,
     place: "Financial District, San Francisco",
     caption:
-      "One camera, eighteen hours, six seconds. Nothing here is keyframed: every frame is the engine asked for a different instant, and the light, the shadows, the sky and the window lights all follow from that one number. The clock in the corner is the film captioning itself.",
+      "One camera, eighteen hours, six seconds. Nothing here is keyframed: every frame is the engine asked for a different instant, and the light, the shadows, the sky, the map in the corner and the window lights all follow from that one number. The readout at the top of the panel is the film captioning itself — the hour, how high the sun is, which band of twilight that puts it in, and how much of the moon is lit.",
     alt: "A time-lapse of the San Francisco financial district seen from above. Shadow sweeps across the towers as the sun crosses the sky, the water changes colour, and after sunset the tower windows light up one by one.",
   },
   {
@@ -162,15 +173,103 @@ const FILMS = [
     to: "2026-08-06T22:40:00-07:00",
     frames: 180,
     fps: 30,
-    // The region shot is the one where the day does the most work. Shadow
-    // sweeps the length of two mountain ranges, and then the thing the relief
-    // was hiding turns up: the cities, which are somewhere else entirely.
+    /**
+     * The region shot, which is now the weather film as much as the light one.
+     *
+     * This is the only one of the three city cameras that is *above* the cloud
+     * deck — `clouds.ts` sizes its own hard case off exactly this chapter, "the
+     * camera 430 units above the ground with the cloud base at 52" — so it is
+     * the only one that watches the marine layer from on top rather than from
+     * under it. And with no weather feed wired, which is what a capture against
+     * a local `dist/` always is, there is a marine layer to watch: `atmosphere.ts`
+     * models the cover from the layer's own diurnal curve on apparent solar time
+     * rather than defaulting to an empty sky. Over San Francisco on this date the
+     * model runs about 0.88 before dawn, thins to 0.27 by mid-afternoon, and is
+     * back over 0.8 by nine.
+     *
+     * **Do not judge this one from a rough cut**, and the reason is a trap worth
+     * writing down. Cover is eased toward its target over a six-second time
+     * constant in *real* time (`COVER_TAU` in `clouds.ts`), while a frame costs
+     * about half a second of real time no matter how many hours of sky it steps
+     * over — measured here at 0.51 s, by differencing an 8-frame run against a
+     * 28-frame one. So the deck always runs *behind* the day, and how far behind
+     * is decided by the frame count rather than by the weather. At `--frames 40`
+     * one frame is twenty-eight minutes of sky, the layer never gets near its
+     * target, and the board reads as permanently socked in — which it is not.
+     * At 180 frames a frame is six minutes and the lag through the steepest part
+     * of the burn-off works out around a fifth of cover: trailing, but the deck
+     * visibly opens and shuts. The frame count is part of what this picture *is*,
+     * not just how smooth it is.
+     *
+     * The poster moved off 0.20 for a related reason: 0.20 is twenty past eight
+     * in the morning, which is now a white rectangle. 0.51 is ten to two, the
+     * clearest the board gets.
+     */
     title: "A day across the whole board",
-    poster: 0.2,
+    poster: 0.51,
     place: "San Francisco Bay Area",
     caption:
-      "Relief is easiest to read when the light moves. Shadow runs the length of two mountain ranges and back, and then at the end the thing the terrain never told you appears on its own: the cities, which are somewhere else entirely.",
-    alt: "A time-lapse of the whole San Francisco Bay Area from above. Long shadows rake across the hills as the sun crosses, and after dark the built-up ground emerges as scattered clusters of light between the ranges.",
+      "Relief is easiest to read when the light moves, and this camera is high enough to read the weather the same way. With nobody to ask for an observation — which is what a fresh clone of this engine has, and what this camera had — the sky is modelled from the Pacific marine layer's own daily curve instead of left empty: the deck that covers the board before dawn burns back through the afternoon and closes in again after sunset. Under it, shadow runs the length of two mountain ranges and back — and at the end the thing the terrain never told you comes through the gaps, which is the cities, which are somewhere else entirely.",
+    alt: "A time-lapse of the whole San Francisco Bay Area from above, seen from over a cloud deck. The cloud covers the board at dawn, thins through the middle of the day to let long shadows rake across the hills and the bay show through, then closes back in at dusk, after which the built-up ground reads as scattered clusters of light between the dark ranges.",
+  },
+  {
+    /**
+     * The one film the stills cannot stand in for.
+     *
+     * `office-floor` in `shots.mjs` is this exact camera at two hours — 11:20 and
+     * 21:30 — and that pair is a fair account of both of them. What a pair cannot
+     * show is the part in between, which is the part that is actually the claim:
+     * the building has no night theme, it has a sun going down, and the fittings
+     * come up as it does. An event with a duration wants the medium that has one.
+     *
+     * **The window is cut to the switch-over, not to the working day.**
+     * `luminaires.ts` ramps the house lights from nothing at six degrees of solar
+     * elevation to full at zero, and over this building's own coordinate on this
+     * date that band is 19:38 to 20:12 — thirty-four minutes. Spread across the
+     * eighteen-hour window the city films use it would be six frames and a
+     * blink. Across these six hours it is seventeen, a little over half a second,
+     * with another thirty-nine frames of twilight behind it in which the fittings
+     * hold the building on their own. Dawn does the same thing in reverse and is
+     * deliberately out of frame: one legible switch-over beats two unreadable
+     * ones, and a sixteen-hour window buys the second one by making both a blur.
+     *
+     * The other end is chosen too. Solar noon here is 13:15 with the sun at 69°,
+     * which is straight down into an open-topped model and flat on every surface
+     * — the interior version of the midday problem the shot list keeps away from.
+     * By half past three the sun is at 54° and falling, and the shadows on the
+     * two plates have somewhere to go for the whole reel.
+     *
+     * The last frame is 21:30, which is `office-floor`'s night frame exactly. So
+     * the film ends on the still, and anyone who suspects one of them is lying
+     * can put them side by side.
+     *
+     * `chapter: 0` is the arrival pose and needs no click. It is also the only
+     * camera that holds all forty-eight metres of the plate and both storeys at
+     * once, which is what makes this read as a *building* changing state rather
+     * than as one room dimming. The Commons was the other candidate: it shows the
+     * void far better and the ceiling far worse, and the ceiling is the subject.
+     *
+     * Lumbridge HQ rather than Frontier Valley, and the hangar is the better
+     * second film than first — it is one storey and two robots against two
+     * storeys and four, its lights are a single run of trusses, and reaching it
+     * needs the office-picker step this script does not have. See the note above
+     * `FILMS`.
+     */
+    id: "office-dusk",
+    door: "office",
+    chapter: 0,
+    expect: "The Floor",
+    from: "2026-08-06T15:30:00-07:00",
+    to: "2026-08-06T21:30:00-07:00",
+    frames: 180,
+    fps: 30,
+    /** Frame 147, twenty-five past eight: fittings at full, sky not yet black. */
+    poster: 0.82,
+    title: "Six hours in the office, and the lights taking over",
+    place: "Lumbridge HQ",
+    caption:
+      "Forty-eight metres by eighteen, two storeys with fourteen metres of interstitial between them, and a sun that belongs to the building rather than to the picture: the pack declares where on the earth it stands, so this floor is lit by the real afternoon over Transbay and switches to its own fittings as that afternoon ends. The changeover is a ramp across six degrees of solar elevation rather than a theme, which is why it takes a film to show it at all. The four Optimus units walking the two floors brighten whatever fitting they pass under.",
+    alt: "A time-lapse of an office interior seen from outside as an open-topped model, both storeys visible at once and held a long way apart. Afternoon daylight rakes across the two floor plates and the sky behind the building warms to orange and then goes dark blue; the ceiling fittings on both levels come up as it does, until the building is lit entirely from within. Small figures sit at the desks and walk between them.",
   },
 ];
 
@@ -344,22 +443,13 @@ async function film(browser, spec, dir) {
   }
 }
 
-/**
- * Frames to an MP4, plus the poster a `<video>` shows before anybody presses
- * play.
- *
- * `yuv420p` and `+faststart` are not decoration: without the first, Safari and
- * a good deal of Android will not decode the file at all, and without the
- * second the index sits at the end and the video will not begin until the whole
- * thing has arrived.
- */
 /**
  * Frames to a master, the master to deliverables, and a poster off the frames.
  *
  * Two stages rather than one, deliberately. The master is a near-lossless
  * archive encode that stays in the render directory; every shipped file is
  * derived from it. That makes "the hero is too heavy, try CRF 28" a ten-second
- * job instead of a twenty-two-minute re-shoot, and — the part that matters —
+ * job instead of a re-shoot, and — the part that matters —
  * it means what is on the site is always exactly what this script produces,
  * rather than something hand-rolled with ffmpeg the day the size became a
  * problem.
@@ -369,7 +459,11 @@ async function film(browser, spec, dir) {
  * second the index sits at the end and playback waits for the whole download.
  *
  * The poster comes off the PNG, not off the master, because it is a still and
- * has no reason to inherit a video codec's compromises.
+ * has no reason to inherit a video codec's compromises. The price of that is
+ * worth knowing before you go looking for a flag that does not exist: the frames
+ * are deleted the moment this returns, so **moving a `poster` fraction costs a
+ * re-shoot**, where moving a CRF costs ten seconds. Everything else about a film
+ * can be changed for free; that one cannot.
  */
 function encode(dir, out, fps, frames, posterAt, deliverables) {
   const ff = (...args) => execFileSync("ffmpeg", ["-y", "-loglevel", "error", ...args]);
@@ -557,8 +651,8 @@ function manifest() {
  * rewrites this file wholesale.
  *
  * To change a film or its caption: edit \`FILMS\` in that script and run it.
- * A caption-only change can use \`--manifest-only\` and skip the ~22 minutes a
- * film costs to shoot.
+ * A caption-only change can use \`--manifest-only\` and skip the shoot entirely —
+ * which is a minute and a half a film on the GPU and twenty-two without one.
  *
  * Every frame of every film below is a screenshot of tera's built \`dist/\` at
  * the commit named here, with the app's own clock stepped between frames.
diff --git a/src/adapters/sample.ts b/src/adapters/sample.ts
index 89d57e5..c0d1601 100644
--- a/src/adapters/sample.ts
+++ b/src/adapters/sample.ts
@@ -443,32 +443,96 @@ export const SAMPLE_PRESENCE_PALETTE: Record<string, number> = {
   guest: 0x7fb886,
 };
 
+
 // ---- The office, over a day ------------------------------------------------
 
 /**
- * The fabricated roster as it stands at one particular instant.
+ * The fabricated roster as it stands at one particular instant: who is in the
+ * building, and **which seat each of them is in right now**.
  *
  * `SAMPLE_PRESENCE` is a photograph of one good morning, and a photograph was
  * the whole truth for as long as the office had no clock. It is not any more.
  * The room is lit by the same sun the city is, the house lights come up as that
  * sun goes down, and the robots go on walking the floor after dark — so a
  * building with all twenty-five of these people still sitting in it at one in
- * the morning is now the least believable thing in it. Everything else in the
- * scene has learned what time it is; the people had not.
+ * the morning was the least believable thing in it. Everything else in the scene
+ * had learned what time it was; the people had not.
+ *
+ * The first version of this function fixed half of that: it thinned the roster
+ * by hour, so the floor filled and emptied. The other half is that everybody it
+ * kept was pinned to one seat from dawn to dusk, and a floor where the same
+ * twenty-five silhouettes sit in the same twenty-five chairs for eleven hours is
+ * a texture rather than a place. A real floor has people in the meeting rooms
+ * when there is a meeting, at the kitchen island at lunch, and in the lounge in
+ * the afternoon. So this now answers a harder question than "are you in": it
+ * answers "where are you", and a `Presence` binds to a `seatId`, so the whole
+ * feature is **choosing seat ids**. Nothing here invents a position; it could
+ * not if it wanted to, which is the point of the seat-id split and is argued at
+ * length on `Presence` in `interiors/types.ts`.
  *
  * This is deliberately a **pure function of an instant the caller supplies**,
  * not a ticking source. The app already has exactly one clock — the wall clock,
  * or whatever the godmode scrubber has overridden it with — and a module that
  * read `new Date()` for itself would be a second one, correct until the moment
  * somebody drags the scrubber to midnight and finds the desks still full. That
- * is the bug being fixed here, so it is not one to reintroduce one layer down.
+ * is the bug this exists to fix, so it is not one to reintroduce one layer down.
  *
- * The result is always a **subset of `SAMPLE_PRESENCE`**, which is where the two
- * sharpest constraints go away for free: one entry per seat in, one entry per
- * seat or fewer out, so the roster can never name more people than there are
- * seats, and nobody is ever moved to a seat they do not sit at. `SAMPLE_PRESENCE`
- * itself is untouched and still exported — it is what a caller with no clock,
- * and every test written before this existed, is entitled to keep getting.
+ * ### What replaced "always a subset of SAMPLE_PRESENCE"
+ *
+ * It used to be one. Returning a filtered `SAMPLE_PRESENCE` bought two hard
+ * properties for nothing — never more people than seats, and never two people in
+ * one seat — because the input already had one person per seat and filtering
+ * cannot create a collision. **That is gone**, and it has to be: a person who is
+ * at their desk at eleven and in Alcatraz at ten is by definition not always at
+ * the seat the photograph gives them. The result is still `Presence[]` and the
+ * exported signature has not moved, but the objects in it now carry seat ids
+ * that are nowhere in `SAMPLE_PRESENCE`, and a `colorKey` that can differ from
+ * the one there.
+ *
+ * The two properties are bought back a different way, and it is worth being
+ * precise because the second one is the easy bug here:
+ *
+ * - **One person, one seat.** The loop below emits at most one `Presence` per
+ *   roster entry, ever. A person is either inside exactly one booking or at
+ *   their own desk, never both, and the `bookings` list for one person is
+ *   audited at import for self-overlap. Twenty-five people therefore produce at
+ *   most twenty-five entries, at twenty-five distinct seats — so the roster can
+ *   never name more people than the floor can hold.
+ * - **One seat, one person.** This is not free and is not derivable from the
+ *   per-person view, because it is a statement about *pairs* of people. It comes
+ *   from `BOOKINGS` being a hand-written table rather than a hash: within one
+ *   booking the room seats are the object's keys, so a repeat is a **compile
+ *   error** (TS1117), and across bookings that are live at the same moment the
+ *   import-time audit at the bottom of this file checks every pair. A booking
+ *   may also never name a seat that somebody sits at all day; that is checked
+ *   too, since sending a visitor to `eng-03` would put two people in a chair
+ *   without either booking overlapping the other.
+ *
+ * `SAMPLE_PRESENCE` itself is untouched and still exported — it is what a caller
+ * with no clock, and every test written before this existed, is entitled to keep
+ * getting.
+ *
+ * ### What it costs
+ *
+ * Called on every clock tick — `updateSun` in `main.ts` runs on a once-a-minute wall-clock interval, and on every godmode scrub
+ * — and on every frame of a godmode scrub, so it is worth stating rather than
+ * hoping.
+ *
+ * Per call: one pass over the twenty-five-entry roster; for each person a walk
+ * of their own bookings which stops at the first one starting after `t`; and for
+ * whoever is not in a booking, four number comparisons against a day that was
+ * computed once. Summed over the roster the booking walk is bounded by the whole
+ * table — fifty seat assignments across fifteen bookings, nobody holding more
+ * than four — so the worst case is a couple of hundred number comparisons.
+ * **Nothing is allocated except the result array**: every `Presence` this can
+ * return, at a desk or in a room, is built once at import and handed out by
+ * reference, exactly as the old filter handed out `SAMPLE_PRESENCE`'s own
+ * objects. There is no hashing on this path at all; the hashes run once per seat
+ * while `ROSTER` is built.
+ *
+ * Import-time work is the roster build and the audit, together a couple of
+ * thousand comparisons over those fifty entries, once, and neither of them on
+ * any frame.
  *
  * ### No weekend, on purpose
  *
@@ -492,24 +556,31 @@ export const SAMPLE_PRESENCE_PALETTE: Record<string, number> = {
  *
  * `when.getHours()` — the viewer's local time, matching `#clock`, the godmode
  * scrubber and every other reading of a `Date` in this app. That is right for
- * the flagship case and imperfect for one that exists: both shipped buildings
- * stand in San Francisco, but the sun in the windows is computed from the site's
- * latitude and longitude while the roster here follows the viewer, so a visitor
- * in another time zone gets a floor that fills up at their nine o'clock under a
- * sky that belongs to the building's. Fixing that properly needs a real time
- * zone on `OfficeSite`, which is a change to the office contract and not to a
- * demo adapter. Guessing one from `site.lng` is *not* the fix and was rejected:
- * a longitude gives you mean solar time, and it knows nothing about daylight
- * saving. The two shipped sites sit at -122.40° and -122.32°, seven kilometres
- * apart, which is about 8 h 10 m of solar offset — ten minutes adrift of Pacific
- * Standard Time, and seventy minutes adrift of the clock for the two thirds of
- * the year that are daylight time. That is wrong in the way that looks right.
- * Until there is a real zone, a caller that genuinely knows the building's can
- * shift the `Date` it passes.
+ * the flagship case and imperfect for one that exists: the sun in the windows is
+ * computed from the site's latitude and longitude while the roster here follows
+ * the viewer, so a visitor in another time zone gets a floor that fills up at
+ * their nine o'clock under a sky that belongs to the building's. Fixing that
+ * properly needs a real time zone on `OfficeSite`, which is a change to the
+ * office contract and not to a demo adapter. Guessing one from `site.lng` is
+ * *not* the fix and was rejected: a longitude gives you mean solar time, and it
+ * knows nothing about daylight saving. Until there is a real zone, a caller that
+ * genuinely knows the building's can shift the `Date` it passes.
  */
 export function samplePresenceAt(when: Date): Presence[] {
   const t = when.getHours() * 60 + when.getMinutes() + when.getSeconds() / 60;
-  return SAMPLE_PRESENCE.filter((person) => isPresentAt(person, t));
+  const out: Presence[] = [];
+  for (const person of ROSTER) {
+    // A booking wins outright. Somebody in a meeting is not also at their desk,
+    // and the order of these two branches is the entire "one person, one seat"
+    // guarantee for a single roster entry.
+    const booked = bookedAt(person, t);
+    if (booked) {
+      out.push(booked);
+      continue;
+    }
+    if (person.desk && isIn(person.desk.day, t)) out.push(person.desk.at);
+  }
+  return out;
 }
 
 /**
@@ -521,7 +592,40 @@ function at(hour: number, minute: number): number {
 }
 
 /**
- * The three shifts that are *not* seeded, and the reason the building is never
+ * Where the six people the photograph catches mid-meeting actually sit.
+ *
+ * `SAMPLE_PRESENCE` is a snapshot at one moment, so for most of the roster the
+ * seat it gives somebody *is* their desk and this table has nothing to say. For
+ * the six in Alcatraz it is not: the snapshot caught them in a room they were
+ * booked into, and a model of a whole day needs to know where they go when the
+ * meeting ends. "Somebody in Alcatraz at 10:00 is at their desk at 11:00" is the
+ * requirement, and this is the line that says which desk.
+ *
+ * The alternative was to move them to desks in `SAMPLE_PRESENCE` itself and let
+ * the schedule put them back in the room. That was rejected because the snapshot
+ * is a deliberately varied fixture — its own comment lists the spread as the
+ * reason it exists — and a `SAMPLE_PRESENCE` in which everybody sits at a desk
+ * exercises exactly one kind of seat. Six lines here cost less than that.
+ *
+ * Keyed on the snapshot's seat rather than on the person id for the same reason
+ * `deskDay` is seeded from the seat: the seat is the address, and renaming
+ * Cormac Dellwood should not move anybody's desk. The desks chosen are free ones
+ * — nobody else in the roster sits at a `sales-*` station, at `design-02`,
+ * `ops-04` or `eng-07` — which the audit below rechecks, because two people
+ * sharing a home desk would be a permanent double occupancy rather than an
+ * occasional one.
+ */
+const DESKS: Record<string, string> = {
+  "alcatraz-01": "sales-01",
+  "alcatraz-02": "sales-02",
+  "alcatraz-03": "sales-03",
+  "alcatraz-06": "design-02",
+  "alcatraz-07": "ops-04",
+  "alcatraz-08": "eng-07",
+};
+
+/**
+ * The three shifts that are *not* hashed, and the reason the building is never
  * empty during working hours.
  *
  * Everyone else's day is drawn from a hash, and a hash makes no promises: there
@@ -544,9 +648,17 @@ function at(hour: number, minute: number): number {
  * step out at half past twelve is precisely the accident that would put an empty
  * floor on screen at the one hour nobody would think to check.
  *
- * The keys are seat ids and they must exist in `SAMPLE_PRESENCE`; see the check
- * below, which is there because renaming a seat would otherwise dissolve the
- * guarantee without a word.
+ * A booking does **not** break the guarantee, and this is the thing to check
+ * before adding one. All three anchors are in `BOOKINGS` — the ops shift at the
+ * morning stand-up, reception in Bernal at twenty to four, the late engineer in
+ * Alcatraz and then alone in the kitchen at quarter past seven — but a booking
+ * *relocates* somebody, it never removes them. The claim above is that the floor
+ * is not empty, not that any particular chair is filled, so an anchor who is in
+ * a meeting still holds it up.
+ *
+ * The keys are desk seat ids and they must belong to somebody in the roster; see
+ * the audit below, which is there because renaming a seat would otherwise
+ * dissolve the guarantee without a word.
  */
 const PRESENCE_ANCHORS: Record<string, { from: number; to: number }> = {
   "ops-01": { from: at(6, 15), to: at(15, 5) },
@@ -555,75 +667,460 @@ const PRESENCE_ANCHORS: Record<string, { from: number; to: number }> = {
 };
 
 /**
- * Two bookings in Alcatraz, and nothing else all day.
+ * One room, booked, with a named person in each chair.
  *
- * A meeting room whose chairs are full at eight in the evening is the same lie
- * as a floor whose desks are, one room in — worse, really, because a meeting is
- * the one thing in an office that everybody knows has a start and an end.
+ * `seats` is keyed on the **room seat** and valued with the occupant's **desk
+ * seat**, which is the opposite of how it reads out loud and is that way round
+ * on purpose: object keys are unique, so a table that puts two people in
+ * `alcatraz-03` does not compile (TS1117). The single easiest mistake in this
+ * whole feature is caught by `tsc` rather than by anybody noticing two figures
+ * z-fighting in one chair.
  */
-const PRESENCE_SESSIONS: { from: number; to: number; attendance: number }[] = [
-  { from: at(9, 40), to: at(10, 30), attendance: 0.8 },
-  { from: at(14, 5), to: at(15, 15), attendance: 0.6 },
+interface Booking {
+  /** For the audit's messages. Nothing reads it at runtime. */
+  room: string;
+  from: number;
+  to: number;
+  /** The `colorKey` an occupant wears while they are here. See `isGuest`. */
+  colorKey: string;
+  /** Room seat -> the desk seat of whoever is in it. */
+  seats: Record<string, string>;
+}
+
+/**
+ * The day's diary: fifteen bookings, fifty chairs filled, hand-written.
+ *
+ * ### Why this is a table and not code
+ *
+ * The obvious shape is generative — hash a person against a session the way
+ * `deskDay` hashes their arrival, and let the room fill up. That is what the
+ * previous version did for its two Alcatraz sessions, and it needed a designated
+ * chair-of-the-meeting to stop the room drawing empty on an unlucky seed. Scaled
+ * up to the nine places this table books, it fails for reasons that are not
+ * about taste:
+ *
+ * - **Collisions become a search problem.** Two independently-hashed sessions
+ *   that overlap in time can pick the same room, and two independently-hashed
+ *   people can pick the same chair. Fixing that at read time means resolving
+ *   conflicts against whoever else happens to be present — and a resolution that
+ *   depends on the rest of the roster is a decision that changes as the clock
+ *   moves. That is the popping this whole section is built to avoid: person B
+ *   would slide from `kitchen-02` to `kitchen-03` at the instant person A walked
+ *   in, for no reason a viewer could see.
+ * - **A hash cannot make a meeting look like a meeting.** Six named people round
+ *   one table for fifty minutes is the thing worth drawing. A per-person
+ *   probability will happily put one person alone in a ten-seat board room —
+ *   that is precisely the failure the old chair-of-the-meeting rule was there to
+ *   paper over — and every fix for it, a threshold, a floor on attendance, a
+ *   quorum, is another coefficient that adds up to writing the guest list badly.
+ * - **The invariant becomes visible.** Read down `seats` and you can see that
+ *   nobody is in two rooms; that is not a property you can read off a hash at
+ *   all, only test for.
+ *
+ * So the diary is data. It is also the honest shape for this file, whose header
+ * has said from the first line that everything in it is invented: a day somebody
+ * wrote down is more obviously fiction than a day a hash produced, not less.
+ *
+ * ### The shape of the day
+ *
+ * Ops stand up at twenty past nine, five of six round Bernal. The big review
+ * fills eight of Alcatraz's ten from five to ten until quarter to eleven. A
+ * visitor waits in reception, is taken into Bolinas, and leaves. Somebody sits
+ * in Lands End with the door shut for an hour — one person in a two-seat quiet
+ * room is what a quiet room looks like, and it is the one place on this floor
+ * where a single occupant is the correct picture rather than a failed meeting.
+ * Lunch is two sittings, because thirteen of these seat ids draw a hashed lunch
+ * window and the kitchen has five seats. Ten of the thirteen eat here; the other
+ * three go out and are simply gone, which is the truth about a lunch hour and is
+ * why the building thins at half past twelve without emptying. The afternoon is
+ * a lounge, a
+ * second Alcatraz session, a Bernal, two focus booths and a second visitor. The
+ * late engineer eats alone in the kitchen at quarter past seven.
+ *
+ * ### Constraints an edit has to keep
+ *
+ * All of these are checked at import, so breaking one is a line in the console
+ * and not a mystery on screen:
+ *
+ * 1. Every value is the desk seat of somebody in `ROSTER`.
+ * 2. No room seat is anybody's desk. Bookings move people to rooms, never into
+ *    another person's chair.
+ * 3. Bookings that are live at the same instant share neither a room seat nor a
+ *    person.
+ *
+ * There is a fourth that is not checked and does not need to be: every booking
+ * here lies inside its attendee's working day. `dayFor` widens a day to cover
+ * its bookings anyway, so a booking that ran past somebody's departure would
+ * keep them in the building rather than making them flicker — but as authored,
+ * with the hashed days these seat ids produce, that widening is a no-op today.
+ * It is there so that the *next* edit to this table cannot open a hole.
+ */
+const BOOKINGS: Booking[] = [
+  {
+    // Ops, standing up. The early shift is an anchor and is in from a quarter
+    // past six; the other four draw arrivals between half seven and a quarter
+    // to nine, so nobody here is being dragged in for their own stand-up.
+    room: "Bernal",
+    from: at(9, 20),
+    to: at(9, 50),
+    colorKey: "meeting",
+    seats: {
+      "bernal-01": "ops-01", // Anouk Sterling
+      "bernal-02": "ops-02", // Emeka Farrow
+      "bernal-03": "ops-05", // Bettina Kovač
+      "bernal-04": "ops-10", // Aurelio Pinsent
+      "bernal-05": "ops-04", // Vasco Underhill
+    },
+  },
+  {
+    // The morning review — eight of ten, which is what a full room looks like
+    // without being a roll call. The six the photograph caught are all here.
+    room: "Alcatraz",
+    from: at(9, 55),
+    to: at(10, 45),
+    colorKey: "meeting",
+    seats: {
+      "alcatraz-01": "sales-01", // Cormac Dellwood
+      "alcatraz-02": "sales-02", // Solveig Amankwah
+      "alcatraz-03": "sales-03", // Ignatius Pell
+      "alcatraz-04": "design-02", // Rosalind Achebe
+      "alcatraz-05": "design-01", // Halcyon Reeve
+      "alcatraz-06": "ops-04", // Vasco Underhill
+      "alcatraz-07": "eng-07", // Clementine Roux
+      "alcatraz-08": "eng-01", // Tobias Quillon
+    },
+  },
+  {
+    // The visitor waiting, which is a booking of the lobby sofa by the person
+    // who has no desk to be at instead. `lobby-01 -> lobby-01` looks like a
+    // no-op and is the point: a guest is in the building only when the diary
+    // says so, so their whole day is bookings and there is no fall-through.
+    room: "Reception",
+    from: at(10, 15),
+    to: at(10, 35),
+    colorKey: "guest",
+    seats: { "lobby-01": "lobby-01" },
+  },
+  {
+    // ...and then taken in. Three in the four-seat room.
+    room: "Bolinas",
+    from: at(10, 35),
+    to: at(11, 20),
+    colorKey: "meeting",
+    seats: {
+      "bolinas-01": "design-03", // Zephyrine Mbeki
+      "bolinas-02": "eng-02", // Ines Marchetti
+      "bolinas-03": "lobby-01", // the visitor, who stays green — see `isGuest`
+    },
+  },
+  {
+    // Lands End, door shut, one person. See the note on quiet rooms above.
+    room: "Lands End",
+    from: at(11, 0),
+    to: at(12, 0),
+    colorKey: "focus",
+    seats: { "quiet-01": "eng-05" }, // Casimir Vane
+  },
+  {
+    // First sitting. Every one of these five has a hashed lunch window that
+    // overlaps this, so `dayFor` drops the window and they eat here instead of
+    // vanishing — which is the point of putting the island in the diary at all.
+    room: "Kitchen",
+    from: at(12, 5),
+    to: at(12, 40),
+    colorKey: "in",
+    seats: {
+      "kitchen-01": "design-03", // Zephyrine Mbeki
+      "kitchen-02": "eng-06", // Perpetua Nkemelu
+      "kitchen-03": "design-01", // Halcyon Reeve
+      "kitchen-04": "sales-01", // Cormac Dellwood
+      "kitchen-05": "ops-05", // Bettina Kovač
+    },
+  },
+  {
+    // Second sitting, five minutes after the first clears.
+    room: "Kitchen",
+    from: at(12, 45),
+    to: at(13, 20),
+    colorKey: "in",
+    seats: {
+      "kitchen-01": "design-04", // Ptolemy Sandoval
+      "kitchen-02": "ops-07", // Xiomara Belfry
+      "kitchen-03": "eng-04", // Sunniva Holt
+      "kitchen-04": "eng-01", // Tobias Quillon
+      "kitchen-05": "booth-02", // Ottoline Grieve
+    },
+  },
+  {
+    // Two in the afternoon, all four lounge chairs.
+    room: "Lounge",
+    from: at(14, 5),
+    to: at(14, 45),
+    colorKey: "in",
+    seats: {
+      "lounge-01": "eng-03", // Dara Oyelaran-Pike
+      "lounge-02": "ops-02", // Emeka Farrow
+      "lounge-03": "design-02", // Rosalind Achebe
+      "lounge-04": "eng-08", // Rafferty Osgood
+    },
+  },
+  {
+    // The long one. Overlaps the lounge above by twenty-five minutes and shares
+    // nobody with it, which is the pair the audit is really watching.
+    room: "Alcatraz",
+    from: at(14, 20),
+    to: at(15, 25),
+    colorKey: "meeting",
+    seats: {
+      "alcatraz-01": "sales-02", // Solveig Amankwah
+      "alcatraz-02": "sales-03", // Ignatius Pell
+      "alcatraz-03": "eng-11", // Marisol Thibault
+      "alcatraz-04": "design-01", // Halcyon Reeve
+      "alcatraz-05": "ops-05", // Bettina Kovač
+      "alcatraz-06": "eng-06", // Perpetua Nkemelu
+    },
+  },
+  {
+    // Heads-down until five. A booth is one seat, which is the point of it.
+    room: "Focus booth 1",
+    from: at(15, 30),
+    to: at(17, 0),
+    colorKey: "focus",
+    seats: { "booth-01": "eng-07" }, // Clementine Roux
+  },
+  {
+    // The second visitor, waiting while reception is still at the front desk.
+    room: "Reception",
+    from: at(15, 20),
+    to: at(15, 40),
+    colorKey: "guest",
+    seats: { "lobby-01": "lobby-01" },
+  },
+  {
+    // Handed over at twenty to four, which is also when reception leaves the
+    // desk for Bernal below. That is a story and not a coincidence.
+    room: "Bolinas",
+    from: at(15, 40),
+    to: at(16, 15),
+    colorKey: "meeting",
+    seats: {
+      "bolinas-01": "sales-01", // Cormac Dellwood
+      "bolinas-02": "design-03", // Zephyrine Mbeki
+      "bolinas-03": "lobby-01", // the visitor
+    },
+  },
+  {
+    room: "Bernal",
+    from: at(15, 40),
+    to: at(16, 20),
+    colorKey: "meeting",
+    seats: {
+      "bernal-01": "eng-02", // Ines Marchetti
+      "bernal-02": "eng-04", // Sunniva Holt
+      "bernal-03": "ops-07", // Xiomara Belfry
+      "bernal-04": "design-04", // Ptolemy Sandoval
+      "bernal-05": "reception-01", // Wren Abaddon, off the front desk
+    },
+  },
+  {
+    room: "Focus booth 3",
+    from: at(16, 40),
+    to: at(17, 45),
+    colorKey: "focus",
+    seats: { "booth-03": "sales-03" }, // Ignatius Pell
+  },
+  {
+    // The late shift eats alone at quarter past seven, in a building that by
+    // then holds one or two people. This is the booking that makes the evening
+    // read as an evening rather than as one figure that never moves.
+    room: "Kitchen",
+    from: at(19, 15),
+    to: at(19, 40),
+    colorKey: "in",
+    seats: { "kitchen-04": "eng-11" }, // Marisol Thibault
+  },
 ];
 
-/**
- * Whoever booked the room is in it.
- *
- * Without this a session can come round and, on this seed or the next one, draw
- * nobody — and a lit meeting room with an empty table for fifty minutes reads as
- * the seat binding having failed rather than as a meeting that was cancelled.
- * The other five chairs are left to the hash, which is what makes the room look
- * like a meeting rather than like a roll call.
- */
-const PRESENCE_SESSION_CHAIR = "alcatraz-01";
+/** One person's whole day, resolved once. */
+interface Rostered {
+  /** The desk seat, which is the key everything else about this person is on. */
+  home: string;
+  /**
+   * Where they are when nothing is booked, and when they are there at all.
+   *
+   * The two travel together in one object so that the check in
+   * `samplePresenceAt` narrows both at once. `null` for the visitor, who has no
+   * desk and exists only inside a booking.
+   */
+  desk: { at: Presence; day: DeskDay } | null;
+  /** Their own bookings, earliest first, audited not to overlap each other. */
+  bookings: Episode[];
+}
+
+/** One person, in one room, for one window. */
+interface Episode {
+  from: number;
+  to: number;
+  /**
+   * The finished `Presence`, built at import.
+   *
+   * A person's diary never changes, so neither does the object describing them
+   * in it, and building one per call would be twenty-five allocations a second
+   * to produce values that are already known. This is what lets
+   * `samplePresenceAt` allocate nothing but its result array.
+   */
+  who: Presence;
+}
 
 /**
- * When the visitor is in the building.
+ * A guest stays a guest wherever they are sitting.
  *
- * Two short windows, because the lobby seat is the one place on this floor where
- * a permanent occupant is obviously wrong: somebody who has been waiting in
- * reception since dawn is not a guest, they are furniture.
+ * The `colorKey` on a booking describes the *room* — amber for a booth, the
+ * meeting red for a table — and it is right for the twenty-four people who work
+ * here. It is wrong for the one who does not: the green is the only hue that is
+ * not in the office's own materials precisely because a visitor is the one
+ * person in the building who is not part of it, and a visitor who turns red on
+ * walking into Bolinas has lost the only thing that marked them out.
+ *
+ * `colorKey` is opaque to the engine and to `presence.ts` — that is the contract
+ * and it is not being bent here — but this module *defines* these keys, in
+ * `SAMPLE_PRESENCE_PALETTE` above, so it is the one place in the repo entitled
+ * to know that `"guest"` means somebody is a guest.
  */
-const PRESENCE_VISITS: { from: number; to: number }[] = [
-  { from: at(10, 5), to: at(10, 50) },
-  { from: at(15, 20), to: at(15, 55) },
-];
+function isGuest(person: Presence): boolean {
+  return person.colorKey === "guest";
+}
 
 /**
- * Is this person in the building at `t` minutes past local midnight?
+ * The roster, resolved: twenty-five people, each with a desk, a day and a diary.
  *
- * Four models, chosen by what the roster already says about the person rather
- * than by a second table of seat ids that would drift out of step with the
- * first. `colorKey` is opaque to the engine and to `presence.ts` — that is the
- * contract and it is not being bent here — but this module *defines* those keys,
- * a few lines up in `SAMPLE_PRESENCE_PALETTE`, so it is the one place in the
- * repo entitled to know that `"meeting"` means somebody is in a meeting.
+ * Built at import rather than lazily, because the audit at the bottom of this
+ * file has to walk the same tables anyway and two passes over fifty entries at
+ * module load is not a cost worth deferring. `SAMPLE_PRESENCE` is a constant and
+ * this file is the only thing that writes it, so there is nothing to invalidate.
  */
-function isPresentAt(person: Presence, t: number): boolean {
-  const anchor = PRESENCE_ANCHORS[person.seatId];
-  if (anchor) return t >= anchor.from && t < anchor.to;
+const ROSTER: Rostered[] = SAMPLE_PRESENCE.map((person) => {
+  const home = DESKS[person.seatId] ?? person.seatId;
+  const bookings = bookingsFor(person, home);
+  if (isGuest(person)) return { home, desk: null, bookings };
 
-  if (person.colorKey === "guest") {
-    return PRESENCE_VISITS.some((visit) => t >= visit.from && t < visit.to);
+  const anchor = PRESENCE_ANCHORS[home];
+  // An anchor is a fixed day with no lunch hole, which is exactly a `DeskDay`
+  // with an empty interval in it — so the two kinds of person go down one path
+  // from here rather than two. `t >= 0 && t < 0` is false at every instant,
+  // which is what "takes no lunch break" means arithmetically.
+  const base: DeskDay = anchor
+    ? { arrive: anchor.from, leave: anchor.to, lunchFrom: 0, lunchTo: 0 }
+    : deskDay(home);
+
+  return {
+    home,
+    desk: {
+      // The snapshot's colour describes the snapshot. `"meeting"` is a statement
+      // about a room, and a person sitting at their own desk wearing it would be
+      // telling the viewer they were somewhere they are not; the other three
+      // keys — in, focus, guest — are statements about the person and survive.
+      at: { ...person, seatId: home, colorKey: person.colorKey === "meeting" ? "in" : person.colorKey },
+      day: dayFor(base, bookings),
+    },
+    bookings,
+  };
+});
+
+/**
+ * Everything in `BOOKINGS` that names this person, earliest first.
+ *
+ * O(bookings × seats) per person and therefore O(people × table) overall, which
+ * is twenty-five passes over fifty entries at import and nothing at all
+ * afterwards. The obvious index — invert the table once into a map keyed on desk
+ * seat — would save about twelve hundred string comparisons that happen once,
+ * and cost a reader a level of indirection between the diary they are editing
+ * and the thing that reads it.
+ */
+function bookingsFor(person: Presence, home: string): Episode[] {
+  const out: Episode[] = [];
+  for (const booking of BOOKINGS) {
+    for (const [roomSeat, deskSeat] of Object.entries(booking.seats)) {
+      if (deskSeat !== home) continue;
+      out.push({
+        from: booking.from,
+        to: booking.to,
+        who: {
+          ...person,
+          seatId: roomSeat,
+          colorKey: isGuest(person) ? person.colorKey : booking.colorKey,
+        },
+      });
+    }
+  }
+  out.sort((a, b) => a.from - b.from);
+  return out;
+}
+
+/**
+ * One person's day, widened to make room for their diary.
+ *
+ * Two adjustments, both computed once and both therefore free of the popping a
+ * clock-dependent adjustment would cause:
+ *
+ * **The day covers its bookings.** A meeting that starts before somebody's
+ * hashed arrival, or runs past their hashed departure, would otherwise show them
+ * appearing for the meeting, vanishing when it ended, and reappearing at their
+ * own arrival time — present, absent, present, which is worse than either. As
+ * authored no booking in the table needs this; it is here so that the next one
+ * cannot open that hole. Note that widening can only ever add minutes, so it
+ * cannot shorten an anchor's shift or break the coverage guarantee.
+ *
+ * **A booking over lunch replaces lunch.** Somebody who spent half past twelve
+ * at the kitchen island did not also go out to eat. Without this, the ten people
+ * the diary feeds would still be carrying their own hashed lunch window
+ * underneath it, and the leftovers of that window would show on both sides of
+ * the meal: they would vanish from their desks a few minutes before the sitting
+ * they are about to be seen at, and four of the five in the first sitting would
+ * stand up from the island straight into what was left of it — for `ops-05`,
+ * whose window runs to 13:06 against a sitting that clears at 12:40,
+ * twenty-six minutes of absence beginning the moment the room emptied.
+ *
+ * The whole hole is dropped rather than trimmed to what the booking does not
+ * cover. A trimmed hole leaves exactly those leftovers, of whatever length the
+ * two hashes happen to disagree by, and an absence whose length nobody chose is
+ * a glitch rather than a lunch.
+ */
+function dayFor(day: DeskDay, bookings: Episode[]): DeskDay {
+  if (bookings.length === 0) return day;
+
+  let first = Infinity;
+  let last = -Infinity;
+  let overLunch = false;
+  for (const booking of bookings) {
+    first = Math.min(first, booking.from);
+    last = Math.max(last, booking.to);
+    // Half-open intervals, so touching at an endpoint is not an overlap.
+    if (booking.from < day.lunchTo && booking.to > day.lunchFrom) overLunch = true;
   }
 
-  if (person.colorKey === "meeting") {
-    return PRESENCE_SESSIONS.some(
-      (session, index) =>
-        t >= session.from &&
-        t < session.to &&
-        (person.seatId === PRESENCE_SESSION_CHAIR ||
-          unit(person.seatId, `session-${index}`) < session.attendance),
-    );
-  }
+  return {
+    arrive: Math.min(day.arrive, first),
+    leave: Math.max(day.leave, last),
+    lunchFrom: overLunch ? 0 : day.lunchFrom,
+    lunchTo: overLunch ? 0 : day.lunchTo,
+  };
+}
 
-  const day = deskDay(person.seatId);
-  if (t < day.arrive || t >= day.leave) return false;
-  // Out at lunch, for those who go. Deliberately checked after the arrive/leave
-  // pair rather than folded into it, because these are two different facts about
-  // a person and a single boolean expression covering both is the one that grows
-  // an off-by-one the first time somebody edits it.
-  return !(t >= day.lunchFrom && t < day.lunchTo);
+/**
+ * The booking this person is inside at `t`, or `null`.
+ *
+ * The list is sorted and a person's bookings never overlap each other — audited
+ * below — so the first one whose window contains `t` is the only one that can,
+ * and the scan can stop as soon as it reaches one that has not started yet.
+ * Nobody in the current table has more than four.
+ */
+function bookedAt(person: Rostered, t: number): Presence | null {
+  for (const booking of person.bookings) {
+    if (t < booking.from) break;
+    if (t < booking.to) return booking.who;
+  }
+  return null;
 }
 
 /** One desk worker's day, in minutes since local midnight. */
@@ -635,12 +1132,17 @@ interface DeskDay {
 }
 
 /**
- * Memoised because a seat's day never changes. `samplePresenceAt` may be called
- * on every clock tick and on every frame of a scrub, and re-hashing six streams
- * per person per call to get an answer that is by construction the same answer
- * is work nobody asked for.
+ * Is somebody with this day at their own desk at `t`?
+ *
+ * The lunch hole is deliberately checked after the arrive/leave pair rather than
+ * folded into it, because these are two different facts about a person and a
+ * single boolean expression covering both is the one that grows an off-by-one
+ * the first time somebody edits it.
  */
-const deskDays = new Map<string, DeskDay>();
+function isIn(day: DeskDay, t: number): boolean {
+  if (t < day.arrive || t >= day.leave) return false;
+  return !(t >= day.lunchFrom && t < day.lunchTo);
+}
 
 /**
  * A believable working day for one seat, from the seat id and nothing else.
@@ -662,7 +1164,9 @@ const deskDays = new Map<string, DeskDay>();
  * twenty-four hours and each crossing goes one way. Advancing the clock by a
  * second can only change the answer for somebody whose boundary falls inside
  * that second, and it changes it once. Scrubbing backwards is symmetric for the
- * same reason.
+ * same reason. Bookings extend that property rather than spending it: a booking
+ * is two more fixed instants, so a person with four of them crosses at most a
+ * dozen times all day and every crossing is still a single, one-way step.
  *
  * Note what this is *instead of* hysteresis. Hysteresis needs memory of the last
  * answer, and this function must give the same answer on a fresh reload as it
@@ -688,30 +1192,40 @@ const deskDays = new Map<string, DeskDay>();
  * Lunch is `12:20` ± 40 min, taken away from the desk by the roughly two thirds
  * who draw under the threshold, and it lasts 24 to 52 minutes. The shortest of
  * those is still twenty-four minutes of world time, which is long enough to read
- * as somebody having gone to eat rather than as a figure that glitched.
+ * as somebody having gone to eat rather than as a figure that glitched. Ten of
+ * the people who draw a lunch are in the diary at the kitchen island instead and
+ * never leave the building; see `dayFor`.
  *
  * Every window lies inside one calendar day and none of them wraps midnight.
- * That is a constraint worth keeping: an interval that wraps needs `from > to`
- * handling in `isPresentAt`, and the first person to write one without it gets a
- * night owl who is never in rather than always.
+ * That is a constraint worth keeping, and it applies to `BOOKINGS` too: an
+ * interval that wraps needs `from > to` handling in `isIn` and `bookedAt`, and
+ * the first person to write one without it gets a night owl who is never in
+ * rather than always.
  *
  * Seeded from the **seat** id and not the person id, because the seat is the
  * address — it is what a `Presence` binds to and what survives an edit to this
  * file. Renaming Tobias Quillon should not change when the person at `eng-01`
  * comes in.
+ *
+ * ### It is no longer memoised
+ *
+ * It used to be, into a `Map`, and the reason was good: the old
+ * `samplePresenceAt` called this per person on every clock tick, so without the
+ * cache each tick re-hashed a day that was by construction the same day. That is
+ * gone. `ROSTER` now calls this exactly once per seat at import and nothing
+ * calls it again, and a cache in front of a function called once per key can
+ * only ever be wrong, never fast. Worth a paragraph rather than a silent
+ * deletion, because "it is memoised, so call it freely" was a documented
+ * property of this function and whoever adds the next caller should know it has
+ * lapsed.
  */
 function deskDay(seatId: string): DeskDay {
-  const hit = deskDays.get(seatId);
-  if (hit) return hit;
-
   const arrive = at(8, 45) + 75 * triangular(seatId, "arrive");
   const leave = at(17, 50) + 95 * triangular(seatId, "leave") + 0.6 * (arrive - at(8, 45));
   const lunchFrom = at(12, 20) + 40 * triangular(seatId, "lunch");
   const lunchLength = unit(seatId, "lunch-length") < 0.65 ? 38 + 14 * triangular(seatId, "bite") : 0;
 
-  const made: DeskDay = { arrive, leave, lunchFrom, lunchTo: lunchFrom + lunchLength };
-  deskDays.set(seatId, made);
-  return made;
+  return { arrive, leave, lunchFrom, lunchTo: lunchFrom + lunchLength };
 }
 
 /**
@@ -751,21 +1265,113 @@ function triangular(seatId: string, stream: string): number {
   return unit(seatId, `${stream}-a`) + unit(seatId, `${stream}-b`) - 1;
 }
 
+// ---- The audit -------------------------------------------------------------
+
 /**
- * The anchors have to be anchored to something.
+ * Everything the tables above promise each other, checked once at import.
  *
- * A seat id in `PRESENCE_ANCHORS` that is not in `SAMPLE_PRESENCE` matches
- * nobody, and the guarantee above quietly becomes a hope — the failure being an
- * empty office at eleven in the morning on some seeds and not others, which is
- * about the worst shape a bug can have. Twenty-five names against three ids, at
- * import, is not a cost worth measuring, and it turns that into a line in the
- * console the first time somebody renames a seat.
+ * These are all invariants of *source data* rather than runtime conditions, so
+ * this is the right place for them and there is deliberately no defensive check
+ * on the hot path. A runtime de-duplicator in `samplePresenceAt` would be code
+ * that cannot fire until somebody breaks the diary, and on the day they did it
+ * would turn a visible bug — two figures in one chair — into an invisible one,
+ * a person silently missing from the floor. Better to fail loudly here, where
+ * the thing that is wrong is twenty lines from the message.
+ *
+ * `console.warn` and not `throw`, matching the rest of this file's posture: a
+ * demo adapter with one bad row in it should still open the building.
  */
-for (const seatId of Object.keys(PRESENCE_ANCHORS)) {
-  if (!SAMPLE_PRESENCE.some((person) => person.seatId === seatId)) {
-    console.warn(
-      `[tera/sample] anchor seat "${seatId}" is not in SAMPLE_PRESENCE; ` +
-        "the sample office can now be empty during working hours",
-    );
+function auditRoster(): void {
+  const say = (message: string) => console.warn(`[tera/sample] ${message}`);
+
+  // 1. Desks are one to a person. Two roster entries resolving to the same home
+  // seat is a permanent double occupancy — every hour of every day, not just
+  // during a booking — which is the worst thing `DESKS` can get wrong.
+  const owner = new Map<string, string>();
+  for (const person of ROSTER) {
+    const name = person.desk?.at.label ?? "the visitor";
+    const held = owner.get(person.home);
+    if (held) say(`seat "${person.home}" is the home seat of both ${held} and ${name}`);
+    owner.set(person.home, name);
+  }
+
+  // 2. The anchors have to be anchored to something. A seat id in
+  // `PRESENCE_ANCHORS` that is nobody's desk matches nobody, and the continuous
+  // 06:15–22:40 guarantee quietly becomes a hope — the failure being an empty
+  // office at eleven in the morning on some seeds and not others, which is about
+  // the worst shape a bug can have.
+  for (const seatId of Object.keys(PRESENCE_ANCHORS)) {
+    if (!owner.has(seatId)) {
+      say(`anchor seat "${seatId}" is nobody's desk; the sample office can now be empty during working hours`);
+    }
+  }
+
+  // 3. Within one booking: everybody named exists, nobody is named twice, and
+  // nowhere it seats them is a desk.
+  //
+  // The last of those is the one that is easy to miss when reading the sweep
+  // below: a booking that puts somebody at `eng-03` collides with whoever lives
+  // at `eng-03` without overlapping any other *booking*, so no amount of
+  // booking-against-booking checking would ever see it. Repeating a room seat
+  // inside one booking is the fourth case and is not checked here at all,
+  // because `seats` is keyed on it and `tsc` rejects the file (TS1117).
+  const desks = new Set<string>();
+  for (const person of ROSTER) if (person.desk) desks.add(person.home);
+  for (const booking of BOOKINGS) {
+    const named = new Set<string>();
+    for (const [roomSeat, deskSeat] of Object.entries(booking.seats)) {
+      if (!owner.has(deskSeat)) say(`${label(booking)} seats "${deskSeat}", who is nobody`);
+      if (desks.has(roomSeat)) say(`${label(booking)} uses "${roomSeat}", which is somebody's desk`);
+      if (named.has(deskSeat)) say(`${label(booking)} seats "${deskSeat}" twice`);
+      named.add(deskSeat);
+    }
+  }
+
+  // 4. No two bookings that are live at the same instant share a chair or a
+  // person.
+  //
+  // Sweeping the `from` instants is exact rather than a sample, and it is the
+  // only subtle thing in this function: the set of live bookings only ever
+  // *gains* a member at some booking's `from`. So if two bookings ever overlap,
+  // they overlap at the later of their two starts, and visiting every `from`
+  // cannot miss a pair. Fifteen starts against fifty entries, once.
+  //
+  // The person half of this is also what `bookedAt` leans on when it stops its
+  // scan at the first booking that has not started: if nobody is ever in two
+  // bookings at once, the first match is the only match.
+  for (const instant of BOOKINGS.map((booking) => booking.from)) {
+    const chair = new Map<string, Booking>();
+    const busy = new Map<string, Booking>();
+    for (const booking of BOOKINGS) {
+      if (instant < booking.from || instant >= booking.to) continue;
+      for (const [roomSeat, deskSeat] of Object.entries(booking.seats)) {
+        // Same-booking repeats belong to check 3, which can name them better.
+        const other = chair.get(roomSeat);
+        if (other && other !== booking) {
+          say(`at ${clock(instant)}, "${roomSeat}" is booked by both ${label(other)} and ${label(booking)}`);
+        }
+        chair.set(roomSeat, booking);
+
+        const elsewhere = busy.get(deskSeat);
+        if (elsewhere && elsewhere !== booking) {
+          say(`at ${clock(instant)}, "${deskSeat}" is in both ${label(elsewhere)} and ${label(booking)}`);
+        }
+        busy.set(deskSeat, booking);
+      }
+    }
   }
 }
+
+/** A booking, named the way somebody scanning the diary would look for it. */
+function label(booking: Booking): string {
+  return `${booking.room} at ${clock(booking.from)}`;
+}
+
+/** `hh:mm`, for the audit's messages only. */
+function clock(t: number): string {
+  const hh = String(Math.floor(t / 60)).padStart(2, "0");
+  const mm = String(Math.floor(t % 60)).padStart(2, "0");
+  return `${hh}:${mm}`;
+}
+
+auditRoster();
diff --git a/src/main.ts b/src/main.ts
index 8ca0ac6..ac4c831 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -101,6 +101,7 @@ const CITIES: { id: string; label: string; city: City }[] = [
 const OFFICES: { id: string; label: string; load: () => Promise<{ default: Office }> }[] = [
   { id: "lumbridge-hq", label: "Lumbridge HQ", load: () => import("./offices/lumbridge-hq.ts") },
   { id: "frontier-valley", label: "Frontier Valley", load: () => import("./offices/frontier-valley.ts") },
+  { id: "mateo-court", label: "Mateo Court", load: () => import("./offices/mateo-court.ts") },
 ];
 
 const canvas = document.querySelector<HTMLCanvasElement>("#scene");
@@ -817,11 +818,28 @@ async function mountCity(id: string) {
     // not a decoration. LA gets its own weather, not San Francisco's fog.
     marineLayer: id === "sf" ? PACIFIC_MARINE_LAYER : null,
   });
-  // The offices are in the Bay Area, so they ride along with that board's
-  // markers and are absent from the Southland's — the same rule the sample set
-  // already follows, for the same reason: a pin for a building six hundred
-  // kilometres off the board is a pin in the wrong place.
-  city.setMarkers(id === "sf" ? [...markers, ...OFFICE_MARKERS] : []);
+  /**
+   * A door belongs to the board it stands on.
+   *
+   * The gate here used to be `id === "sf"`, which was correct for exactly as
+   * long as every office was in the Bay Area. It stopped being correct the
+   * moment one was not: a hard-coded city id would have kept the Los Angeles
+   * building off the Los Angeles board and pinned it to San Francisco's.
+   *
+   * So the test is the board's own bounds, which is the same question asked
+   * honestly — a pin for a building outside the rectangle being drawn is a pin
+   * in the wrong place, whichever city that happens to be. The sample company
+   * markers stay SF-only; they are sample data about one city and always were.
+   */
+  const bounds = entry.city.bounds;
+  const doors = OFFICE_MARKERS.filter(
+    (m) =>
+      m.lat >= bounds.minLat &&
+      m.lat <= bounds.maxLat &&
+      m.lng >= bounds.minLng &&
+      m.lng <= bounds.maxLng,
+  );
+  city.setMarkers(id === "sf" ? [...markers, ...doors] : doors);
   city.onChapterChange(() => renderLegend());
 
   /**
@@ -871,7 +889,7 @@ async function mountCity(id: string) {
     },
   });
   showPlan();
-  minimap.setMarkers(id === "sf" ? [...markers, ...OFFICE_MARKERS] : []);
+  minimap.setMarkers(id === "sf" ? [...markers, ...doors] : doors);
 
   // The instruments, for the one visitor in a deployment who has them. The pose
   // editor holds a `World`, a camera and a controls, so it belongs to the board
diff --git a/src/offices/mateo-court.ts b/src/offices/mateo-court.ts
new file mode 100644
index 0000000..15fc53c
--- /dev/null
+++ b/src/offices/mateo-court.ts
@@ -0,0 +1,1650 @@
+/**
+ * Mateo Court — a courtyard block in the Arts District, Los Angeles.
+ *
+ * The third office pack, and the first one on the Southern California board.
+ * `lumbridge-hq.ts` is a floor plate: fifteen rooms hung off a corridor, 188 m
+ * up a tower. `frontier-valley.ts` is a shed: one room fifty-four metres across
+ * with the meeting boxes standing in it like furniture. Both are buildings whose
+ * circulation is **indoors**, and both are on the Bay Area board.
+ *
+ * This is neither, and the difference is one hole. Take a brick block that fills
+ * its lot, lift the roof off the middle of it, and the space you are left with
+ * in the centre is not a room — it is outside. Every door in the building then
+ * opens onto it, and the corridor is a courtyard. That is a third kind of plan
+ * rather than a third decoration on the first two: there is no corridor here at
+ * all, and there is no single volume either. There is a ring of rooms and a hole.
+ *
+ * ### Why here, and why this is not a conceit
+ *
+ * The courtyard block is what Los Angeles built before it had air conditioning,
+ * and it kept building them afterwards because the climate never stopped paying
+ * for them. A plan whose circulation is open to the sky is a plan that only
+ * works where the weather lets you walk to a meeting without a coat and where
+ * the rain, when it comes, comes in a season rather than on a Tuesday. Putting
+ * one in downtown Los Angeles is not a theme; it is the local answer to the
+ * question every other pack in this directory answers with a corridor.
+ *
+ * The Arts District is where that block would be a workplace rather than
+ * housing. It is single- and double-storey brick warehouse east of Alameda,
+ * built to be loaded off railway sidings and now full of people who need a large
+ * cheap room and somewhere to put a table saw. `socal.ts` files it as
+ * `arts-district`, 12 to 48 m, "industrial" palette — a district of low masonry
+ * boxes, which is what this is one of.
+ *
+ * ### What the format has not been asked to do before, and how it went
+ *
+ * Three things, and only one of them needed any care.
+ *
+ * A **room with no ceiling that genuinely has no ceiling.** `ceiling: null` is
+ * used all over the reference pack to take the lid off for an establishing
+ * shot, and once — the commons — to mean a real double-height void. `court`
+ * here means it in a third sense: there is nothing above it at any height,
+ * because it is the sky. Nothing in the format had to change; the field already
+ * said what was needed.
+ *
+ * An **upper walkway open on one side.** The loggia is a level, for exactly the
+ * reason `frontier-valley.ts` records at length about its mezzanine: a `Room`
+ * carries a floor finish and no height, so a deck authored as a room lies on the
+ * ground with its furniture floating over it. Its open edge is a `Wall` at
+ * 1.1 m, because `Plan` derives the walk collider from the wall list and a
+ * balustrade authored as a prop is a balcony you can walk off.
+ *
+ * The **stair**, which is the one thing that had to be argued about. It stands
+ * in the courtyard, outdoors, which is the type's signature move — and it is a
+ * room with no treads in it, because nothing in the `src/assets/office/`
+ * catalogue is a stair. So `stair` is a floor finish the shape of the flight,
+ * exactly as the reference pack's `stair-core` is, and the way up is modelled as
+ * the **gap between two balustrade walls** at the head of it rather than as
+ * geometry. A pack that wants treads registers `acme:stair.dogleg` with
+ * `defineAsset` and drops it in; nothing here has to move for that to work.
+ *
+ * ### The coordinate frame
+ *
+ * Metres, `1 unit = 1 m`, floor on the XZ plane with +Y up, origin at the corner
+ * this file calls north-west. +X east, +Z south, so in plan view +Z runs down
+ * the page and the street façade along `z = 0` is at the top.
+ *
+ * As in both other packs the compass words are a reading convenience — but here
+ * they are also a claim, because `site.heading` is 36 and the sun comes in
+ * accordingly. See the note on `MATEO_COURT_SITE` below, which is where the
+ * consequences are worked through, and `interiors/types.ts` on `OfficeSite`.
+ */
+
+import type {
+  AssetId,
+  DeskBank,
+  Level,
+  Office,
+  Opening,
+  Outline,
+  Point2,
+  Prop,
+  Room,
+  Seat,
+  Viewpoint,
+  Wall,
+  Yaw,
+  Zone,
+} from "../interiors/types.ts";
+import { MATEO_COURT_SITE } from "./sites.ts";
+
+// ---- Where it stands ------------------------------------------------------
+
+
+// ---- The block ------------------------------------------------------------
+
+/**
+ * The lot, and the hole in it. Everything else in this file is measured off
+ * these six numbers, so a self-hoster with a different block starts here.
+ *
+ * 36 x 26 m is a small downtown lot: 936 m², which is a little more ground than
+ * the reference pack's whole ground floor covers. The courtyard takes 155 of it
+ * and leaves 781 m² of building, in a ring never more than 9.6 m deep. That
+ * depth is the whole reason the type works: every room in this building has a
+ * wall on the street or on the yard, so every room in this building has daylight
+ * from one side and a door on the other. A deeper ring would need a corridor to reach the middle of it, and
+ * a courtyard block with a corridor in it has stopped being a courtyard block.
+ */
+const WIDTH = 36.0;
+const DEPTH = 26.0;
+
+const COURT_W = 9.6;
+const COURT_E = 26.4;
+const COURT_N = 8.4;
+const COURT_S = 17.6;
+
+/**
+ * Ground floor to underside of the timber above: 4.4 m.
+ *
+ * A commercial storey is 2.8 (`lumbridge-hq`) and a hangar is 9
+ * (`frontier-valley`). A brick-and-timber warehouse is neither, and the number
+ * is what makes it read as one: high enough that the windows are tall and the
+ * room takes light a long way back from them, low enough that it is obviously a
+ * floor of a building rather than a volume. The upper storey is a metre shorter
+ * for the plainest possible reason — the good height went downstairs, where the
+ * goods were.
+ */
+const GROUND = 4.4;
+const UPPER = 3.4;
+
+/**
+ * The floor structure between them, and therefore floor-to-floor.
+ *
+ * 0.6 m of beams and deck. Unlike the reference pack's `PLENUM` this is not
+ * exaggerated and is not trying to be a storey of its own: a heavy-timber floor
+ * really is about this deep, and nothing is run through it. `Plan` adds `STOREY`
+ * to every coordinate on level 2 exactly once, so the upper floor below is
+ * authored with its own slab at zero.
+ */
+const FLOOR_STRUCTURE = 0.6;
+const STOREY = GROUND + FLOOR_STRUCTURE;
+
+/** The height of the loggia's open edge. A rail, and a wall — see `RAILS`. */
+const RAIL = 1.1;
+
+/**
+ * Three thicknesses, and the middle one is the interesting one.
+ *
+ * `EXT` is the outer skin: 350 mm of load-bearing brick, which is what holds a
+ * two-storey timber floor up and is nearly three times the reference pack's
+ * partition. `YARD` is the courtyard skin at 250 — also an outside wall, also
+ * weathering, but carrying nothing but itself. `INT` is a stud partition and is
+ * the level's default, so the thirty-odd walls that do not say otherwise are it.
+ */
+const EXT_THICKNESS = 0.35;
+const YARD_THICKNESS = 0.25;
+const INT_THICKNESS = 0.12;
+
+const EXT_FACE = EXT_THICKNESS / 2;
+const YARD_FACE = YARD_THICKNESS / 2;
+const INT_FACE = INT_THICKNESS / 2;
+
+/**
+ * How far the centre of a wall-hung panel sits off the wall's face.
+ *
+ * `tera:screen.wall-display` is 0.12 m deep and `tera:whiteboard` 0.10 m, and a
+ * prop's origin is the centre of its footprint, so half the depth plus a
+ * centimetre of reveal hangs one *on* a wall rather than half inside it.
+ *
+ * Neither gets an `elevation` anywhere in this file, and that is deliberate:
+ * both assets are authored standing on the floor with their own mount height
+ * built in — `mount: 0.9` for the whiteboard, `mount: 0.86` for the display
+ * (`assets/office/surfaces.ts` and `screens.ts`). A pack that also supplies
+ * `elevation: 1.0` has hung the board 1.9 m up.
+ */
+const DISPLAY_OFFSET = 0.07;
+const BOARD_OFFSET = 0.06;
+
+// The lines the ground floor is built on, west to east across the street range.
+const PRESS_E = 9.6; // the press / the front office
+const LOBBY_E = 16.6; // the front office / the paseo
+const PASEO_E = 19.6; // the paseo / the mess
+const MESS_E = 28.0; // the mess / Hewitt
+
+// The west range is two rooms; the south range is the desk floor plus a store.
+const WILLOW_S = 13.0;
+const STORE_W = 31.0;
+
+/**
+ * The stair, which stands in the yard and is therefore a shape cut out of it.
+ *
+ * A dog-leg in two flights with a half landing at the east end: 5 m of rise in
+ * a 5.4 x 2.6 m footprint, which is about fourteen risers a flight. It is
+ * against the front office's yard wall because that is the one stretch of that
+ * wall with nothing behind it — the reception counter is at the other end of the
+ * room — and because a stair in the middle of a courtyard is a stair you walk
+ * round all day.
+ *
+ * The second flight comes back west and arrives at the loggia's edge, which is
+ * why the gap in the balustrade is where it is and why it is 1.2 m wide.
+ */
+const STAIR_E = 15.0;
+const STAIR_S = 11.0;
+const STAIR_HEAD_N = 9.8;
+
+// -- The upper floor --------------------------------------------------------
+//
+// Level 2 covers the street range and the west range and stops: the east and
+// south ranges are single storey with the roof straight onto them. A block like
+// this grew in pieces and never had one date, and a second floor everywhere
+// would have doubled the pack without adding a room worth looking at.
+const LOGGIA_W = 7.2; // the upper rooms / the walkway
+const LOGGIA_N = 6.0; // the loft / the walkway
+const LOFT_E = COURT_E; // the two-storey part stops on the courtyard's east line
+const JESSE_N = 11.8; // Palmetto / Jesse
+
+// ---- Yaw ------------------------------------------------------------------
+
+/**
+ * The four right angles, named for the direction a prop's *front* points.
+ *
+ * The rule they are read with is the one the reference pack states: a prop takes
+ * the yaw of the wall it backs onto, and a seat takes the yaw of the direction
+ * the occupant looks. Zero faces −Z and the angle increases counter-clockwise
+ * from above, which is exactly `object.rotation.y` with nothing converting it.
+ */
+const NORTH: Yaw = 0;
+const EAST: Yaw = -Math.PI / 2;
+const SOUTH: Yaw = Math.PI;
+const WEST: Yaw = Math.PI / 2;
+
+// ---- Assets ---------------------------------------------------------------
+
+/**
+ * Every asset this pack places. All seventeen ids are `tera:` ids registered in
+ * `src/assets/office/`; an id that resolves to nothing gets a placeholder box
+ * rather than an error, which is exactly why they are bound to constants here
+ * where a typo is visible once instead of in forty prop literals.
+ */
+const DESK: AssetId = "tera:desk.workstation";
+const PEDESTAL: AssetId = "tera:desk.pedestal";
+const PARTITION: AssetId = "tera:desk.partition";
+const TASK_CHAIR: AssetId = "tera:seat.task-chair";
+const LOUNGE_CHAIR: AssetId = "tera:seat.lounge";
+const MEETING_TABLE: AssetId = "tera:table.meeting";
+const SIDE_TABLE: AssetId = "tera:table.side";
+const SHELF: AssetId = "tera:storage.shelf";
+const LOCKER: AssetId = "tera:storage.locker";
+const MONITOR: AssetId = "tera:screen.monitor";
+const DISPLAY: AssetId = "tera:screen.wall-display";
+const PLANT: AssetId = "tera:plant.potted";
+const TREE: AssetId = "tera:plant.tall";
+const PENDANT: AssetId = "tera:light.pendant";
+const TROFFER: AssetId = "tera:light.troffer";
+const RUG: AssetId = "tera:rug";
+const WHITEBOARD: AssetId = "tera:whiteboard";
+
+/**
+ * Surfaces, and one of them is a compromise worth naming.
+ *
+ * `MaterialRegistry.resolve` throws the namespace away, reads the first
+ * dot-segment as a role through a small alias table, and **falls back silently**
+ * when it recognises neither. So an id is only worth writing if it lands
+ * somewhere: `tera:concrete.polished` is the `polishedConcrete` role,
+ * `tera:tile.paver` is `tile`, `tera:steel.panel` is `metalTrim`.
+ *
+ * `BRICK` is the compromise. There is no brick in the closed `SurfaceRole` union
+ * in `assets/materials.ts` and a pack cannot add one — the union is a
+ * three-line change *in that file* — so `tera:brick.common` would have resolved
+ * to whatever the caller's fallback happened to be, which is the worst of both
+ * outcomes because it renders and it renders wrong. The id below names the
+ * material a reader is looking at and resolves to `plasterAccent`, whose
+ * plaster texture at 0.92 roughness is the closest thing in the list to a
+ * hundred-year-old common brick. `tera:tile.brick` was the other candidate — a
+ * grid texture is a better match for coursing — and was rejected because the
+ * `tile` role is 0.3 roughness, and glazed brick is a different building.
+ */
+const BRICK = "tera:plasterAccent.brick";
+const CONCRETE = "tera:concrete.polished";
+const WOOD = "tera:wood.plank";
+const CARPET = "tera:carpet.loop";
+const CARPET_ACCENT = "tera:carpetAccent.broadloom";
+const TERRAZZO = "tera:tile.terrazzo";
+const PAVER = "tera:tile.paver";
+const PAINT = "tera:paint.matt";
+const GLASS = "tera:glass.curtain";
+const STEEL = "tera:steel.panel";
+const CEILING_TILE = "tera:ceiling.tile";
+
+// ---- Authoring helpers ----------------------------------------------------
+
+/*
+ * Four functions. They run at module load and return plain objects, so the
+ * exported `Office` is still what `interiors/types.ts` demands — data that would
+ * survive `JSON.parse(JSON.stringify(…))` unchanged — and the file is still
+ * something a person can edit twice.
+ */
+
+/**
+ * An axis-aligned outline, wound counter-clockwise **in plan view**: NW → SW →
+ * SE → NE, which has a negative shoelace area over (x, z) because +Z runs down
+ * the page. `Plan` re-winds a reversed polygon silently, so this is a courtesy
+ * to the reader rather than a trap for the author.
+ */
+function rect(x0: number, z0: number, x1: number, z1: number): Outline {
+  return [
+    { x: x0, z: z0 },
+    { x: x0, z: z1 },
+    { x: x1, z: z1 },
+    { x: x1, z: z0 },
+  ];
+}
+
+/** A regular grid of points, columns first. `rows: 1` gives a line. */
+function grid(
+  x0: number,
+  z0: number,
+  columns: number,
+  rows: number,
+  dx: number,
+  dz: number,
+): Point2[] {
+  const points: Point2[] = [];
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < columns; c++) points.push({ x: x0 + c * dx, z: z0 + r * dz });
+  }
+  return points;
+}
+
+/**
+ * One asset at each of `points`, with ids `${prefix}-01`, `-02`, … — the same
+ * two-digit scheme `DeskBank` expansion uses, so a prop id is something you can
+ * work out on paper rather than by running the code.
+ */
+function scatter(
+  prefix: string,
+  kind: AssetId,
+  points: Point2[],
+  opts: { rotation?: Yaw; elevation?: number; colorKey?: string } = {},
+): Prop[] {
+  return points.map((position, i) => ({
+    id: `${prefix}-${String(i + 1).padStart(2, "0")}`,
+    kind,
+    position,
+    rotation: opts.rotation ?? NORTH,
+    elevation: opts.elevation,
+    colorKey: opts.colorKey,
+  }));
+}
+
+/** A doorway: `sill: 0` and enough head to walk through, which is what makes it
+ * a gap in the collision segments as well as a hole in the wall. */
+function doorway(start: number, width = 0.9, head = 2.1): Opening {
+  return { kind: "door", start, width, sill: 0, head };
+}
+
+/** A window. The sill is the whole of the difference between a window and a
+ * doorway you did not mean to author. */
+function pane(start: number, width: number, sill = 1.0, head = 3.4): Opening {
+  return { kind: "window", start, width, sill, head };
+}
+
+/** A cased opening with no leaf in it. */
+function archway(start: number, width: number, head = 2.4): Opening {
+  return { kind: "arch", start, width, sill: 0, head };
+}
+
+// ---- Rooms ----------------------------------------------------------------
+
+/**
+ * Twelve slabs, and the shape of the building is which of them touch the yard.
+ *
+ * Ten rooms and a passage sit in the ring; the eleventh thing on this level is
+ * the yard itself and the twelfth is the stair standing in it. Nine of the ten
+ * rooms open onto the yard directly and the tenth — the press — opens off the
+ * front office, so the longest route in this building from the street to any
+ * room is three doors.
+ *
+ * Nothing overlaps. The yard is notched around the stair rather than passing
+ * underneath it, for the reason the reference pack notches its open floor around
+ * the booths: two coplanar slabs at the same height is a z-fight waiting for the
+ * wrong GPU, and `Plan.roomAt` resolving the later one is not a reason to stack
+ * them.
+ *
+ * `ceiling: null` on nearly everything is the reference pack's convenience — a
+ * block you look down into cannot have lids on the rooms you are looking into —
+ * with two exceptions in opposite directions. The store keeps its ceiling
+ * because it is the one room here nobody is meant to see inside. The yard and
+ * the stair have `ceiling: null` because they are **outside**, and that is the
+ * one place in this pack where the field means what it literally says.
+ */
+const ROOMS: Room[] = [
+  // -- The street range, west to east ---------------------------------------
+  {
+    id: "press",
+    name: "The Press",
+    // The messy end, on the corner, with a concrete floor and its own door out
+    // of the front office wide enough to carry a sheet of ply through.
+    outline: rect(0, 0, PRESS_E, COURT_N),
+    floor: CONCRETE,
+    ceiling: null,
+  },
+  {
+    id: "lobby",
+    name: "The Front",
+    // Reception, and the only room in the building with a door on the paseo and
+    // a door on the yard. Somebody arriving is met here and then walked out
+    // into the middle of the block, which is the introduction the plan wants to
+    // make.
+    outline: rect(PRESS_E, 0, LOBBY_E, COURT_N),
+    floor: WOOD,
+    ceiling: null,
+  },
+  {
+    id: "paseo",
+    name: "The Paseo",
+    // A passage cut straight through the street range: three metres wide and
+    // eight and a half from the pavement to the yard, counting the brick at the
+    // street end. It is the only way into this building that is not a goods
+    // door, and it is the oldest device in this kind of plan — the reason the
+    // front door of the building is not the front door of the office.
+    outline: rect(LOBBY_E, 0, PASEO_E, COURT_N),
+    floor: CONCRETE,
+    ceiling: null,
+  },
+  {
+    id: "mess",
+    name: "The Mess",
+    outline: rect(PASEO_E, 0, MESS_E, COURT_N),
+    floor: TERRAZZO,
+    ceiling: null,
+  },
+  {
+    id: "hewitt",
+    name: "Hewitt",
+    // The big meeting room, in the corner where two walls have no openings at
+    // all — the party wall east and the range wall south. The meeting rooms in
+    // this pack take their names from the streets of the district, the way the
+    // reference pack's take theirs from places in the bay.
+    outline: rect(MESS_E, 0, WIDTH, COURT_N),
+    floor: CARPET,
+    ceiling: null,
+  },
+
+  // -- The west range -------------------------------------------------------
+  {
+    id: "willow",
+    name: "Willow",
+    outline: rect(0, COURT_N, COURT_W, WILLOW_S),
+    floor: CARPET_ACCENT,
+    ceiling: null,
+  },
+  {
+    id: "violet",
+    name: "Violet",
+    // The quiet room. No table you can put a laptop on, on purpose.
+    outline: rect(0, WILLOW_S, COURT_W, COURT_S),
+    floor: CARPET_ACCENT,
+    ceiling: null,
+  },
+
+  // -- The east range -------------------------------------------------------
+  {
+    id: "shop",
+    name: "The Shop",
+    // Fabrication, with a four-metre roller shutter onto the yard. That shutter
+    // is the reason the yard is paved rather than planted: work comes out of
+    // this room and is finished in the middle of the building, which is a thing
+    // a courtyard can do and a corridor cannot.
+    outline: rect(COURT_E, COURT_N, WIDTH, COURT_S),
+    floor: CONCRETE,
+    ceiling: null,
+  },
+
+  // -- The south range ------------------------------------------------------
+  {
+    id: "works",
+    name: "The Works",
+    // Thirty-one metres of desk floor along the back of the block, glazed onto
+    // the yard on one side and onto the alley on the other. The longest room
+    // here, and the only one that is more than one thing at once.
+    outline: rect(0, COURT_S, STORE_W, DEPTH),
+    floor: CARPET,
+    ceiling: null,
+  },
+  {
+    id: "store",
+    name: "Facilities",
+    outline: rect(STORE_W, COURT_S, WIDTH, DEPTH),
+    floor: CONCRETE,
+    ceiling: { height: 3.0, surface: CEILING_TILE },
+  },
+
+  // -- The hole -------------------------------------------------------------
+  /**
+   * The yard: 16.8 by 9.2, open to the sky, and the circulation of the whole
+   * building.
+   *
+   * Notched around the stair on its north-west corner. Wound the way `rect`
+   * winds — down the west side, along the south, back up the east and west
+   * along the north — with the notch taken out of the run that meets it.
+   *
+   * `ceiling: null` here is not the establishing-shot convenience it is
+   * everywhere else in this file. There is no ceiling.
+   */
+  {
+    id: "court",
+    name: "The Yard",
+    outline: [
+      { x: COURT_W, z: STAIR_S },
+      { x: COURT_W, z: COURT_S },
+      { x: COURT_E, z: COURT_S },
+      { x: COURT_E, z: COURT_N },
+      { x: STAIR_E, z: COURT_N },
+      { x: STAIR_E, z: STAIR_S },
+    ],
+    floor: PAVER,
+    ceiling: null,
+  },
+  {
+    id: "stair",
+    name: "The Stair",
+    // A floor finish the shape of the flight, and no treads — the kit has no
+    // stair asset, and inventing an id for one would resolve to a placeholder
+    // box in the middle of the yard. The reference pack's `stair-core` is the
+    // same admission with a wall round it.
+    outline: rect(COURT_W, COURT_N, STAIR_E, STAIR_S),
+    floor: STEEL,
+    ceiling: null,
+  },
+];
+
+// ---- Walls ----------------------------------------------------------------
+
+/**
+ * Twenty segments, written west-to-east and north-to-south without exception,
+ * because `Opening.start` is measured from a wall's `from` end and the day you
+ * reverse one and forget is the day a door moves to the other end of a room.
+ *
+ * The east wall is the one worth reading first. It has **no openings at all**,
+ * because it is a party wall: on a downtown lot the block next door is built
+ * against you, and a window in that wall would look at somebody else's brick.
+ * That single fact is what makes the yard necessary rather than decorative —
+ * with one side blind and the ring 9.6 m deep, the middle of the block is the
+ * only place the light for half the building can come from.
+ */
+const WALLS: Wall[] = [
+  // -- The envelope ---------------------------------------------------------
+  {
+    id: "ext-north",
+    // The street. Tall windows on brick piers, and the paseo arch punched
+    // straight through the middle of them — 3 m wide and 3.6 m to the head,
+    // which is a lorry-sized hole and is what the passage was cut for before it
+    // was a way for people to walk in.
+    from: { x: 0, z: 0 },
+    to: { x: WIDTH, z: 0 },
+    thickness: EXT_THICKNESS,
+    surface: BRICK,
+    openings: [
+      pane(1.2, 3.2),
+      pane(5.6, 3.2),
+      pane(10.6, 4.4),
+      archway(LOBBY_E, 3.0, 3.6),
+      pane(20.6, 3.2),
+      pane(24.4, 3.0),
+      pane(29.0, 5.6),
+    ],
+  },
+  {
+    id: "ext-east",
+    // The party wall. Solid for its whole 26 m, at both storeys.
+    from: { x: WIDTH, z: 0 },
+    to: { x: WIDTH, z: DEPTH },
+    thickness: EXT_THICKNESS,
+    surface: BRICK,
+  },
+  {
+    id: "ext-south",
+    // The alley, and the goods side. The shutter is a `door` rather than a
+    // window for the reason that matters to the collider: `sill: 0` and 4 m of
+    // head is a hole a walker can use, which is what an escape route is.
+    from: { x: 0, z: DEPTH },
+    to: { x: WIDTH, z: DEPTH },
+    thickness: EXT_THICKNESS,
+    surface: BRICK,
+    openings: [
+      pane(1.6, 5.2),
+      pane(8.4, 5.2),
+      pane(15.2, 5.2),
+      { kind: "door", start: 22.4, width: 3.6, sill: 0, head: 4.0 },
+      doorway(32.4),
+    ],
+  },
+  {
+    id: "ext-west",
+    from: { x: 0, z: 0 },
+    to: { x: 0, z: DEPTH },
+    thickness: EXT_THICKNESS,
+    surface: BRICK,
+    openings: [pane(1.4, 3.4), pane(9.4, 2.6, 1.0, 2.8), pane(13.8, 2.6, 1.0, 2.8), pane(18.6, 5.2)],
+  },
+
+  // -- The courtyard skin ---------------------------------------------------
+  //
+  // Six walls and a gap. The gap is the paseo's mouth between x 16.6 and 19.6,
+  // where the passage simply arrives in the yard: a wall belongs to no room, so
+  // an opening in the ring is authored by not writing a wall rather than by
+  // punching a hole in one.
+  //
+  // **Every door in this skin is 1.2 m and not 0.9**, and that is arithmetic
+  // rather than taste. `Plan.blocked` inflates each solid run by
+  // `radius + thickness / 2`, so a leaf in one of these 0.25 m walls loses
+  // 2 x (0.3 + 0.125) = 0.85 m of its width to a 0.3 m walker: a 0.9 m door
+  // leaves 0.05 m of clear width, which no flood fill will thread and which
+  // seals the room behind it while looking completely fine in a screenshot.
+  // Willow and Violet were sealed exactly that way on the first pass. At 1.2 m
+  // the same sum leaves 0.35 m, and 1.2 m is a pair of leaves, which is what a
+  // door onto a courtyard is anyway. The 0.9 m leaves that survive are mostly in
+  // the 0.12 m partitions, where the loss is 0.72 and the clear width is 0.18 —
+  // the same margin every door in the reference pack runs at. The exception is
+  // the alley door into the store, which is 0.9 m through 0.35 m of brick and
+  // was measured rather than assumed: `blocked` is false through it at a 0.3 m
+  // radius, because it is the *sum* of the inflations that has to fit and this
+  // one still does.
+  {
+    id: "yard-lobby",
+    // The front office's yard wall, with the stair standing against it. The
+    // window is high — sill 2.6 — because the bottom two and a half metres of
+    // this wall have a flight of stairs in front of them, and the door is at the
+    // far end of it, which puts reception's way out into the yard exactly at the
+    // foot of the stair.
+    from: { x: COURT_W, z: COURT_N },
+    to: { x: LOBBY_E, z: COURT_N },
+    thickness: YARD_THICKNESS,
+    surface: BRICK,
+    openings: [pane(1.0, 3.6, 2.6, 3.8), doorway(5.4, 1.2)],
+  },
+  {
+    id: "yard-mess",
+    from: { x: PASEO_E, z: COURT_N },
+    to: { x: COURT_E, z: COURT_N },
+    thickness: YARD_THICKNESS,
+    surface: GLASS,
+    // Wide enough to carry lunch through without turning sideways, which is the
+    // only specification a kitchen door onto a courtyard has.
+    openings: [archway(1.4, 2.4), pane(4.6, 1.8, 1.0, 2.6)],
+  },
+  {
+    id: "front-willow",
+    from: { x: COURT_W, z: COURT_N },
+    to: { x: COURT_W, z: WILLOW_S },
+    thickness: YARD_THICKNESS,
+    surface: GLASS,
+    // The door starts 2.6 m along, which is where the stair's footprint ends. A
+    // metre further north and it would have opened into the second flight.
+    openings: [doorway(2.6, 1.2), pane(3.9, 0.6, 1.0, 2.6)],
+  },
+  {
+    id: "front-violet",
+    from: { x: COURT_W, z: WILLOW_S },
+    to: { x: COURT_W, z: COURT_S },
+    thickness: YARD_THICKNESS,
+    surface: BRICK,
+    openings: [doorway(1.2, 1.2), pane(3.0, 1.4, 1.0, 2.6)],
+  },
+  {
+    id: "yard-shop",
+    from: { x: COURT_E, z: COURT_N },
+    to: { x: COURT_E, z: COURT_S },
+    thickness: YARD_THICKNESS,
+    surface: STEEL,
+    // The shutter, and a personnel door beside it so the shop is usable with the
+    // shutter down. Both are ways through; the shutter is four metres of one.
+    openings: [{ kind: "door", start: 2.6, width: 4.0, sill: 0, head: 4.0 }, doorway(7.4, 1.2)],
+  },
+  {
+    id: "yard-works",
+    from: { x: COURT_W, z: COURT_S },
+    to: { x: COURT_E, z: COURT_S },
+    thickness: YARD_THICKNESS,
+    surface: GLASS,
+    // A pair of leaves rather than a single: this is the door forty people use,
+    // and the reference pack's entrance makes the same argument. Full-height
+    // glazing either side of it, as a *wall with a glass surface* — an opening
+    // here would hand the collider sixteen metres of gap and put the desk floor
+    // in the yard.
+    openings: [doorway(3.4, 1.8, 2.4), pane(7.4, 3.6, 1.0, 3.0), pane(12.4, 3.0, 1.0, 3.0)],
+  },
+
+  // -- Inside the ring ------------------------------------------------------
+  {
+    id: "paseo-west",
+    from: { x: LOBBY_E, z: 0 },
+    to: { x: LOBBY_E, z: COURT_N },
+    openings: [doorway(4.2, 1.0, 2.4)],
+  },
+  {
+    id: "paseo-east",
+    from: { x: PASEO_E, z: 0 },
+    to: { x: PASEO_E, z: COURT_N },
+    openings: [doorway(4.6)],
+  },
+  {
+    id: "press-east",
+    from: { x: PRESS_E, z: 0 },
+    to: { x: PRESS_E, z: COURT_N },
+    // 1.6 m, because the things this room makes leave through it.
+    openings: [doorway(3.4, 1.6, 2.4)],
+  },
+  {
+    id: "press-south",
+    from: { x: 0, z: COURT_N },
+    to: { x: PRESS_E, z: COURT_N },
+  },
+  {
+    id: "willow-violet",
+    from: { x: 0, z: WILLOW_S },
+    to: { x: COURT_W, z: WILLOW_S },
+  },
+  {
+    id: "violet-works",
+    from: { x: 0, z: COURT_S },
+    to: { x: COURT_W, z: COURT_S },
+  },
+  {
+    id: "mess-hewitt",
+    from: { x: MESS_E, z: 0 },
+    to: { x: MESS_E, z: COURT_N },
+    openings: [doorway(4.4)],
+  },
+  {
+    id: "range-north-east",
+    // Between the street range and the east range, and deliberately solid: the
+    // way from the mess to the shop is across the yard. In a building organised
+    // round a courtyard, a shortcut that avoids the courtyard is a hole in the
+    // idea rather than a convenience.
+    from: { x: COURT_E, z: COURT_N },
+    to: { x: WIDTH, z: COURT_N },
+  },
+  {
+    id: "range-south-east",
+    from: { x: COURT_E, z: COURT_S },
+    to: { x: WIDTH, z: COURT_S },
+    // The one internal door on the far side of the yard, because material goes
+    // from the shop to the desks and 1.6 m of it goes on a trolley.
+    openings: [doorway(1.6, 1.6, 2.4)],
+  },
+  {
+    id: "store-west",
+    from: { x: STORE_W, z: COURT_S },
+    to: { x: STORE_W, z: DEPTH },
+    openings: [doorway(3.0, 1.2, 2.4)],
+  },
+];
+
+// ---- Desk banks -----------------------------------------------------------
+
+/**
+ * Twenty-eight desks in two declarations, both in the works.
+ *
+ * `Plan` expands each into a desk prop, a chair prop and a seat per station,
+ * with ids that are contractual: `works-a-01` … `works-a-14` counting along each
+ * row and then down the rows, and `works-a-desk-01`, `works-a-chair-01` for the
+ * furniture. A `Presence` binds to `works-a-04` and has no way to notice that
+ * the bench moved 200 mm, which is the property the whole scheme exists for.
+ *
+ * A second bench is a second bank, for the reason both other packs record: one
+ * `rowPitch` cannot be both the 0.85 m that makes two rows meet back to back and
+ * the 1.95 m of chair, aisle and chair between one bench and the next.
+ */
+const DESK_BANKS: DeskBank[] = [
+  {
+    id: "works-a",
+    desk: DESK,
+    chair: TASK_CHAIR,
+    origin: { x: 3.4, z: 19.2 },
+    rotation: NORTH,
+    columns: 7,
+    rows: 2,
+    pitch: 1.7, // 1.6 m desks with a 100 mm gap
+    rowPitch: 0.85,
+    facingRows: true,
+    seatOffset: 0.6,
+  },
+  {
+    id: "works-b",
+    desk: DESK,
+    chair: TASK_CHAIR,
+    origin: { x: 3.4, z: 23.2 },
+    rotation: NORTH,
+    columns: 7,
+    rows: 2,
+    pitch: 1.7,
+    rowPitch: 0.85,
+    facingRows: true,
+    seatOffset: 0.6,
+  },
+];
+
+// ---- Seats ----------------------------------------------------------------
+
+/**
+ * The forty-one seats on this level that a `DeskBank` cannot generate: chairs
+ * round tables, two people waiting in reception, four standing at a pair of
+ * worktables — and eight at a table in the open air, which is the entry the
+ * other two packs have nothing like.
+ *
+ * A seat is an address and not a chair. The prefixes here (`front`, `mess`,
+ * `hewitt`, `willow`, `violet`, `shop`, `press`, `yard`) are disjoint from both
+ * shipped packs' on purpose: ids are unique per building by the format's rules,
+ * but a deployment serving three buildings from one presence API would find out
+ * the hard way, and staying disjoint costs nothing.
+ */
+const SEATS: Seat[] = [
+  // Reception, and the pair waiting for somebody to come and get them.
+  { id: "front-01", position: { x: 13.6, z: 5.0 }, facing: EAST, pose: "sit" },
+  { id: "front-02", position: { x: 11.6, z: 6.6 }, facing: EAST, pose: "sit" },
+  { id: "front-03", position: { x: 13.2, z: 6.6 }, facing: WEST, pose: "sit" },
+
+  // The press. Four standing at two worktables, because nobody sits down to cut
+  // a mount board — `pose` is the only thing that tells a consumer how tall to
+  // draw an occupant.
+  { id: "press-01", position: { x: 3.8, z: 4.4 }, facing: NORTH, pose: "stand" },
+  { id: "press-02", position: { x: 5.4, z: 4.4 }, facing: NORTH, pose: "stand" },
+  { id: "press-03", position: { x: 3.8, z: 5.4 }, facing: SOUTH, pose: "stand" },
+  { id: "press-04", position: { x: 5.4, z: 5.4 }, facing: SOUTH, pose: "stand" },
+
+  // The mess: three perched at the island, two at the table by the glass.
+  { id: "mess-01", position: { x: 22.2, z: 4.2 }, facing: NORTH, pose: "stand" },
+  { id: "mess-02", position: { x: 23.0, z: 4.2 }, facing: NORTH, pose: "stand" },
+  { id: "mess-03", position: { x: 23.8, z: 4.2 }, facing: NORTH, pose: "stand" },
+  { id: "mess-04", position: { x: 20.2, z: 6.6 }, facing: EAST, pose: "sit" },
+  { id: "mess-05", position: { x: 23.0, z: 6.6 }, facing: WEST, pose: "sit" },
+
+  // Hewitt — ten round a 4.8 m table, five a side, both ends left clear so the
+  // people at them can see the display on the party wall.
+  { id: "hewitt-01", position: { x: 29.4, z: 3.2 }, facing: SOUTH, pose: "sit" },
+  { id: "hewitt-02", position: { x: 30.4, z: 3.2 }, facing: SOUTH, pose: "sit" },
+  { id: "hewitt-03", position: { x: 31.4, z: 3.2 }, facing: SOUTH, pose: "sit" },
+  { id: "hewitt-04", position: { x: 32.4, z: 3.2 }, facing: SOUTH, pose: "sit" },
+  { id: "hewitt-05", position: { x: 33.4, z: 3.2 }, facing: SOUTH, pose: "sit" },
+  { id: "hewitt-06", position: { x: 29.4, z: 5.2 }, facing: NORTH, pose: "sit" },
+  { id: "hewitt-07", position: { x: 30.4, z: 5.2 }, facing: NORTH, pose: "sit" },
+  { id: "hewitt-08", position: { x: 31.4, z: 5.2 }, facing: NORTH, pose: "sit" },
+  { id: "hewitt-09", position: { x: 32.4, z: 5.2 }, facing: NORTH, pose: "sit" },
+  { id: "hewitt-10", position: { x: 33.4, z: 5.2 }, facing: NORTH, pose: "sit" },
+
+  // Willow, six.
+  { id: "willow-01", position: { x: 3.4, z: 9.7 }, facing: SOUTH, pose: "sit" },
+  { id: "willow-02", position: { x: 4.4, z: 9.7 }, facing: SOUTH, pose: "sit" },
+  { id: "willow-03", position: { x: 5.4, z: 9.7 }, facing: SOUTH, pose: "sit" },
+  { id: "willow-04", position: { x: 3.4, z: 11.7 }, facing: NORTH, pose: "sit" },
+  { id: "willow-05", position: { x: 4.4, z: 11.7 }, facing: NORTH, pose: "sit" },
+  { id: "willow-06", position: { x: 5.4, z: 11.7 }, facing: NORTH, pose: "sit" },
+
+  // Violet, the quiet room: two chairs and nothing else.
+  { id: "violet-01", position: { x: 4.4, z: 14.4 }, facing: SOUTH, pose: "sit" },
+  { id: "violet-02", position: { x: 4.4, z: 16.2 }, facing: NORTH, pose: "sit" },
+
+  // The shop, standing at the benches.
+  { id: "shop-01", position: { x: 30.2, z: 11.4 }, facing: NORTH, pose: "stand" },
+  { id: "shop-02", position: { x: 31.8, z: 11.4 }, facing: NORTH, pose: "stand" },
+  { id: "shop-03", position: { x: 31.0, z: 14.0 }, facing: NORTH, pose: "stand" },
+
+  /**
+   * The yard table. Eight seats outdoors, which is the pack's whole argument in
+   * one declaration: a seat is a spot on the floor with a name, the format never
+   * asked whether the floor had a roof over it, and a building in this climate
+   * puts a third of its meeting capacity in the middle of the block.
+   */
+  { id: "yard-01", position: { x: 17.2, z: 12.4 }, facing: SOUTH, pose: "sit" },
+  { id: "yard-02", position: { x: 18.4, z: 12.4 }, facing: SOUTH, pose: "sit" },
+  { id: "yard-03", position: { x: 19.6, z: 12.4 }, facing: SOUTH, pose: "sit" },
+  { id: "yard-04", position: { x: 20.8, z: 12.4 }, facing: SOUTH, pose: "sit" },
+  { id: "yard-05", position: { x: 17.2, z: 14.4 }, facing: NORTH, pose: "sit" },
+  { id: "yard-06", position: { x: 18.4, z: 14.4 }, facing: NORTH, pose: "sit" },
+  { id: "yard-07", position: { x: 19.6, z: 14.4 }, facing: NORTH, pose: "sit" },
+  { id: "yard-08", position: { x: 20.8, z: 14.4 }, facing: NORTH, pose: "sit" },
+];
+
+// ---- Props ----------------------------------------------------------------
+
+/**
+ * Everything that is not a wall, a floor or a desk bank, grouped in the order
+ * you walk through the building: in off the street, into reception, round the
+ * yard clockwise, and out into the works.
+ *
+ * No monitors on the desks, for the reason the reference pack gives at length:
+ * twenty-eight monitor props kept in step by hand with a bank somebody will move
+ * next week is what `overrides:` exists to prevent. The one monitor in the
+ * building belongs to a place rather than to a desk.
+ */
+const PROPS: Prop[] = [
+  // -- The paseo ------------------------------------------------------------
+  // Nearly empty, and it has to be: three metres wide is a passage, and a
+  // passage with furniture in it is a corridor with an obstruction in it.
+  {
+    id: "paseo-directory",
+    kind: DISPLAY,
+    position: { x: LOBBY_E + INT_FACE + DISPLAY_OFFSET, z: 2.4 },
+    rotation: WEST,
+  },
+  ...scatter("paseo-tree", TREE, [
+    { x: 17.2, z: 1.2 },
+    { x: 19.0, z: 1.2 },
+  ]),
+  ...scatter("paseo-light", TROFFER, grid(18.1, 2.0, 1, 3, 0, 2.4), { elevation: GROUND }),
+
+  // -- The Front ------------------------------------------------------------
+  // The desk is turned to face the paseo door, so the receptionist is on its far
+  // flank looking back at whoever just came in off the street.
+  { id: "front-desk", kind: DESK, position: { x: 14.2, z: 5.0 }, rotation: EAST },
+  { id: "front-chair", kind: TASK_CHAIR, position: { x: 13.6, z: 5.0 }, rotation: EAST },
+  {
+    id: "front-monitor",
+    kind: MONITOR,
+    position: { x: 13.9, z: 5.0 },
+    rotation: EAST,
+    // Standing on the desktop. `tera:desk.workstation` is 0.73 m to the deck and
+    // a monitor is authored on the floor like everything else, so the pack
+    // supplies the height rather than the asset assuming one.
+    elevation: 0.73,
+  },
+  { id: "front-pedestal", kind: PEDESTAL, position: { x: 14.2, z: 3.9 }, rotation: EAST },
+  { id: "front-rug", kind: RUG, position: { x: 12.4, z: 6.6 }, rotation: NORTH },
+  { id: "front-sofa-w", kind: LOUNGE_CHAIR, position: { x: 11.6, z: 6.6 }, rotation: EAST },
+  { id: "front-sofa-e", kind: LOUNGE_CHAIR, position: { x: 13.2, z: 6.6 }, rotation: WEST },
+  { id: "front-table", kind: SIDE_TABLE, position: { x: 12.4, z: 6.6 }, rotation: NORTH },
+  {
+    id: "front-shelf",
+    kind: SHELF,
+    position: { x: PRESS_E + INT_FACE + 0.18, z: 2.0 },
+    rotation: WEST,
+  },
+  { id: "front-tree", kind: TREE, position: { x: 15.8, z: 1.2 }, rotation: NORTH },
+  ...scatter("front-light", TROFFER, grid(10.6, 1.6, 3, 3, 2.4, 2.6), { elevation: GROUND }),
+
+  // -- The Press ------------------------------------------------------------
+  // Two 2.4 m tables, because a `Prop` is an id and a placement and carries no
+  // parameters: the long bench this room wants is two of the table the kit has.
+  { id: "press-table-n", kind: MEETING_TABLE, position: { x: 4.6, z: 3.4 }, rotation: NORTH },
+  { id: "press-table-s", kind: MEETING_TABLE, position: { x: 4.6, z: 6.6 }, rotation: NORTH },
+  ...scatter("press-locker", LOCKER, grid(EXT_FACE + 0.25, 1.4, 1, 2, 0, 1.3), { rotation: WEST }),
+  ...scatter("press-shelf", SHELF, grid(6.6, COURT_N - INT_FACE - 0.18, 2, 1, 1.0, 0), {
+    rotation: SOUTH,
+  }),
+  {
+    id: "press-board",
+    kind: WHITEBOARD,
+    position: { x: 2.4, z: COURT_N - INT_FACE - BOARD_OFFSET },
+    rotation: SOUTH,
+  },
+  { id: "press-plant", kind: PLANT, position: { x: 8.6, z: 0.8 }, rotation: NORTH },
+  ...scatter("press-light", TROFFER, grid(1.6, 1.6, 3, 3, 3.2, 2.6), { elevation: GROUND }),
+
+  // -- The Mess -------------------------------------------------------------
+  // A meeting table doing duty as an island, exactly as the reference pack's
+  // kitchen does. There is no `tera:kitchen.island` and there should not be; the
+  // honest way to get one is to register it in your own namespace.
+  { id: "mess-island", kind: MEETING_TABLE, position: { x: 23.0, z: 3.0 }, rotation: NORTH },
+  {
+    id: "mess-island-plant",
+    kind: PLANT,
+    position: { x: 23.0, z: 3.0 },
+    rotation: NORTH,
+    elevation: 0.74,
+  },
+  ...scatter("mess-stool", TASK_CHAIR, grid(22.2, 4.2, 3, 1, 0.8, 0), { rotation: NORTH }),
+  // The counters run down the wall the building's only internal door on this
+  // range is in, not under the street windows: a 1.8 m locker in front of a
+  // window with a 1 m sill is a wall with a window nobody can see out of.
+  ...scatter("mess-counter", LOCKER, grid(MESS_E - INT_FACE - 0.25, 1.4, 1, 3, 0, 1.3), {
+    rotation: EAST,
+  }),
+  {
+    id: "mess-shelf",
+    kind: SHELF,
+    position: { x: MESS_E - INT_FACE - 0.18, z: 6.0 },
+    rotation: EAST,
+  },
+  { id: "mess-table", kind: MEETING_TABLE, position: { x: 21.6, z: 6.6 }, rotation: NORTH },
+  { id: "mess-seat-w", kind: LOUNGE_CHAIR, position: { x: 20.2, z: 6.6 }, rotation: EAST },
+  { id: "mess-seat-e", kind: LOUNGE_CHAIR, position: { x: 23.0, z: 6.6 }, rotation: WEST },
+  { id: "mess-tree", kind: TREE, position: { x: 26.0, z: 1.4 }, rotation: NORTH },
+  ...scatter("mess-pendant", PENDANT, grid(22.4, 3.0, 2, 1, 1.2, 0), { elevation: GROUND }),
+  ...scatter("mess-light", TROFFER, grid(20.6, 2.0, 3, 2, 2.6, 3.4), { elevation: GROUND }),
+
+  // -- Hewitt ---------------------------------------------------------------
+  { id: "hewitt-table-w", kind: MEETING_TABLE, position: { x: 30.4, z: 4.2 }, rotation: NORTH },
+  { id: "hewitt-table-e", kind: MEETING_TABLE, position: { x: 32.8, z: 4.2 }, rotation: NORTH },
+  ...scatter("hewitt-chair-n", TASK_CHAIR, grid(29.4, 3.2, 5, 1, 1.0, 0), { rotation: SOUTH }),
+  ...scatter("hewitt-chair-s", TASK_CHAIR, grid(29.4, 5.2, 5, 1, 1.0, 0), { rotation: NORTH }),
+  {
+    id: "hewitt-display",
+    kind: DISPLAY,
+    // On the party wall, which is the one wall in this room that will never have
+    // a window in it. Rooms get laid out around where a screen can go more often
+    // than anybody admits, and here the wall was decided by the neighbours.
+    position: { x: WIDTH - EXT_FACE - DISPLAY_OFFSET, z: 4.2 },
+    rotation: EAST,
+  },
+  {
+    id: "hewitt-board",
+    kind: WHITEBOARD,
+    position: { x: MESS_E + INT_FACE + BOARD_OFFSET, z: 4.2 },
+    rotation: WEST,
+  },
+  { id: "hewitt-tree", kind: TREE, position: { x: 29.2, z: 7.4 }, rotation: NORTH },
+  ...scatter("hewitt-light", TROFFER, grid(29.6, 2.4, 3, 2, 2.6, 3.6), { elevation: GROUND }),
+
+  // -- Willow ---------------------------------------------------------------
+  { id: "willow-table", kind: MEETING_TABLE, position: { x: 4.4, z: 10.7 }, rotation: NORTH },
+  ...scatter("willow-chair-n", TASK_CHAIR, grid(3.4, 9.7, 3, 1, 1.0, 0), { rotation: SOUTH }),
+  ...scatter("willow-chair-s", TASK_CHAIR, grid(3.4, 11.7, 3, 1, 1.0, 0), { rotation: NORTH }),
+  {
+    id: "willow-display",
+    kind: DISPLAY,
+    position: { x: EXT_FACE + DISPLAY_OFFSET, z: 10.7 },
+    rotation: WEST,
+  },
+  { id: "willow-plant", kind: PLANT, position: { x: 8.4, z: 9.2 }, rotation: NORTH },
+  ...scatter("willow-light", TROFFER, grid(2.8, 9.6, 2, 2, 2.8, 2.2), { elevation: GROUND }),
+
+  // -- Violet ---------------------------------------------------------------
+  { id: "violet-rug", kind: RUG, position: { x: 4.4, z: 15.3 }, rotation: NORTH, colorKey: "focus" },
+  { id: "violet-chair-n", kind: LOUNGE_CHAIR, position: { x: 4.4, z: 14.4 }, rotation: SOUTH },
+  { id: "violet-chair-s", kind: LOUNGE_CHAIR, position: { x: 4.4, z: 16.2 }, rotation: NORTH },
+  { id: "violet-table", kind: SIDE_TABLE, position: { x: 4.4, z: 15.3 }, rotation: NORTH },
+  {
+    id: "violet-shelf",
+    kind: SHELF,
+    position: { x: 7.0, z: WILLOW_S + INT_FACE + 0.18 },
+    rotation: NORTH,
+  },
+  { id: "violet-tree", kind: TREE, position: { x: 8.2, z: 16.6 }, rotation: NORTH },
+  { id: "violet-pendant", kind: PENDANT, position: { x: 4.4, z: 15.3 }, rotation: NORTH, elevation: GROUND },
+  ...scatter("violet-light", TROFFER, grid(2.4, 14.2, 2, 2, 3.2, 2.4), { elevation: GROUND }),
+
+  // -- The Shop -------------------------------------------------------------
+  { id: "shop-bench-n", kind: MEETING_TABLE, position: { x: 31.0, z: 10.0 }, rotation: NORTH },
+  { id: "shop-bench-s", kind: MEETING_TABLE, position: { x: 31.0, z: 12.6 }, rotation: NORTH },
+  ...scatter("shop-locker", LOCKER, grid(28.0, COURT_N + INT_FACE + 0.25, 3, 1, 1.3, 0)),
+  // Racking beside the shutter, against the courtyard wall — which is the one
+  // place in this pack a prop backs onto the 0.25 m skin rather than the 0.12 m
+  // partition or the 0.35 m brick, so it is the one place `YARD_FACE` is the
+  // right half-thickness to add to a locker's own 0.25.
+  ...scatter("shop-rack", LOCKER, grid(COURT_E + YARD_FACE + 0.25, 9.1, 1, 2, 0, 1.3), {
+    rotation: WEST,
+  }),
+  // Against the party wall, which in this room is 9.2 m of unbroken brick and
+  // the best storage wall in the building.
+  ...scatter("shop-shelf", SHELF, grid(WIDTH - EXT_FACE - 0.18, 9.6, 1, 4, 0, 1.2), {
+    rotation: EAST,
+  }),
+  {
+    id: "shop-board",
+    kind: WHITEBOARD,
+    position: { x: 33.4, z: COURT_N + INT_FACE + BOARD_OFFSET },
+    rotation: NORTH,
+  },
+  { id: "shop-tree", kind: TREE, position: { x: 27.4, z: 16.4 }, rotation: NORTH },
+  ...scatter("shop-light", TROFFER, grid(28.4, 9.8, 3, 3, 2.8, 2.8), { elevation: GROUND }),
+
+  // -- The Works ------------------------------------------------------------
+  // A screen down the spine of each bench: 1.4 m against a 1.7 m pitch leaves a
+  // gap you can talk through, which is the entire argument for a 0.45 m screen.
+  ...scatter("works-a-screen", PARTITION, grid(3.4, 19.625, 7, 1, 1.7, 0)),
+  ...scatter("works-b-screen", PARTITION, grid(3.4, 23.625, 7, 1, 1.7, 0)),
+  // Pedestals park at the ends of the benches rather than under the desks, which
+  // is where they end up in a building where people move seats.
+  ...scatter("works-pedestal", PEDESTAL, [
+    { x: 2.0, z: 19.6 },
+    { x: 2.0, z: 23.6 },
+    { x: 14.8, z: 19.6 },
+    { x: 14.8, z: 23.6 },
+  ]),
+  ...scatter("works-locker", LOCKER, grid(1.4, COURT_S + INT_FACE + 0.25, 3, 1, 1.3, 0)),
+  {
+    id: "works-display",
+    kind: DISPLAY,
+    position: { x: EXT_FACE + DISPLAY_OFFSET, z: 21.0 },
+    rotation: WEST,
+  },
+  // The east end of the works is left as somewhere to sit rather than as more
+  // desks. None of these four chairs has a seat id, and that is the format
+  // working as intended: a chair with nobody's name on it needs no address.
+  { id: "works-rug", kind: RUG, position: { x: 25.0, z: 21.8 }, rotation: NORTH, colorKey: "social" },
+  ...scatter("works-lounge", LOUNGE_CHAIR, [
+    { x: 23.8, z: 21.0 },
+    { x: 26.2, z: 21.0 },
+    { x: 23.8, z: 22.6 },
+    { x: 26.2, z: 22.6 },
+  ]),
+  { id: "works-side", kind: SIDE_TABLE, position: { x: 25.0, z: 21.8 }, rotation: NORTH },
+  ...scatter("works-tree", TREE, [
+    { x: 17.6, z: 18.6 },
+    { x: 29.6, z: 18.6 },
+    { x: 20.0, z: 25.0 },
+  ]),
+  ...scatter("works-light", TROFFER, grid(2.4, 18.8, 8, 3, 3.6, 2.8), { elevation: GROUND }),
+
+  // -- Facilities -----------------------------------------------------------
+  // The lockers skip the middle of the wall because the door is there.
+  ...scatter("store-locker", LOCKER, [
+    { x: STORE_W + INT_FACE + 0.25, z: 18.4 },
+    { x: STORE_W + INT_FACE + 0.25, z: 19.7 },
+    { x: STORE_W + INT_FACE + 0.25, z: 23.0 },
+    { x: STORE_W + INT_FACE + 0.25, z: 24.3 },
+  ], { rotation: WEST }),
+  ...scatter("store-shelf", SHELF, grid(WIDTH - EXT_FACE - 0.18, 18.6, 1, 3, 0, 1.2), {
+    rotation: EAST,
+  }),
+  ...scatter("store-light", TROFFER, grid(32.6, 19.6, 1, 2, 0, 3.0), { elevation: 3.0 }),
+
+  // -- The Yard -------------------------------------------------------------
+  /**
+   * A long table and four trees, and no light fittings at all.
+   *
+   * The table is two 2.4 m tables end to end with eight chairs at it, and the
+   * chairs are `tera:seat.task-chair` because there is no bench anywhere in the
+   * catalogue. That is the one place in this pack where the library is being
+   * used past its brief and it shows: the honest fix is `defineAsset` with a
+   * bench of your own, not a task chair left out in the weather.
+   *
+   * The absence of lighting is not an oversight. `tera:light.pendant` is
+   * authored with its origin at a **mounting plane** and all its geometry below
+   * it, and there is nothing over the yard to mount one on — the fittings that
+   * light this space in the evening are on the loggia above, hung from a soffit
+   * that exists.
+   */
+  { id: "yard-table-w", kind: MEETING_TABLE, position: { x: 18.0, z: 13.4 }, rotation: NORTH },
+  { id: "yard-table-e", kind: MEETING_TABLE, position: { x: 20.4, z: 13.4 }, rotation: NORTH },
+  ...scatter("yard-chair-n", TASK_CHAIR, grid(17.2, 12.4, 4, 1, 1.2, 0), { rotation: SOUTH }),
+  ...scatter("yard-chair-s", TASK_CHAIR, grid(17.2, 14.4, 4, 1, 1.2, 0), { rotation: NORTH }),
+  ...scatter("yard-tree", TREE, [
+    { x: 11.4, z: 12.6 },
+    { x: 11.4, z: 16.2 },
+    { x: 24.6, z: 10.4 },
+    { x: 24.6, z: 16.2 },
+  ]),
+  ...scatter("yard-plant", PLANT, [
+    { x: 16.0, z: 9.4 },
+    { x: 22.4, z: 9.4 },
+    { x: 15.0, z: 16.6 },
+    { x: 24.6, z: 13.2 },
+  ]),
+];
+
+// ---- Zones ----------------------------------------------------------------
+
+/**
+ * Three labelled regions of floor and no behaviour anywhere.
+ *
+ * Two of them are spatial — anybody standing in the yard can see that it is the
+ * yard — and are built at both depths. The third names who sits somewhere rather
+ * than what the floor is for, which is org chart drawn on a plan, and is not
+ * built for an anonymous visitor. That is the line `audience` exists to draw and
+ * the reference pack's `ZONES` argues it at length; there is no point arguing it
+ * twice.
+ */
+const ZONES: Zone[] = [
+  { id: "zone-yard", name: "The Yard", outline: rect(COURT_W, COURT_N, COURT_E, COURT_S), colorKey: "social" },
+  {
+    id: "zone-fabrication",
+    name: "Fabrication",
+    outline: rect(COURT_E, COURT_N, WIDTH, COURT_S),
+    colorKey: "focus",
+  },
+  {
+    id: "zone-crew",
+    name: "Crew",
+    outline: rect(2.0, 18.4, 15.6, 24.8),
+    colorKey: "team-a",
+    audience: "private",
+  },
+];
+
+// ---- The upper floor ------------------------------------------------------
+
+/**
+ * Level 2: a long room over the street, two rooms over the west range, and the
+ * walkway that connects them.
+ *
+ * **Every coordinate below is in this level's own frame**, with its floor at
+ * zero; `Plan` adds `STOREY` to all of them exactly once. It stops at the
+ * courtyard's east line and at the courtyard's south line, because the east and
+ * south ranges are single storey — so the upper floor is an L, and the inside
+ * corner of that L is the loggia.
+ *
+ * The upper partitions do not line up with the ground floor's, and that is not
+ * an error to be tidied: the frame here is columns and beams, the brick is on
+ * the outside, and a warehouse that has been three businesses has its walls
+ * wherever the last one wanted them.
+ */
+
+const L2_ROOMS: Room[] = [
+  {
+    id: "loft",
+    name: "The Loft",
+    // Twenty-six metres of north-lit floor over the street range, with the
+    // paseo tunnelling underneath it. The one room in this building that could
+    // not exist on the ground floor, because on the ground floor the way in
+    // goes through it.
+    outline: rect(0, 0, LOFT_E, LOGGIA_N),
+    floor: CARPET,
+    ceiling: null,
+  },
+  {
+    id: "palmetto",
+    name: "Palmetto",
+    outline: rect(0, LOGGIA_N, LOGGIA_W, JESSE_N),
+    floor: CARPET_ACCENT,
+    ceiling: null,
+  },
+  {
+    id: "jesse",
+    name: "Jesse",
+    // The project room: concrete, three boards along the end wall, and nowhere
+    // comfortable to sit down. Its equivalent downstairs is the press, and both
+    // rooms read the same way for the same reason.
+    outline: rect(0, JESSE_N, LOGGIA_W, COURT_S),
+    floor: CONCRETE,
+    ceiling: null,
+  },
+  /**
+   * The loggia: 2.4 m of covered walkway wrapping the yard's north and west
+   * sides, and the circulation of the whole upper floor.
+   *
+   * An L, wound the way `rect` winds — down the west side, east along the
+   * bottom of the west arm, north up the courtyard edge, east along the
+   * courtyard's north edge, and back. It is not a corridor with a view; it is
+   * the same idea as the yard one storey up, which is why the two upper rooms
+   * open onto it and the loft opens onto it twice.
+   *
+   * 2.4 m is the width that matters. Under about two a covered walkway is a
+   * balcony you edge along; much over three and the rooms behind it stop getting
+   * the light the courtyard was cut for in the first place.
+   */
+  {
+    id: "loggia",
+    name: "The Loggia",
+    outline: [
+      { x: LOGGIA_W, z: LOGGIA_N },
+      { x: LOGGIA_W, z: COURT_S },
+      { x: COURT_W, z: COURT_S },
+      { x: COURT_W, z: COURT_N },
+      { x: LOFT_E, z: COURT_N },
+      { x: LOFT_E, z: LOGGIA_N },
+    ],
+    floor: WOOD,
+    ceiling: null,
+  },
+];
+
+const L2_WALLS: Wall[] = [
+  // -- The envelope, one storey up ------------------------------------------
+  //
+  // The same lines as the ground floor and not the same openings, which is the
+  // point of restating the walls rather than sharing them: this floor wants
+  // glass where the floor below wants a pier.
+  {
+    id: "l2-ext-north",
+    from: { x: 0, z: 0 },
+    to: { x: LOFT_E, z: 0 },
+    thickness: EXT_THICKNESS,
+    surface: BRICK,
+    openings: [
+      pane(1.6, 4.0, 0.9, 2.8),
+      pane(7.2, 4.0, 0.9, 2.8),
+      pane(12.8, 4.0, 0.9, 2.8),
+      pane(18.4, 4.0, 0.9, 2.8),
+    ],
+  },
+  {
+    id: "l2-ext-west",
+    from: { x: 0, z: 0 },
+    to: { x: 0, z: COURT_S },
+    thickness: EXT_THICKNESS,
+    surface: BRICK,
+    openings: [pane(1.6, 3.4, 0.9, 2.8), pane(7.0, 2.6, 0.9, 2.8), pane(12.6, 2.6, 0.9, 2.8)],
+  },
+  {
+    id: "l2-ext-east",
+    // The party wall again, and blind again. It is what the loft's lockers and
+    // its board hang on, which is a real consequence of a real constraint.
+    from: { x: LOFT_E, z: 0 },
+    to: { x: LOFT_E, z: COURT_N },
+    thickness: EXT_THICKNESS,
+    surface: BRICK,
+  },
+  {
+    id: "l2-ext-south",
+    // Where the two-storey part of the block stops. Beyond it is the roof of the
+    // south range, so this is an outside wall standing on an inside line.
+    from: { x: 0, z: COURT_S },
+    to: { x: COURT_W, z: COURT_S },
+    thickness: EXT_THICKNESS,
+    surface: BRICK,
+    openings: [pane(1.6, 3.0, 0.9, 2.8)],
+  },
+
+  // -- Internal --------------------------------------------------------------
+  {
+    id: "l2-palmetto-north",
+    from: { x: 0, z: LOGGIA_N },
+    to: { x: LOGGIA_W, z: LOGGIA_N },
+    openings: [doorway(3.0)],
+  },
+  {
+    id: "l2-loft-south",
+    from: { x: LOGGIA_W, z: LOGGIA_N },
+    to: { x: LOFT_E, z: LOGGIA_N },
+    // Two arches rather than one door, because this is the wall between a
+    // twenty-six-metre room and the only way out of it.
+    openings: [archway(2.0, 2.4), archway(12.0, 2.4)],
+  },
+  {
+    id: "l2-loggia-west",
+    from: { x: LOGGIA_W, z: LOGGIA_N },
+    to: { x: LOGGIA_W, z: COURT_S },
+    surface: GLASS,
+    openings: [doorway(3.6), doorway(7.6), pane(9.2, 1.6, 1.0, 2.4)],
+  },
+  {
+    id: "l2-palmetto-jesse",
+    from: { x: 0, z: JESSE_N },
+    to: { x: LOGGIA_W, z: JESSE_N },
+  },
+
+  /**
+   * The balustrade, in three pieces, and the gap between two of them is the way
+   * up.
+   *
+   * A **wall** and not a prop, for the reason `office.test.ts` already asserts
+   * about the reference pack's gallery: `Plan` derives the walk collider from
+   * the wall list, so a rail authored as furniture is an edge you walk off. The
+   * drop here is 5 m onto pavers.
+   *
+   * There are no openings anywhere in these three, and there is no `sill: 0,
+   * head: 1.1` trick either. An opening is a way through iff `sill <= 0` and
+   * `head >= 1.1`, and threading a doorway through a 1.1 m wall means authoring
+   * a hole whose head is exactly the wall's height — which works, and which is a
+   * clever thing that reads as a mistake. Two walls with 1.2 m of nothing
+   * between them says the same and cannot be misread. The stair arrives in that
+   * 1.2 m.
+   */
+  {
+    id: "rail-north",
+    from: { x: COURT_W, z: COURT_N },
+    to: { x: LOFT_E, z: COURT_N },
+    height: RAIL,
+    surface: STEEL,
+  },
+  {
+    id: "rail-west-n",
+    from: { x: COURT_W, z: COURT_N },
+    to: { x: COURT_W, z: STAIR_HEAD_N },
+    height: RAIL,
+    surface: STEEL,
+  },
+  {
+    id: "rail-west-s",
+    from: { x: COURT_W, z: STAIR_S },
+    to: { x: COURT_W, z: COURT_S },
+    height: RAIL,
+    surface: STEEL,
+  },
+];
+
+/**
+ * Twelve desks upstairs, in one bank. Seat ids are `loft-a-01` … `loft-a-12`,
+ * restarting at 01 as every bank's do and unique building-wide because the
+ * prefix is.
+ */
+const L2_DESK_BANKS: DeskBank[] = [
+  {
+    id: "loft-a",
+    desk: DESK,
+    chair: TASK_CHAIR,
+    origin: { x: 8.4, z: 1.9 },
+    rotation: NORTH,
+    columns: 6,
+    rows: 2,
+    pitch: 1.7,
+    rowPitch: 0.85,
+    facingRows: true,
+    seatOffset: 0.6,
+  },
+];
+
+const L2_SEATS: Seat[] = [
+  // Palmetto, six round a 2.4 m table.
+  { id: "palmetto-01", position: { x: 2.6, z: 7.9 }, facing: SOUTH, pose: "sit" },
+  { id: "palmetto-02", position: { x: 3.6, z: 7.9 }, facing: SOUTH, pose: "sit" },
+  { id: "palmetto-03", position: { x: 4.6, z: 7.9 }, facing: SOUTH, pose: "sit" },
+  { id: "palmetto-04", position: { x: 2.6, z: 9.9 }, facing: NORTH, pose: "sit" },
+  { id: "palmetto-05", position: { x: 3.6, z: 9.9 }, facing: NORTH, pose: "sit" },
+  { id: "palmetto-06", position: { x: 4.6, z: 9.9 }, facing: NORTH, pose: "sit" },
+
+  // Jesse. Standing at the boards, like the reference pack's project room.
+  { id: "jesse-01", position: { x: 1.4, z: 16.4 }, facing: SOUTH, pose: "stand" },
+  { id: "jesse-02", position: { x: 3.4, z: 16.4 }, facing: SOUTH, pose: "stand" },
+  { id: "jesse-03", position: { x: 5.4, z: 16.4 }, facing: SOUTH, pose: "stand" },
+
+  // The loggia, looking down into the yard. Set back from the rail, because a
+  // chair against a balustrade is a chair nobody chooses.
+  { id: "loggia-01", position: { x: 8.2, z: 12.0 }, facing: EAST, pose: "sit" },
+  { id: "loggia-02", position: { x: 8.2, z: 13.6 }, facing: EAST, pose: "sit" },
+  { id: "loggia-03", position: { x: 12.0, z: 6.9 }, facing: SOUTH, pose: "sit" },
+];
+
+const L2_PROPS: Prop[] = [
+  // -- The Loft -------------------------------------------------------------
+  ...scatter("loft-screen", PARTITION, grid(8.4, 2.325, 6, 1, 1.7, 0)),
+  ...scatter("loft-pedestal", PEDESTAL, [
+    { x: 7.0, z: 1.4 },
+    { x: 7.0, z: 3.2 },
+    { x: 18.4, z: 1.4 },
+    { x: 18.4, z: 3.2 },
+  ]),
+  ...scatter("loft-locker", LOCKER, grid(LOFT_E - EXT_FACE - 0.25, 1.4, 1, 3, 0, 1.3), {
+    rotation: EAST,
+  }),
+  {
+    id: "loft-board",
+    kind: WHITEBOARD,
+    position: { x: LOFT_E - EXT_FACE - BOARD_OFFSET, z: 5.0 },
+    rotation: EAST,
+  },
+  {
+    id: "loft-display",
+    kind: DISPLAY,
+    // On the loggia wall, clear of both arches.
+    position: { x: 23.0, z: LOGGIA_N - INT_FACE - DISPLAY_OFFSET },
+    rotation: SOUTH,
+  },
+  ...scatter("loft-tree", TREE, [
+    { x: 2.0, z: 4.4 },
+    { x: 24.0, z: 4.4 },
+  ]),
+  ...scatter("loft-plant", PLANT, grid(9.2, 0.7, 3, 1, 3.4, 0)),
+  ...scatter("loft-light", TROFFER, grid(2.4, 1.6, 7, 2, 3.6, 2.8), { elevation: UPPER }),
+
+  // -- Palmetto -------------------------------------------------------------
+  { id: "palmetto-table", kind: MEETING_TABLE, position: { x: 3.6, z: 8.9 }, rotation: NORTH },
+  ...scatter("palmetto-chair-n", TASK_CHAIR, grid(2.6, 7.9, 3, 1, 1.0, 0), { rotation: SOUTH }),
+  ...scatter("palmetto-chair-s", TASK_CHAIR, grid(2.6, 9.9, 3, 1, 1.0, 0), { rotation: NORTH }),
+  {
+    id: "palmetto-display",
+    kind: DISPLAY,
+    position: { x: EXT_FACE + DISPLAY_OFFSET, z: 8.9 },
+    rotation: WEST,
+  },
+  { id: "palmetto-plant", kind: PLANT, position: { x: 6.4, z: 7.0 }, rotation: NORTH },
+  ...scatter("palmetto-light", TROFFER, grid(2.0, 7.6, 2, 2, 3.2, 2.6), { elevation: UPPER }),
+
+  // -- Jesse ----------------------------------------------------------------
+  ...scatter("jesse-board", WHITEBOARD, grid(1.4, COURT_S - EXT_FACE - BOARD_OFFSET, 3, 1, 2.0, 0), {
+    rotation: SOUTH,
+  }),
+  { id: "jesse-table", kind: MEETING_TABLE, position: { x: 3.6, z: 14.4 }, rotation: NORTH },
+  ...scatter("jesse-shelf", SHELF, grid(5.0, JESSE_N + INT_FACE + 0.18, 2, 1, 1.0, 0)),
+  { id: "jesse-plant", kind: PLANT, position: { x: 6.4, z: 16.8 }, rotation: NORTH },
+  ...scatter("jesse-light", TROFFER, grid(2.0, 13.0, 2, 2, 3.2, 3.0), { elevation: UPPER }),
+
+  // -- The Loggia -----------------------------------------------------------
+  // Furnished as somewhere to sit and not as a route, and everything set back
+  // 1.4 m from the rail. The pendants are the fittings that light the yard: they
+  // hang from the soffit of this walkway, which is the only thing over the
+  // courtyard for one to hang from.
+  ...scatter("loggia-chair", LOUNGE_CHAIR, [
+    { x: 8.2, z: 12.0 },
+    { x: 8.2, z: 13.6 },
+  ], { rotation: EAST }),
+  { id: "loggia-chair-n", kind: LOUNGE_CHAIR, position: { x: 12.0, z: 6.9 }, rotation: SOUTH },
+  { id: "loggia-side", kind: SIDE_TABLE, position: { x: 8.2, z: 12.8 }, rotation: NORTH },
+  ...scatter("loggia-plant", PLANT, [
+    { x: 8.9, z: 9.0 },
+    { x: 8.9, z: 16.6 },
+    { x: 16.0, z: 7.7 },
+    { x: 22.0, z: 7.7 },
+  ]),
+  ...scatter("loggia-pendant", PENDANT, grid(8.4, 8.0, 1, 3, 0, 3.2), { elevation: UPPER }),
+  ...scatter("loggia-light", PENDANT, grid(12.0, 7.2, 4, 1, 3.6, 0), { elevation: UPPER }),
+];
+
+const L2_ZONES: Zone[] = [
+  {
+    id: "zone-loggia",
+    name: "The Loggia",
+    outline: rect(LOGGIA_W, LOGGIA_N, COURT_W, COURT_S),
+    colorKey: "social",
+  },
+];
+
+// ---- Viewpoints -----------------------------------------------------------
+
+/**
+ * Six poses, and the first one is the passage rather than the plan.
+ *
+ * `viewpoints[0]` is the arrival pose. `interiors/types.ts` suggests reception;
+ * the reference pack argues for the establishing shot instead, on the grounds
+ * that arriving inside a room before you have seen the shape of a building is
+ * disorienting. This pack takes the third option and arrives **under the arch**,
+ * because the one shot that shows what kind of building this is is the one taken
+ * from inside the way in: a dark three-metre passage with a lit courtyard at the
+ * end of it. You have seen the plan by the time you have walked eight metres,
+ * which answers the reference pack's objection rather than ignoring it.
+ *
+ * `distance` is metres from the target to the camera and `height` is metres
+ * above *this level's* floor. The camera sits at `at + (sin r, cos r) * distance`
+ * and looks back at the target, so `rotation: Math.PI` is a camera to the north
+ * looking south — which is how the paseo shot points down the passage.
+ */
+const VIEWPOINTS: Viewpoint[] = [
+  {
+    id: "paseo",
+    number: "01",
+    label: "The Paseo",
+    shortLabel: "Paseo",
+    levelId: "level-1",
+    focus: { at: { x: 18.1, z: 9.0 }, distance: 8, height: 1.7, rotation: Math.PI },
+    description:
+      "Standing under the street arch looking down the passage into the yard. Three metres wide and eight and a half from the pavement to the yard, and the only way into this building anybody arrives by — everything else here is on the other side of it.",
+  },
+  {
+    id: "block",
+    number: "02",
+    label: "The Whole Block",
+    shortLabel: "The Block",
+    levelId: "level-1",
+    // Aimed at the middle of the yard rather than the middle of the plate,
+    // because the middle of the plate is the thing that is not there.
+    focus: { at: { x: 18.0, z: 13.0 }, distance: 44, height: 26, rotation: 0.5 },
+    description:
+      "Thirty-six metres by twenty-six with a hole in the middle of it. A ring of rooms never more than nine and a half metres deep on the long sides, two storeys on two sides and one on the other two, and the courtyard doing the job a corridor does in every other pack in this directory.",
+  },
+  {
+    id: "yard",
+    number: "03",
+    label: "The Yard",
+    shortLabel: "Yard",
+    levelId: "level-2",
+    // From the loggia's west arm, looking east across the void at the far range.
+    // On level 2, so `height` is measured from the walkway rather than the
+    // pavers five metres below it.
+    focus: { at: { x: 18.0, z: 12.0 }, distance: 9.6, height: 1.7, rotation: -Math.PI / 2 },
+    description:
+      "From the walkway, looking across the middle of the block. Sixteen metres of open air with a table in it, the shop's shutter on the far side, and nothing overhead — the one room in this office that is not a room.",
+  },
+  {
+    id: "works",
+    number: "04",
+    label: "The Works",
+    shortLabel: "Works",
+    levelId: "level-1",
+    focus: { at: { x: 8.6, z: 21.6 }, distance: 12, height: 4.0, rotation: 1.2 },
+    description:
+      "Twenty-eight seats in two benches along the back of the block, glazed onto the yard on one side and the alley on the other. The bench nearer the yard is works-a-01 through works-a-14.",
+  },
+  {
+    id: "shop",
+    number: "05",
+    label: "The Shop",
+    shortLabel: "Shop",
+    levelId: "level-1",
+    // Standing in the yard looking east through the open shutter.
+    focus: { at: { x: 31.0, z: 13.0 }, distance: 9, height: 2.6, rotation: 4.9 },
+    description:
+      "Four metres of roller shutter onto the courtyard, with the benches inside it and the party wall behind them. Work comes out of this room and gets finished in the middle of the building.",
+  },
+  {
+    id: "loft",
+    number: "06",
+    label: "The Loft",
+    shortLabel: "Loft",
+    levelId: "level-2",
+    focus: { at: { x: 12.0, z: 3.0 }, distance: 13, height: 4.0, rotation: 1.4 },
+    description:
+      "Twenty-six metres of unbroken floor over the street range, with the paseo tunnelling under the far end of it. Twelve seats, north light on one side and the loggia on the other.",
+  },
+];
+
+// ---- The pack -------------------------------------------------------------
+
+const LEVEL_1: Level = {
+  id: "level-1",
+  name: "Ground",
+  elevation: 0,
+  wallHeight: GROUND,
+  wallThickness: INT_THICKNESS,
+  wallSurface: PAINT,
+  floorplan: {
+    rooms: ROOMS,
+    walls: WALLS,
+    props: PROPS,
+    deskBanks: DESK_BANKS,
+    seats: SEATS,
+    zones: ZONES,
+  },
+};
+
+/**
+ * The upper storey, at floor-to-*floor* above the ground.
+ *
+ * `elevation` is `STOREY` and not `GROUND`: 4.4 would bury this slab in the
+ * timber it is supposed to be sitting on. `Plan` adds it to every coordinate on
+ * the level exactly once, which is what lets the `L2_*` section above be read
+ * without holding 5 m in your head.
+ */
+const LEVEL_2: Level = {
+  id: "level-2",
+  name: "Upper",
+  elevation: STOREY,
+  wallHeight: UPPER,
+  wallThickness: INT_THICKNESS,
+  wallSurface: PAINT,
+  floorplan: {
+    rooms: L2_ROOMS,
+    walls: L2_WALLS,
+    props: L2_PROPS,
+    deskBanks: L2_DESK_BANKS,
+    seats: L2_SEATS,
+    zones: L2_ZONES,
+  },
+};
+
+export const MATEO_COURT: Office = {
+  id: "mateo-court",
+  name: "Mateo Court",
+  levels: [LEVEL_1, LEVEL_2],
+  viewpoints: VIEWPOINTS,
+  /**
+   * The Arts District, on the board `cities/socal.ts` draws. See
+   * `MATEO_COURT_SITE` above for where the three numbers come from and which of
+   * them decides what: the short version is that 1.2 m is a loading dock, 36° is
+   * the 1781 pueblo grid, and the second of those is why the loggia is on the
+   * two sides of the yard it is on.
+   */
+  site: MATEO_COURT_SITE,
+  meta: {
+    description:
+      "A courtyard block in the Arts District: a ring of rooms round a yard with the roof off, an outdoor stair and an open walkway over it. The third pack, and the one where the circulation is outside.",
+    author: "Lumbridge",
+    license: "CC0-1.0",
+    version: "1.0.0",
+    updated: "2026-08-07",
+  },
+};
+
+export default MATEO_COURT;
diff --git a/src/offices/sites.ts b/src/offices/sites.ts
index 307cd20..1c925cb 100644
--- a/src/offices/sites.ts
+++ b/src/offices/sites.ts
@@ -44,16 +44,31 @@ export const FRONTIER_VALLEY_SITE: OfficeSite = {
   label: "Alameda Point",
 };
 
+/**
+ * A courtyard block in the Arts District, square to the pueblo grid rather than
+ * to the compass — which is the whole reason `heading` is a field. See
+ * `mateo-court.ts` for where the numbers come from: 1.2 m is a loading dock, and
+ * 36° is the 1781 survey the downtown street grid still follows.
+ */
+export const MATEO_COURT_SITE: OfficeSite = {
+  lat: 34.0395,
+  lng: -118.2288,
+  elevation: 1.2,
+  heading: 36,
+  label: "Arts District, Los Angeles",
+};
+
 /**
  * Every building this build can walk into, for the city to point at.
  *
  * `id` matches the pack's own `Office.id` and the `OFFICES` table in `main.ts`,
  * which is what lets a click on a marker resolve to a door. Keeping the three in
- * step is not enforced by the type system; it is enforced by there being exactly
- * two of them and by `office.test.ts` asserting that each pack's site is the one
- * named here.
+ * step is not enforced by the type system; it is enforced by there being three of
+ * them and by `office.test.ts` asserting that each pack's site is the very
+ * object named here — identity, not equality, so a restated coordinate fails.
  */
 export const OFFICE_SITES: { id: string; name: string; site: OfficeSite }[] = [
   { id: "lumbridge-hq", name: "Lumbridge HQ", site: LUMBRIDGE_HQ_SITE },
   { id: "frontier-valley", name: "Frontier Valley", site: FRONTIER_VALLEY_SITE },
+  { id: "mateo-court", name: "Mateo Court", site: MATEO_COURT_SITE },
 ];
diff --git a/src/test/office.test.ts b/src/test/office.test.ts
index f5bbc7b..ea12caf 100644
--- a/src/test/office.test.ts
+++ b/src/test/office.test.ts
@@ -27,10 +27,77 @@ import { describe, it } from "node:test";
 import { Plan } from "../interiors/plan.ts";
 import LUMBRIDGE_HQ from "../offices/lumbridge-hq.ts";
 import FRONTIER_VALLEY from "../offices/frontier-valley.ts";
+import MATEO_COURT from "../offices/mateo-court.ts";
 import { OFFICE_SITES } from "../offices/sites.ts";
 
 const plan = new Plan(LUMBRIDGE_HQ, { warn: false });
 
+/**
+ * Which rooms on a level can be walked to from a point, at 0.1 m.
+ *
+ * Shared by all three packs, because it was written three times otherwise and
+ * the third copy is where a subtle divergence lives. The grid is finer than it
+ * looks like it needs to be and that is not optional: `blocked` inflates by the
+ * walker's radius, so threading a 0.9 m door with a 0.3 m radius leaves 0.3 m of
+ * clear width, and a 0.25 m grid can straddle that and report a sealed room that
+ * is fine. Erring the other way is not possible — a coarser grid only ever
+ * reaches fewer rooms, so a pass is always a real pass.
+ */
+function reachableRoomsOf(
+  plan: Plan,
+  levelId: string,
+  entry: { x: number; z: number },
+): Set<string> {
+  const STEP = 0.1;
+  const RADIUS = 0.3;
+  const b = plan.bounds;
+  const cols = Math.ceil(b.width / STEP);
+  const rows = Math.ceil(b.depth / STEP);
+  const at = (c: number, r: number) => ({ x: b.minX + c * STEP, z: b.minZ + r * STEP });
+
+  const room: (string | null)[] = new Array(cols * rows).fill(null);
+  for (let r = 0; r < rows; r += 1) {
+    for (let c = 0; c < cols; c += 1) {
+      room[r * cols + c] = plan.roomAt(levelId, at(c, r))?.id ?? null;
+    }
+  }
+
+  const sc = Math.round((entry.x - b.minX) / STEP);
+  const sr = Math.round((entry.z - b.minZ) / STEP);
+  assert.ok(room[sr * cols + sc], `${levelId}'s entry point is not inside a room`);
+
+  const seen = new Uint8Array(cols * rows);
+  const queue: [number, number][] = [[sc, sr]];
+  seen[sr * cols + sc] = 1;
+  while (queue.length > 0) {
+    const [c, r] = queue.pop() as [number, number];
+    for (const [dc, dr] of [
+      [1, 0],
+      [-1, 0],
+      [0, 1],
+      [0, -1],
+    ]) {
+      const nc = c + (dc as number);
+      const nr = r + (dr as number);
+      if (nc < 0 || nr < 0 || nc >= cols || nr >= rows) continue;
+      const i = nr * cols + nc;
+      if (seen[i] === 1 || room[i] === null) continue;
+      if (plan.blocked(levelId, at(c, r), at(nc, nr), RADIUS)) continue;
+      seen[i] = 1;
+      queue.push([nc, nr]);
+    }
+  }
+
+  const reached = new Set<string>();
+  for (let i = 0; i < seen.length; i += 1) {
+    const id = room[i];
+    if (seen[i] === 1 && id != null) reached.add(id);
+  }
+  return reached;
+}
+
+
+
 describe("the reference pack resolves cleanly", () => {
   /** Checklist item 1, and the one everything else here depends on. */
   it("reports no problems at all", () => {
@@ -398,7 +465,7 @@ describe("the sites", () => {
   });
 
   it("carry headings inside the compass", () => {
-    for (const pack of [LUMBRIDGE_HQ, FRONTIER_VALLEY]) {
+    for (const pack of [LUMBRIDGE_HQ, FRONTIER_VALLEY, MATEO_COURT]) {
       const h = pack.site?.heading ?? 0;
       assert.ok(h >= 0 && h < 360, `${pack.id} has a heading of ${h}`);
     }
@@ -430,12 +497,12 @@ describe("the office site table", () => {
   it("lists exactly the packs this build ships", () => {
     assert.deepEqual(
       OFFICE_SITES.map((e) => e.id).sort(),
-      [FRONTIER_VALLEY.id, LUMBRIDGE_HQ.id].sort(),
+      [FRONTIER_VALLEY.id, LUMBRIDGE_HQ.id, MATEO_COURT.id].sort(),
     );
   });
 
   it("hands each pack the very same site object it publishes", () => {
-    for (const pack of [LUMBRIDGE_HQ, FRONTIER_VALLEY]) {
+    for (const pack of [LUMBRIDGE_HQ, FRONTIER_VALLEY, MATEO_COURT]) {
       const entry = OFFICE_SITES.find((e) => e.id === pack.id);
       assert.ok(entry, `${pack.id} is missing from OFFICE_SITES`);
       // Identity, not equality: the packs import from the table, so anything
@@ -444,3 +511,104 @@ describe("the office site table", () => {
     }
   });
 });
+
+/**
+ * The third pack, and the first on the other board.
+ *
+ * A courtyard block: a ring of rooms round an open-air yard with **no corridor
+ * anywhere** — every door opens onto the yard, and the yard does the job a
+ * corridor does in the other two. That makes it the first pack whose
+ * circulation is outdoors, and the first whose `ceiling: null` means there is
+ * genuinely no ceiling rather than "take the lid off so the shot can see in".
+ */
+describe("the Mateo Court pack", () => {
+  const mc = new Plan(MATEO_COURT, { warn: false });
+
+  it("resolves with no problems", () => {
+    assert.deepEqual(
+      mc.problems.map((p) => `${p.where}: ${p.message} (${p.action})`),
+      [],
+    );
+  });
+
+  it("stacks its upper floor floor-to-floor", () => {
+    assert.deepEqual(
+      mc.levels.map((l) => [l.id, l.floorY]),
+      [
+        ["level-1", 0],
+        ["level-2", 5],
+      ],
+    );
+  });
+
+  it("keeps its seat ids disjoint from both other packs", () => {
+    const mine = mc.allSeats().map((s) => s.id);
+    assert.equal(new Set(mine).size, mine.length);
+    const others = new Set([
+      ...plan.allSeats().map((s) => s.id),
+      ...new Plan(FRONTIER_VALLEY, { warn: false }).allSeats().map((s) => s.id),
+    ]);
+    assert.deepEqual(mine.filter((id) => others.has(id)), []);
+  });
+
+  /**
+   * **The check that matters most in this pack.**
+   *
+   * Every door through the 0.25 m courtyard skin is 1.2 m rather than the 0.9 m
+   * the rest of the library uses, and that is not a style choice: `blocked`
+   * inflates by the walker's radius *and* by the wall's thickness, so a 0.9 m
+   * leaf in a wall this thick leaves too little clear width and seals the room
+   * behind it — while rendering perfectly. Two rooms were sealed exactly that
+   * way on the pack's first pass. A well-meaning edit back to 0.9 for
+   * consistency would do it again, and this is the only thing that would say so.
+   */
+  for (const [levelId, entry] of [
+    ["level-1", { x: 18.1, z: 1.0 }],
+    ["level-2", { x: 8.4, z: 10.4 }],
+  ] as const) {
+    it(`${levelId}: every room reachable from the way in`, () => {
+      const reached = reachableRoomsOf(mc, levelId, entry);
+      const sealed = mc.levels
+        .find((l) => l.id === levelId)!
+        .rooms.map((r) => r.id)
+        .filter((id) => !reached.has(id));
+      assert.deepEqual(sealed, [], `sealed rooms on ${levelId}`);
+    });
+  }
+
+  /**
+   * The loggia rail, and the gap in it.
+   *
+   * Both halves matter and only together: a rail that also sealed the stair head
+   * would pass an assertion that only checked you cannot fall off.
+   */
+  it("guards the loggia edge without sealing the way up", () => {
+    assert.ok(mc.blocked("level-2", { x: 8.8, z: 9.0 }, { x: 10.6, z: 9.0 }, 0.3));
+    assert.ok(mc.blocked("level-2", { x: 8.8, z: 14.0 }, { x: 10.6, z: 14.0 }, 0.3));
+    assert.ok(mc.blocked("level-2", { x: 18.0, z: 7.6 }, { x: 18.0, z: 9.4 }, 0.3));
+    assert.ok(
+      !mc.blocked("level-2", { x: 8.8, z: 10.4 }, { x: 10.4, z: 10.4 }, 0.3),
+      "the stair head is walled off",
+    );
+  });
+
+  it("stands its upper-floor occupants on the deck", () => {
+    for (const id of ["loggia-01", "palmetto-01"]) {
+      assert.equal(mc.seat(id)?.y, 5, `${id} is not on the deck`);
+    }
+  });
+
+  it("leaves the yard open to the sky", () => {
+    const court = mc.levels[0]?.rooms.find((r) => r.id === "court");
+    assert.ok(court, "no courtyard");
+    assert.equal(court.ceiling, null);
+  });
+
+  /** The point of the pack: the Southland board finally has a door. */
+  it("stands on the Southland board", () => {
+    const site = MATEO_COURT.site;
+    assert.ok(site);
+    assert.ok(site.lat > 33.28 && site.lat < 34.36, `latitude ${site.lat}`);
+    assert.ok(site.lng > -118.88 && site.lng < -117.22, `longitude ${site.lng}`);
+  });
+});