zz-meridian 0.16.1 → 0.16.3

package/dist/migrations.js

@@ -422,7 +422,47 @@ export const RELEASE_MIGRATIONS = [
         instructions: 'The release renamed them with no redirect, and an update writes none of the team\'s pages, views or tests. Each file listed is one of them or names one: a page or a view, the view tools, `src/app.config.ts`\'s nav and the feature ids it names, the routes of `scripts/verify.config.ts`, or a shipped test that expects them. A project that kept the sample\'s pages as they were brings the release\'s over: `app/(dashboard)/` and `app/embed/`, `src/views/`, `src/data/`, `src/lib/assistant/` beside `prompt.ts`, `src/app.config.ts` with its own `app` kept, and each shipped test as the release has it; a file listed here that the release no longer has is deleted. A project that made the pages its own keeps its own names, makes the changes this release\'s other migrations list in them, and reads "not applicable" for the assistant walk-through\'s steps on Home and Now (`scripts/lib/sample.ts`).',
         checks: GATE_AND_BUILD,
     },
+    {
+        id: 'marker-measured-on-observe',
+        since: '0.16.2',
+        applies: railObserverNeverAnswers,
+        summary: 'A test mounts the rail over a `ResizeObserver` whose `observe` answers nothing: the rail takes its first measurement from the observer now, where it took one by hand.',
+        instructions: 'Bring `tests/rail-marker.test.tsx` over from the release as it has it. Since 0.16.2 `src/components/patterns/rail/index.tsx` reads no offset of its own — a rail mounts inside the tap that opens the phone drawer, and a read there lays the page out inside that tap — so the marker\'s first position is the one `observe` delivers, after the effect that called it. A test whose fake answers `observe` with an empty body expects the marker before any delivery and fails; the release\'s fake answers it with the callback, `observe() { for (const cb of observers) queueMicrotask(cb); }`, and reads the marker after that delivery. A test of your own that mounts the rail changes the same way.',
+        checks: ['gate'],
+    },
+    {
+        id: 'view-page-matched-as-next',
+        since: '0.16.3',
+        applies: (root) => (/\bfunction onPage\s*\(/.test(text(root, 'app/api/assistant/route.ts') ?? '') ? ['app/api/assistant/route.ts'] : null),
+        summary: 'The assistant route finds the view of the page a person is on with `viewAt` from `src/lib/shared-context.ts`, which matches a catch-all `page` as Next.js does.',
+        instructions: 'In `app/api/assistant/route.ts`, delete the local `onPage` and find the view with `viewAt` from `@/lib/shared-context`: `const at = viewAt(viewTools, path); const view = at && views.includes(at) ? at : undefined;`, where `views` are the view tools the person may use. `onPage` matched a `[...name]` segment as one segment and a `[[...name]]` never, so a view whose `page` is a catch-all (`/docs/[...path]`) was handed its prepared query at one depth only. `viewAt` matches as Next.js does — `[...name]` one or more segments, `[[...name]]` zero or more — and where two views match one address it takes the one Next.js renders, before asking whether the person may use it, so a less specific view never stands in for the page.',
+        checks: ['gate'],
+    },
+    {
+        id: 'journey-moved',
+        since: '0.16.3',
+        applies: (root) => matching(root, (rel, src) => importsOf(rel, src).some(({ from, names, namespace }) => from === 'scripts/navigate' && (namespace !== null || names.some((n) => n !== 'workspaceHomes')))),
+        summary: 'The navigation journey moved from `scripts/navigate.ts` to `scripts/lib/journey.ts`, which keeps every source file Meridian ships under 700 lines.',
+        instructions: 'Bring `tests/navigate-start.test.ts` and `tests/navigate-menu-start.test.ts` over from the release as it has them. A file of your own that imports the journey — `startFor`, `journeyStart`, `journey`, `drawerRoutes`, `prepare`, `liveRefresh`, `Fail` and the types `Device`, `Metric`, `Condition`, `Measured`, `Sample` and `NavConfig` — imports it from `scripts/lib/journey.ts` instead; `scripts/navigate.ts` keeps the command and `workspaceHomes` only.',
+        checks: ['gate'],
+    },
+    {
+        id: 'today-in-timezone',
+        since: '0.16.3',
+        applies: (root) => matching(root, (rel, src) => (rel === 'app/api/assistant/route.ts' || rel === 'src/data/metrics.ts') && /\bconst today = clock\(\)\.toISOString\(\)\.slice\(0, 10\)|\btoday: clock\(\)\.toISOString\(\)\.slice\(0, 10\)/.test(src)),
+        summary: "Today is the day in `app.timezone` wherever a day is cut: `dayOf(clock())` from `src/lib/format-date.ts`, not the UTC date.",
+        instructions: "Replace `clock().toISOString().slice(0, 10)` with `dayOf(clock())` (`dayOf` in `src/lib/format-date.ts`) in each file listed: the prepared query's `today` in `app/api/assistant/route.ts`, and `readDays`'s today in `src/data/metrics.ts`. The prompt has told the model today in `app.timezone` all along, while the prepared query and the page cut their periods at the UTC date, so east of UTC after local midnight (west of UTC in the evening) the model's today and its `7d` window's end were a day apart. A day row is kept under its day in `app.timezone`, so a file of your own that compares an instant's day with one — `now.slice(0, 10)`, `at.slice(0, 10)` — asks `dayOf` too. A product whose `app.timezone` is UTC sees no change. A project that kept the sample's views brings `src/views/now-parts.ts`, `src/views/revenue-parts.ts`, `src/views/customer-context.ts`, `src/views/customer.tsx` and `src/views/members.tsx` over from the release.",
+        checks: ['gate'],
+    },
 ];
+/**
+ * A test of the rail that stands over a fake `ResizeObserver` answering `observe` with nothing (0.16.2). The lookbehind
+ * keeps `unobserve() {}` out of it: a fake that answers the callback and also stubs `unobserve` is the release's own
+ * shape, and the one thing to bring over.
+ */
+function railObserverNeverAnswers(root) {
+    return matching(root, (rel, src) => /\.(?:test|spec)\.tsx?$/.test(rel) && /\bRail\b/.test(src) && /\bResizeObserver\b/.test(src) && /(?<![\w$.])observe\s*\(\s*\)\s*\{\s*\}/.test(src));
+}
 /** The team's files that import an export 0.16.0 removed from a managed module, by name or through a namespace. */
 function removedExportReaders(root) {
     const removed = { 'src/lib/insight': ['deviations', 'largest', 'runs', 'weekendRatio'], 'src/lib/collection': ['queryInput'] };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zz-meridian",
-  "version": "0.16.1",
+  "version": "0.16.3",
   "description": "Bring ZZ Meridian, a dashboard design system, into a Next.js project, or start a new dashboard on it. Copies the files in; nothing depends on this package at runtime.",
   "license": "MIT",
   "type": "module",

package/payload/CHANGELOG.md

@@ -2,6 +2,43 @@
 
 Every release of ZZ Meridian, newest first. Versions follow semver: a removed or renamed token, prop or card is major; a new card, token or variant is minor; a corrected value is a patch. Each entry says what breaks and what to do instead.
 
+## [0.16.3] · 2026-10-17
+
+### Breaking
+
+- **The navigation journey moved to `scripts/lib/journey.ts`.** A created project's `tests/navigate-start.test.ts` and `tests/navigate-menu-start.test.ts` import `startFor` and `journeyStart` from `scripts/navigate.ts`, which no longer has them, so they fail the type check until they are brought over. The files are the project's own, so the update does not write them: it reports them as the migration `journey-moved` — bring the release's copies over, and import the journey (`journey`, `journeyStart`, `startFor`, `drawerRoutes`, `prepare`, `liveRefresh`, `Fail` and its types) from `scripts/lib/journey.ts` in a file of your own. `scripts/navigate.ts` keeps the command and `workspaceHomes`.
+
+### Changed
+
+- **The default verify does less twice, and the gate runs its three long checks side by side.** `scripts/gate.ts` runs the type check, the lint and the tests together once the quick checks before them pass, and prints their lines in the same order as before. All three run to the end, so one failure never hides another. The build inside `pnpm verify` no longer type-checks the tree a second time, because the gate has just checked it with the same tsconfig: verify sets `MERIDIAN_TYPES_CHECKED` for that build, and the template's `next.config.ts` reads it as `typescript.ignoreBuildErrors`. Every other `next build` still checks types. An adopted project keeps its own `next.config`, so its verify checks types twice as before, unless it adds that line. Measured from a clean tree on one machine: the gate 22.9 → 15.4 s, the build 14.5 → 9.5 s, the default verify 62.2 → 49.8 s. The release's verify had reached 193 s against its 180 s limit on the slowest runner CPU.
+- **Every source file Meridian ships is under 700 lines** ([#41](https://github.com/zhixuan312/zz-meridian/issues/41)). `scripts/navigate.ts` had grown to 775, the only managed file past a ceiling a project may hold its own files to — and a project cannot split a managed file, because the update restores it. The journey and its measurements are `scripts/lib/journey.ts` now (467 lines) and `scripts/navigate.ts` keeps the command and its report (319); nothing either does changed. A test of the package holds every shipped file under `src`, `app`, `scripts` and `tests` to 700 lines, so a release cannot grow one past it again.
+
+### Fixed
+
+- **Today is the product's day wherever a day is cut** ([#42](https://github.com/zhixuan312/zz-meridian/issues/42)). The assistant's prompt told the model today in `app.timezone`, while the prepared query (`today` in `app/api/assistant/route.ts`) and the pages' periods (`readDays` in `src/data/metrics.ts`) cut their days at the UTC date. So east of UTC after local midnight, and west of it in the evening, the model's today and the end of its `7d` window were a day apart, and a day row — kept under its day in `app.timezone` — fell on the wrong side of the cut. **`dayOf(at)`** (`src/lib/format-date.ts`) is the calendar day of an instant in `app.timezone`, and the route, `readDays` and the sample's views (Now's month and its runs by day, Revenue's ladder and trials, a customer's busiest day and trial days left, a new member's joined date) ask it now. A product whose `app.timezone` is UTC sees no change. The route and `src/data/metrics.ts` are the team's own files, so the update reports them as the migration `today-in-timezone` — replace `clock().toISOString().slice(0, 10)` with `dayOf(clock())`.
+- **A view whose page is a catch-all route is handed its prepared query at every depth** ([#40](https://github.com/zhixuan312/zz-meridian/issues/40)). The assistant route matched a view's `page` against the address segment by segment and required the two to have as many segments, reading `[...name]` as any one segment and `[[...name]]` as one too: a view on `/docs/[...path]` was the page at `/docs/a` and not at `/docs/a/b`, which the same Next.js route renders, and one on `/docs/[[...path]]` was never the page at `/docs`. The match is `viewAt` in `src/lib/shared-context.ts` now, and it matches as Next.js does — `[...name]` one or more segments, `[[...name]]` zero or more — and where two views match one address it takes the one Next.js renders: a static segment over `[name]`, that over a catch-all. The route asks whether the person may use that view after choosing it, so a less specific view never stands in for the page. `app/api/assistant/route.ts` is the team's own file, so the update does not write it: it reports it as the migration `view-page-matched-as-next` — delete the route's `onPage` and find the view with `viewAt`. `node scripts/ask.ts` asks a catch-all page's questions on a link of any depth, and an optional catch-all's on the page with none.
+
+## [0.16.2] · 2026-10-16
+
+### Breaking
+
+- **A created project's shipped test of the rail fails until it is brought over.** `tests/rail-marker.test.tsx` — the template's test of the rail's marker — stands over a `ResizeObserver` whose `observe` answers with nothing, which only worked because the rail read its own offsets as well. That read is what 0.16.2 removed (see **Changed**), so the file now asserts a marker position that nothing has measured yet. The file is the project's own from the moment it is created, so the update does not write it: it reports it as the migration `marker-measured-on-observe`, with the fix — bring the release's `tests/rail-marker.test.tsx` over as the release has it. Its fake answers `observe` with the callback and reads the marker after that delivery; a test of your own that mounts the rail answers `observe` the same way.
+- **The Web Vitals check fails on a dropped frame.** `scripts/vitals.ts` counted frames over 50 ms while its taps played out and printed the number on every line without ever failing on it, so a `verify --full` that passed was not being held to the floor its own header states. It fails now: `frames over 50 ms` must read `0 of N`. Two things about how it counts changed with it. Frames are read **in the tap's own window and no other** — the recording used to run from the moment the page opened, straight through the Escape that closes what a tap opened and the settle after it, which the INP measurement in the same loop already excludes because it is the check's own work and not the person's. And a page that drops one frame is **measured a second time in full** before it is failed, because a single frame in two hundred is inside the noise of the host a four-times throttle is measuring: a page that drops one twice is a page that stutters. A run that was passing still passes; a run that was failing now says so, and names the control the frame was dropped on.
+
+### New
+
+- **`useNavDrawer(asked)`** (`src/components/base/use-nav-drawer.ts`) — whether a navigation drawer is open, for the frame that owns one. It carries the bookkeeping both shells had written for themselves: the drawer opens for every press of the top bar's button that it has not answered yet, remembers the page it opened on so a navigation closes it, and forgets that page when the address moves. The Atlas's copy was missing the last of those, so opening the contents on a phone, following a link and pressing Back re-opened the drawer with nobody pressing anything. A product that wrote the same bookkeeping for a drawer of its own should read it from here.
+
+### Changed
+
+- **The rail reads its own geometry from the observer's first delivery, not by hand.** The rail measured itself with an `offsetTop` read as well as through its `ResizeObserver`, and a rail mounts inside the tap that opens the phone drawer — so that read made the browser lay the whole page out inside the tap: measured at a 50 ms frame on a throttled phone, against 33 ms for the mount alone. The observer's first delivery reports the same numbers after the browser has laid out for itself. Nothing moves while a measurement is missing: the current item draws the same pill itself.
+- **The Atlas's front page names the latest release, not the work toward the next one.** It read the first section of `CHANGELOG.md` — which is `[Unreleased]` while a release is pending, and has no version — so the card showed pending work under the version it was going to be released as. It also read the version, the date and the summary with one pattern that refused the `#` of `### Breaking`, the first line under every heading in that file: the date fell to an empty fallback and the card printed `0.16.2 · ` with nothing after the separator, on every release. The heading and the paragraph are read separately now, and the "Full changelog" link no longer shares the kicker's line.
+- **`AppMark` names its own gradient.** The mark is a client component now, because each draws a sheen whose id has to be its own: a page holds more than one mark (the Atlas draws one in the phone's bar and one in the shelf, both mounted at every width), and a fixed `id` was a duplicate on every one of those pages, with a `url(#…)` naming two elements. A product that overrode the mark's markup rather than its `app.logo` is unaffected; the first load of `/embed/now` in this template moved 809 → 811 KiB.
+
+### Fixed
+
+- **A new dashboard's own `pnpm verify` failed on a test that named the template.** `tests/embed-page-failure.test.tsx` asserts the embed's way out, and wrote the copy out as `Open in ZZ Meridian` — the template's name, while the frame draws `Open in ${app.name}`. Every dashboard is created under its own name, so the test passed in this repository and failed in every project made from it, at the first `pnpm verify` a team runs. It reads the name from `src/app.config.ts` now.
+
 ## [0.16.1] · 2026-10-16
 
 ### Breaking

package/payload/CONTRIBUTING.md

@@ -93,7 +93,7 @@ Write the status on the line under the title: `Status: beta`.
 | `pnpm typecheck`, `pnpm test` | TypeScript and the behaviour tests | Gate |
 | `node scripts/audit.ts` | With the app running: every page and embed view at 2560, 1440, 1024, 768 and 390px in both themes (embeds at 720 and 420 on a simulated host ground). It measures inside open shadow roots too. Fails on sideways scroll, text clipped without an ellipsis, text cut with an ellipsis that keeps the whole of it in no `title`, two pieces of text drawn in the same place or a stroked line drawn through one, a control with no accessible name, more than one page scroller, rendered text under its WCAG minimum (an SVG's text too, read by its `fill` against what the SVG paints behind it), a Tab stop with no focus ring (a change of outline, shadow or border when focus arrives), a custom element it cannot look inside (`unmeasured:`), and any uncaught exception or console error. Prints the design metrics: type sizes, weights, radii and the hierarchy ratio | Before release |
 | `node scripts/audit.ts --atlas` | With the app running: the same audit over the Design Atlas, at 1440 and 390px in both themes: every card's page and its bare preview, and every other entry the Atlas serves (the token views, the page specs, the guides). Its first line says what it reached, by kind, and `--list` prints the routes without opening a browser. Not part of `pnpm verify`, which stays fast: a card's preview is where a defect in its own box shows, so run it after changing a component | After changing a component |
-| `node scripts/vitals.ts [--atlas]` | With a production build running: LCP, INP and CLS on a mid-range phone for every static page, the Atlas's front page and one card page among them. `--atlas` measures every Atlas entry instead, about fifteen minutes, and is not part of `pnpm verify` | Inside `pnpm verify --full`; `--atlas` after changing what every card page shares |
+| `node scripts/vitals.ts [--atlas]` | With a production build running: LCP, INP, CLS and dropped frames on a mid-range phone for every static page, the Atlas's front page and one card page among them. `--atlas` measures every Atlas entry instead, about fifteen minutes, and is not part of `pnpm verify` | Inside `pnpm verify --full`; `--atlas` after changing what every card page shares |
 | `node scripts/interactions.ts` | With the app running: presses every control on every page (mouse at 1440px, taps at 390px) and follows every link. Reaches controls inside open shadow roots. Fails on a control that changes nothing, one something covers, and a link that answers 4xx | Before release |
 | `node scripts/keyboard.ts` | With the app running: Tab through each page until focus comes back round, then Shift+Tab back. Fails on a stop with no focus ring, a control hidden under the sticky bar, a visible control never reached, and a reverse order that differs | Before release |
 | `pnpm verify` | The gate once, one production build, the route policy, the size checks and a smoke of up to three routes on desktop and the phone drawer; ends with a coverage line, and the report is in `out/verify.txt` | Before finishing any change |

package/payload/app/(dashboard)/(home)/README.md

@@ -35,14 +35,14 @@ The page is headed by what its revenue says for the period chosen, worked out by
 | The period is a record: its revenue is higher than that of every earlier whole period of its length, and at least six such periods are kept (`facts.recordNeedsPeriods` in `src/app.config.ts`) | "The highest 30 days yet: $3,300,438.74", then ", the 3rd record in a row" when the periods before it were each a record too. A record's title has no clause about the services |
 | Otherwise, with a period before it | "Revenue is up 25.8% on the 90 days before" ("down"; "Revenue is level with the 90 days before" when the change rounds to 0.0%), then the services' clause |
 | No period comes before it (All) | "$27,710,624.39 of revenue in 360 days", then the services' clause |
-| The services' clause | ", and every service is operational"; ", and Inference API is degraded" (or "is down") for the one service in the worst state any is in; ", and 2 services are degraded" for several. Left out when the services could not be read |
+| The services' clause | As the last clause, ", and every service is operational". As its own sentence after the figures when something is wrong, ". Inference API is degraded" (or "is down") for the one service in the worst state any is in, ". 2 services are degraded" for several, and ". No service is monitored yet" for a read that returned none: the one thing a person may have to act on is not the fourth item of a list. Left out when the services could not be read |
 | The history could not be read, or no day is kept | The page is headed by its name |
 
 In the sample the four periods read "The highest 7 days yet: $810,137.13", "The highest 30 days yet: $3,300,438.74, the 3rd record in a row", "Revenue is up 25.8% on the 90 days before, and Inference API is degraded" and "$27,710,624.39 of revenue in 360 days, and Inference API is degraded". 90 days and All state no record: 360 days hold four whole periods of 90 and one of 360, fewer than a record needs.
 
 ### The line under the title
 
-One line, worked out by `homeLine` in `src/views/home-context.ts`: the customers that have not left, the period's requests and their change, gross margin for a person who may read what compute cost, and the services, each one that is not operational named with its state, those down first. Counts are written at a glance (`formatCompact`). In the sample at 30 days an Owner reads "320 customers, 1.1B requests in 30 days (up 4.7%), a gross margin of 62.4%, and Inference API is degraded." and a Member or a Viewer the same line without the margin clause. A clause whose figures could not be read is left out. What is wrong today is said here whatever the title says: a record's title has no clause about the services.
+One line, worked out by `homeLine` in `src/views/home-context.ts`: the customers that have not left, the period's requests and their change, and gross margin for a person who may read what compute cost, with the services last. Counts are written at a glance (`formatCompact`). A service that is not operational, or a product monitoring none, is the line's own second sentence, after the figures: on a day whose title states a record it is the only place on the page that says what is wrong today. In the sample at 30 days an Owner reads "320 customers, 1.1B requests in 30 days (up 4.7%), and a gross margin of 62.4%. Inference API is degraded." and a Member or a Viewer the same line without the margin clause. A clause whose figures could not be read is left out.
 
 The revenue card and the tiles share the page's Meridian: its dates are the period's complete days, then the day in progress. Point at a day in the revenue chart and the featured figure reads it; at the day in progress its pill says "so far". A tile reads the pointed day only when its points are the Meridian's dates (the Metric tile's rule). While a day is in progress, the Requests, Compute cost and Gross margin tiles have a point for each complete day and none for the day in progress, one short of the Meridian's dates, so they keep the period's figure and a part-day is never read as a whole one. When the latest day kept is complete, no day is in progress, their points are the Meridian's dates, and pointing at a day reads it in those three tiles too.
 

package/payload/app/(dashboard)/engineering/README.md

@@ -11,7 +11,7 @@ Thirteen parts, in this order. Every chart and list is the card named, the page
 | Part | Split | Pattern | Holds |
 |---|---|---|---|
 | 1. Head | | Page frame | Kicker `ZZ Meridian · Production`; the title, a sentence about the services and the releases (below), with the page's name kept in the heading; the line under it (below), then who Engineering is for (`workspaces.engineering.audience`, read from the declaration); Freshness. No action |
-| 2. Days inside the band | full | Featured metric with a Trend chart, line, with `height="fill"` | The page's protagonist, marked `data-protagonist="Days inside the band"` on a wrapper whose display is `contents`: the days inside the band over every complete day kept, 357, its kicker naming of how many ("Days inside the band · of 360 complete days kept"); the steady fact as its finding, the line the context carries ("357 of 360 days inside the band of p95 under 350 ms and errors under 1%; outside it on 17 Aug 2026, 21 Sept 2026 and 22 Sept 2026"); and the p95 of each of the last 360 complete days as its chart. Its Ask asks what stands out in the days inside the band. With the days not read, its place says so; with none kept, it is not drawn |
+| 2. Days inside the band | full | Featured metric with a Trend chart, line, with `height="fill"` | The page's protagonist, marked `data-protagonist="Days inside the band"` on a wrapper whose display is `contents`: the days inside the band over every complete day kept, 357, its kicker naming of how many ("Days inside the band · of 360 complete days kept"); the steady fact as its finding, the line the context carries ("357 of 360 days inside the band of p95 under 350 ms and errors under 1%; outside it on 17 Aug 2026, 21 Sept 2026 and 22 Sept 2026"); and the p95 of each of the last 360 complete days as its chart, with the band drawn as the region under its ceiling (`band`: `{ value: 350, label: 'Band: p95 under 350 ms' }` in `src/app.config.ts`) and a mark on each day outside it (`marks`, from the strip's own states, so the day that left the band on its error rate is marked where its p95 stands inside the region). Its Ask asks what stands out in the days inside the band. With the days not read, its place says so; with none kept, it is not drawn |
 | 3. Services, now | 2/3 | Card with a Status list, `run` | Every service in the team's order with its state, its last 90 days and how long it has run ("Operational for 69 days · its longest in 90"). Past eight services, the ones not operational, then the three with the longest current runs (below). Always a link to Services that names how many there are: "All 6 services" |
 | 4. Open incident | 1/3 | Incident card, under the part's own heading | The incident nobody has resolved, each update timed from its start ("at the start", "after 1.1h"), its owner and its ticket, which opens the Tickets page on it. With several, "Open incidents": one card each, the most severe first and then the newest. With none, one card says so with when the last one was resolved and how long it lasted ("the last was resolved on 17 Aug 2026 and lasted 2.4h") |
 | 5. N of M days inside the band | full | Card with Uptime bars, `lg`, and a list | Titled by its figure, "357 of 360 days inside the band". The last 360 complete days, ending on the latest complete day, a mark for each day outside the band (`facts.band` in `src/app.config.ts`); the share of the days shown inside it, read "99.17% inside the band"; then four facts: the days outside by date, the year of requests beside the range of the median day's p95, p95 on the busiest day yet, and the requests answered without an error |

package/payload/app/(dashboard)/members/actions.ts

@@ -4,6 +4,7 @@ import { clock } from '@/data/collections';
 import { can, collectionFor, resolveAccess, Unauthenticated } from '@/data/access';
 import { assignMemberRole, REFUSALS } from '@/data/member-mutations';
 import type { AnyCollection } from '@/lib/collection';
+import { dayOf } from '@/lib/format-date';
 import type { Result } from '@/views/members';
 import { STATUSES, TEAMS, type Member } from '@/data/sample';
 import { MAIN_ROLES, type AddOn, type MainRole } from '@/data/roles';
@@ -38,7 +39,7 @@ export async function inviteMember(input: { name: string; email: string; role: M
   if (!MAIN_ROLES.includes(input.role) || !TEAMS.includes(input.team)) return { ok: false, error: 'Choose a role and a team from the lists.' };
   // The boundary decides the role the caller may give — an Admin inviting an Owner is refused there with the frozen
   // rule's message — so this path only shapes the invitation.
-  return run('create', undefined, (c) => c.create!({ name, email, role: input.role, team: input.team, status: 'Invited', joined: clock().toISOString().slice(0, 10), lastActive: null }));
+  return run('create', undefined, (c) => c.create!({ name, email, role: input.role, team: input.team, status: 'Invited', joined: dayOf(clock()), lastActive: null }));
 }
 
 export async function setMemberStatus(id: string, status: Member['status']): Promise<Result> {

package/payload/app/api/assistant/route.ts

@@ -12,7 +12,8 @@ import { handedTo } from '@/lib/assistant/scoped';
 import type { AgentChange, HandedExplore } from '@/lib/assistant/tools';
 import type { AnyCollection, Grant, Need } from '@/lib/collection';
 import type { PreparedQuery } from '@/lib/explore';
-import type { ViewTool } from '@/lib/shared-context';
+import { dayOf } from '@/lib/format-date';
+import { viewAt, type ViewTool } from '@/lib/shared-context';
 import { viewTools } from '@/views/tools';
 
 /** The panel sends at most the last 100 messages; a larger body than 2 MB is refused before it is parsed. */
@@ -62,14 +63,15 @@ export async function POST(request: Request): Promise<Response> {
   // they may use it. It reads through `aggregate()` and `read()`, which ask the person's grant again when a call runs;
   // its schema offers only what they may read: the collections handed above, without each one's hidden fields.
   const path = pathOf(String(page?.path ?? ''));
-  const view = views.find((v) => onPage(v.page, path));
+  const at = viewAt(viewTools, path);
+  const view = at && views.includes(at) ? at : undefined;
   const names = new Set(readable.map((c) => c.name));
   const reads = new Set(view ? Object.values(view.explore.sources).map((s) => s.collection) : []);
   const explore: HandedExplore | undefined = view && [...reads].some((name) => names.has(name))
     ? {
       view,
       rights: { readable: names, hidden: (name) => (readable.find((c) => c.name === name)?.hidden ?? []) as string[] },
-      io: { aggregate, read, today: clock().toISOString().slice(0, 10) },
+      io: { aggregate, read, today: dayOf(clock()) },
       page: path,
     }
     : undefined;
@@ -145,12 +147,6 @@ function pathOf(address: string): string {
   return (path.length > 1 ? path.replace(/\/+$/, '') : path) || '/';
 }
 
-/** Whether `path` is the page `route` renders: each segment equal, a `[name]` segment matching any one segment. */
-function onPage(route: string, path: string): boolean {
-  const want = route.split('/'), got = path.split('/');
-  return want.length === got.length && want.every((w, i) => (/^\[[^\]/]+\]$/.test(w) ? got[i] !== '' : w === got[i]));
-}
-
 /** The grants a need names: the one, every one of an `allOf`, and none for `public`. */
 const grantsOf = (need: Need): readonly Grant[] => (need === 'public' ? [] : typeof need === 'string' ? [need] : need.allOf);
 

package/payload/app/embed/error.tsx

@@ -0,0 +1,30 @@
+'use client';
+
+import { app } from '@/app.config';
+
+/**
+ * The last net in an embed: something threw that the page's own read did not catch (a view that fails to render). It
+ * imports nothing else, and that is the design, not an oversight.
+ *
+ * Measured: an error boundary here that drew the view's frame and an empty state cost 28 KiB on every embed route's
+ * first load — `/embed/now` went 14 KiB past the 820 KiB budget and all three embeds grew 5.8–7.7% — while the same
+ * boundary importing nothing costs none of it, because a segment's error boundary lands in the route's entry chunk and
+ * everything it imports lands with it. So the framed failure is the page's own (it catches a read that threw and draws
+ * the frame and a card), and this is the document underneath it: the product's name, one sentence, and Try again.
+ * `app.config` is the one import, and it is already in the entry chunk of every route that draws the product's mark.
+ */
+export default function EmbedError({ reset }: { error: Error & { digest?: string }; reset: () => void }) {
+  return (
+    <main className="mx-auto flex min-h-dvh max-w-prose flex-col items-start justify-center gap-3 p-8">
+      <p className="t-kicker">{app.name}</p>
+      <p className="text-sm text-ink">This view did not load, and nothing was changed.</p>
+      <button
+        type="button"
+        onClick={reset}
+        className="press hit rounded-md border border-line-strong px-3 py-1.5 text-sm font-medium text-ink hover:bg-fill-hover"
+      >
+        Try again
+      </button>
+    </main>
+  );
+}

package/payload/app/embed/home/page.tsx

@@ -1,6 +1,7 @@
 import { Suspense } from 'react';
 import { homeTool } from '@/views/tools';
 import { parsePeriod } from '@/lib/period';
+import { EmbedBusy, EmbedFailed } from '@/components/patterns/embed-frame';
 import { EmbedHome } from './view';
 
 export const metadata = { title: 'Home' };
@@ -11,17 +12,30 @@ type SearchParams = Promise<{ period?: string; day?: string }>;
  * Tool: `zz_meridian_home { period, day? }` (`homeTool` in `src/views/tools.ts`). The route renders from the
  * tool's own read, so what the model is told and what the view shows are one. Inline: the revenue card and its three tiles.
  * Fullscreen: the console's Home rows.
+ *
+ * The period stays in the address and is read by the view below, inside its boundary: a page that awaited it here would
+ * wait for the request, and this route no longer prerenders. The fallback therefore names the view and not its period,
+ * as Requests' names the view and not its filters, and both gain theirs with the read.
  */
 export default function Page({ searchParams }: { searchParams: SearchParams }) {
   return (
-    <Suspense>
+    <Suspense fallback={<Busy />}>
       <Home searchParams={searchParams} />
     </Suspense>
   );
 }
 
+/** The frame the host sees while the read runs: this view's title, and a body of the shape the read will fill. */
+function Busy() {
+  return (
+    <EmbedBusy title="Home" consolePath="/" name="Home" blocks={['chart', 'tiles']} />
+  );
+}
+
 async function Home({ searchParams }: { searchParams: SearchParams }) {
   const { period, day } = await searchParams;
-  const { data } = await homeTool.read({ period: parsePeriod(period), day: /^\d{4}-\d{2}-\d{2}$/.test(day ?? '') ? day : undefined });
-  return <EmbedHome {...data} />;
+  // A read that threw is this view's own failure, drawn in the frame. The segment's error boundary is the last net
+  // under it, and imports nothing, because anything a boundary imports lands in every embed's first load.
+  const read = await homeTool.read({ period: parsePeriod(period), day: /^\d{4}-\d{2}-\d{2}$/.test(day ?? '') ? day : undefined }).catch(() => null);
+  return read ? <EmbedHome {...read.data} /> : <EmbedFailed title="Home" consolePath="/" name="Home" />;
 }

package/payload/app/embed/home/view.tsx

@@ -9,7 +9,11 @@ import { HomeBody, RevenueCard, ShareHome, companyTiles, isEmpty, meridianDates
 import type { HomeData } from '@/views/home-context';
 import { PERIOD_LABEL } from '@/lib/period';
 
-/** Inline: the revenue card and the three tiles beside it. Fullscreen: the console's Home, its nine parts. Both share the same context. */
+/**
+ * Inline: the revenue card and the three tiles beside it. Fullscreen: the console's Home, its nine parts. Both share the
+ * same context. Both state the period's record on the revenue card: the frame above them names the view and its period,
+ * where the console's page names the record itself, so this is the one surface left that can say it.
+ */
 export function EmbedHome(p: HomeData) {
   const s = useSurface();
   return (
@@ -18,7 +22,7 @@ export function EmbedHome(p: HomeData) {
       meta={<Freshness updatedAt={new Date(p.updatedAt)} now={new Date(p.now)} />}
       consolePath={`/?period=${p.period}`}
     >
-      {s.mode === 'fullscreen' || isEmpty(p) ? <HomeBody {...p} /> : <Inline {...p} />}
+      {s.mode === 'fullscreen' || isEmpty(p) ? <HomeBody {...p} finding={p.record} /> : <Inline {...p} />}
     </EmbedFrame>
   );
 }
@@ -30,7 +34,7 @@ function Inline(p: HomeData) {
     <Meridian dates={dates} day={p.day}>
       <ShareHome data={p} />
       <Stack className="gap-3">
-        <RevenueCard data={p} dates={dates} />
+        <RevenueCard data={p} dates={dates} finding={p.record} />
         <Row split="tiles" className="gap-3">
           {companyTiles(p)}
         </Row>

package/payload/app/embed/now/page.tsx

@@ -1,6 +1,7 @@
 import { Suspense } from 'react';
 import { packNow } from '@/views/now-context';
 import { nowTool } from '@/views/tools';
+import { EmbedBusy, EmbedFailed } from '@/components/patterns/embed-frame';
 import { EmbedNow } from './view';
 
 export const metadata = { title: 'Now' };
@@ -8,16 +9,28 @@ export const metadata = { title: 'Now' };
 /**
  * Tool: `zz_meridian_now {}` (`nowTool` in `src/views/tools.ts`), rendered from the tool's own read, at request time
  * for whoever is asking. Inline: the status list and the open incident. Fullscreen: the Now page's body.
+ *
+ * `Now` takes no argument, so its frame is the same whatever the host asks for: the host is framed at once rather than
+ * shown an empty rectangle while the read runs.
  */
 export default function Page() {
   return (
-    <Suspense>
+    <Suspense fallback={<Busy />}>
       <Now />
     </Suspense>
   );
 }
 
+/** The frame the host sees while the read runs: this view's title, and a body of the shape the read will fill. */
+function Busy() {
+  return (
+    <EmbedBusy title="Now" consolePath="/engineering" name="Now" blocks={['tiles', 'table']} />
+  );
+}
+
 async function Now() {
-  const { data } = await nowTool.read({});
-  return <EmbedNow {...packNow(data)} />;
+  // A read that threw is this view's own failure, drawn in the frame. The segment's error boundary is the last net
+  // under it, and imports nothing, because anything a boundary imports lands in every embed's first load.
+  const read = await nowTool.read({}).catch(() => null);
+  return read ? <EmbedNow {...packNow(read.data)} /> : <EmbedFailed title="Now" consolePath="/engineering" name="Now" />;
 }

package/payload/app/embed/requests/page.tsx

@@ -1,5 +1,6 @@
 import { Suspense } from 'react';
 import { requestsTool } from '@/views/tools';
+import { EmbedBusy, EmbedFailed } from '@/components/patterns/embed-frame';
 import { EmbedRequests } from './view';
 
 export const metadata = { title: 'Requests' };
@@ -11,19 +12,31 @@ type SearchParams = Promise<Record<string, string | string[] | undefined>>;
  * tool's view and the console's view are the same address. Inline: the five latest that match. Fullscreen: the table.
  * Both read what the console page reads: one page of the filtered set and the summary of all of it, so the shared
  * context is the console's.
+ *
+ * The frame is drawn at once with the view's own name; the scope its title gains ("Requests · Failing") is the read's
+ * to say, and the console link carries the filters once it has: the unfiltered list is where the reader lands meanwhile.
  */
 export default function Page({ searchParams }: { searchParams: SearchParams }) {
   return (
-    <Suspense>
+    <Suspense fallback={<Busy />}>
       <Requests searchParams={searchParams} />
     </Suspense>
   );
 }
 
+/** The frame the host sees while the read runs: this view's title, and a body of the shape the read will fill. */
+function Busy() {
+  return (
+    <EmbedBusy title="Requests" consolePath="/requests" name="Requests" blocks={['table']} />
+  );
+}
+
 async function Requests({ searchParams }: { searchParams: SearchParams }) {
   const p = await searchParams;
   const one = (v: string | string[] | undefined) => (Array.isArray(v) ? v[0] : v);
   // The tool's own read: the address's filters are its arguments, and the sort and page the table may set ride along.
-  const { data } = await requestsTool.read({ status: one(p.status) as 'all' | undefined, method: one(p.method), region: one(p.region), q: one(p.q), ...(p.sort || p.dir || p.page ? { sort: one(p.sort), dir: one(p.dir), page: one(p.page) } : {}) } as Parameters<typeof requestsTool.read>[0]);
-  return <EmbedRequests {...data} />;
+  // A read that threw is this view's own failure, drawn in the frame. The segment's error boundary is the last net
+  // under it, and imports nothing, because anything a boundary imports lands in every embed's first load.
+  const read = await requestsTool.read({ status: one(p.status) as 'all' | undefined, method: one(p.method), region: one(p.region), q: one(p.q), ...(p.sort || p.dir || p.page ? { sort: one(p.sort), dir: one(p.dir), page: one(p.page) } : {}) } as Parameters<typeof requestsTool.read>[0]).catch(() => null);
+  return read ? <EmbedRequests {...read.data} /> : <EmbedFailed title="Requests" consolePath="/requests" name="Requests" />;
 }

package/payload/app/system/(atlas)/page.tsx

@@ -13,9 +13,17 @@ export default function AtlasHome() {
   const readme = readRepo('README.md');
   const principles = [...(readme.split('## Principles')[1]?.split('\n## ')[0] ?? '').matchAll(/\*\*(.+?)\*\*\s*(.+)/g)].map((m) => ({ title: m[1].replace(/\.$/, ''), text: m[2] }));
   const all = entries();
-  const latest = readRepo('CHANGELOG.md').split(/\n(?=## \[)/)[1] ?? '';
-  const head = latest.match(/^## \[([^\]]+)\] · (\S+)\n+([^\n#][^\n]*)/);
-  const release = { version: head?.[1] ?? s.version, date: head?.[2] ?? '', summary: head?.[3] ?? '', headlines: [...latest.matchAll(/^- \*\*(.+?)\*\*/gm)].map((m) => m[1].replace(/[.:]$/, '').replace(/`/g, '')) };
+  // The front page states the latest *release*, not the work toward the next one. `[Unreleased]` is a section like any
+  // other and it sits first, and reading it here named pending work with the version it is going to be released
+  // under, without a date and without its summary — the entry is written for the day it becomes `## [x.y.z] · date`.
+  const latest = readRepo('CHANGELOG.md').split(/\n(?=## \[)/).slice(1).find((s) => /^## \[\d+\.\d+\.\d+\] · \S+/.test(s)) ?? '';
+  // The version and its date are on the heading, and the summary is the paragraph under it — a line every one of these
+  // releases does without, since they all open on a `###` heading, but the card has the place for one. Read together as
+  // they were, `[^\n#]` refused the `#` of `### Breaking`, so the newest release lost its date to the fallback and the
+  // card printed a separator with nothing after it.
+  const heading = latest.match(/^## \[([^\]]+)\] · (\S+)/);
+  const summary = latest.split(/\n\n/).slice(1).map((p) => p.trim()).find((p) => p && !p.startsWith('#') && !p.startsWith('-') && !p.startsWith('|')) ?? '';
+  const release = { version: heading?.[1] ?? s.version, date: heading?.[2] ?? '', summary, headlines: [...latest.matchAll(/^- \*\*(.+?)\*\*/gm)].map((m) => m[1].replace(/[.:]$/, '').replace(/`/g, '')) };
   const changelog = all.find((e) => e.id === 'changelog')?.href;
   const series = demoSeries('30d').current;
   const counts = [
@@ -126,10 +134,13 @@ export default function AtlasHome() {
         <SectionHead title="What changed." line="Every release, with what breaks and what to do instead." />
         <div className="grid gap-8 rounded-xl border border-line bg-surface p-7 lg:grid-cols-[minmax(0,2fr)_minmax(0,3fr)]">
           <div>
-            <p className="t-kicker">{release.version} · {release.date}</p>
-            <p className="t-small mt-4 max-w-[48ch] text-ink-2">{release.summary}</p>
+            {/* A release is named and dated, always; the paragraph under it is a release's own to have. */}
+            <p className="t-kicker">{release.date ? `${release.version} · ${release.date}` : release.version}</p>
+            {release.summary ? <p className="t-small mt-4 max-w-[48ch] text-ink-2">{release.summary}</p> : null}
+            {/* The link takes its own line: the kicker above it is `inline-flex`, so an inline link shares its line and
+                reads as one word, which is what it did once the empty summary paragraph between them went. */}
             {changelog ? (
-              <Link href={changelog} className="mt-6 inline-flex items-center gap-1.5 text-sm font-medium text-accent-ink hover:text-ink">
+              <Link href={changelog} className="mt-6 flex w-fit items-center gap-1.5 text-sm font-medium text-accent-ink hover:text-ink">
                 Full changelog <ArrowRight className="size-3.5" />
               </Link>
             ) : null}

package/payload/app/system/preview/[section]/[card]/stage.tsx

@@ -1,7 +1,9 @@
 'use client';
 
+import Link from 'next/link';
 import { useSearchParams } from 'next/navigation';
 import { lazy, Suspense } from 'react';
+import { ArrowLeft } from 'lucide-react';
 import { PREVIEW_LOADERS } from '@/system/preview-loaders';
 
 /** One lazy component per card, made once: the route's first load carries none of them, and the page loads only its own. */
@@ -10,6 +12,10 @@ const PREVIEWS = Object.fromEntries(Object.entries(PREVIEW_LOADERS).map(([id, lo
 function Inner({ id }: { id: string }) {
   const q = useSearchParams();
   const P = PREVIEWS[id];
+  // The card's own name, from its folder: the stage knows the id and not the title, and importing the Atlas's content
+  // reading to draw one word would weigh more than the word.
+  const slug = id.split('/').at(-1)!.replace(/-/g, ' ');
+  const label = slug[0].toUpperCase() + slug.slice(1);
   return (
     <div
       data-theme={q.get('theme') ?? undefined}
@@ -17,6 +23,13 @@ function Inner({ id }: { id: string }) {
       data-density={q.get('density') ?? undefined}
       className="min-h-dvh bg-ground p-8 text-ink max-sm:p-4"
     >
+      {/* The card page opens this in a new tab, which has no history to go back through: without a link here the only
+          way off a preview is to close the tab. One quiet line above the specimen, naming the card it belongs to. */}
+      <nav className="mx-auto mb-6 flex max-w-5xl items-center">
+        <Link href={`/system/${id}`} className="press hit inline-flex h-7 items-center gap-1.5 rounded-md px-2 text-xs font-medium text-ink-2 hover:bg-fill-hover hover:text-ink">
+          <ArrowLeft className="size-3.5" /> {label}
+        </Link>
+      </nav>
       <div data-specimen className="mx-auto max-w-5xl"><Suspense><P /></Suspense></div>
     </div>
   );

package/payload/docs/agents.md

@@ -83,7 +83,7 @@ The answer is text of at most 3,000 characters, in a fixed order: the window as
 
 ## The console's own assistant
 
-The second place is inside the product. The assistant panel reads the page the person is on (its address with the query, the view's shared context, then the visible text), reads further through every `view_<name>` and the page's own prepared query, and proposes changes as Proposals in its thread. It is handed that page's `explore_<view>` and no other page's: the route finds the view whose `page`, the console route of the page it renders, is the address the panel sends, and hands its prepared query only where the person may use that view. There is no tool that reads a collection directly. Its write tools are those of the collections that prepared query reads, among the product's collections (`src/data/collections.ts`), so the members' writes are handed on Members and the key writes on API keys; a change takes the ids the query's drilled rows give, and asked for a change another page makes, the assistant gives that page's address where the person may open it; a page they may not open is never offered as where they make a change. A rail page's `page` is its `href` in `nav`; a detail page's has its segment (`/customers/[id]`) and matches any one segment there. It follows the same rules: it reads what the person may read, changes nothing without approval, and leaves its mark (the Agent mark and the "Assistant" caption). It is off until a model is configured. `docs/assistant.md` says how to switch it on and point it at your data, and how the same tools can later be offered from an MCP server.
+The second place is inside the product. The assistant panel reads the page the person is on (its address with the query, the view's shared context, then the visible text), reads further through every `view_<name>` and the page's own prepared query, and proposes changes as Proposals in its thread. It is handed that page's `explore_<view>` and no other page's: the route finds the view whose `page`, the console route of the page it renders, is the address the panel sends, and hands its prepared query only where the person may use that view. There is no tool that reads a collection directly. Its write tools are those of the collections that prepared query reads, among the product's collections (`src/data/collections.ts`), so the members' writes are handed on Members and the key writes on API keys; a change takes the ids the query's drilled rows give, and asked for a change another page makes, the assistant gives that page's address where the person may open it; a page they may not open is never offered as where they make a change. A rail page's `page` is its `href` in `nav`; a detail page's has its segment (`/customers/[id]`) and matches any one segment there, and a catch-all matches as Next.js matches it: `/docs/[...path]` any depth under `/docs/`, `/docs/[[...path]]` `/docs` as well. Where two views match one address, the one Next.js renders is chosen (`viewAt` in `src/lib/shared-context.ts`). It follows the same rules: it reads what the person may read, changes nothing without approval, and leaves its mark (the Agent mark and the "Assistant" caption). It is off until a model is configured. `docs/assistant.md` says how to switch it on and point it at your data, and how the same tools can later be offered from an MCP server.
 
 The page text it reads is the scroll region's visible text, less every node marked `data-assistant="omit"`. A value shown once, such as a newly issued key's secret or a one-time sign-up link, is drawn so marked, or outside the scroll region (a `Dialog` portals to the document's body), so asking while it is on screen never sends it to the model; the sample's API keys page marks a new key's Copy field so. `scripts/ask.ts` leaves out the same nodes from the page it sends. The thread is the signed-in person's for the tenant they act for: it is stored with that scope, a change of either starts an empty thread and removes the earlier one, and each request names the scope, so a session that changed hands since (a sign-in from another tab) is refused with 409 and the panel clears the thread instead of continuing it, then refreshes the route, so the next question is asked as whoever is signed in now. A tab writes and removes only a thread of its own scope.
 

package/payload/docs/distribution.md

@@ -147,10 +147,10 @@ Two environment variables exist for the updater's own tests and are used only wh
 reports as `migration:<id>` because it cannot make them. An entry applies when the project's recorded version is older
 than its `since` and the target is not, and its `applies(root)` returns the paths that still have the old shape, or
 null. It only reads, and only team-owned files (the ownership rule's managed paths are skipped); a file it cannot read is
-absent. A project already on the new shape gets no line. Every entry carries `gate` and `build` as its checks (`verify-modes`, `agent-reads-section`, `nav-needs` and `agent-reads-own-group`, `gate` alone), and its
+absent. A project already on the new shape gets no line. Every entry carries `gate` and `build` as its checks (`verify-modes`, `agent-reads-section`, `nav-needs`, `agent-reads-own-group` and `marker-measured-on-observe`, `gate` alone), and its
 instructions name the section of a reference (`cache.md`, `live.md`, `validation.md`, `agents.md`, `customize.md`), of the Start guide or of `docs/assistant.md` to follow.
 
-Six arrived after 0.5.0 and are resolved as the skill's `references/update.md` says: `share-view-context` and `agent-reads-section` (0.9.0), `assistant-view-tools` (0.10.0), `nav-needs` (0.13.0), `agent-reads-own-group` (0.15.0) and `refusal-declared` (0.16.0). The ten of 0.5.0 are:
+Eleven arrived after 0.5.0 and are resolved as the skill's `references/update.md` says: `share-view-context` and `agent-reads-section` (0.9.0), `assistant-view-tools` (0.10.0), `nav-needs` (0.13.0), `agent-reads-own-group` (0.15.0), `refusal-declared`, `managed-exports-removed`, `view-tool-page-explore`, `agent-does-here-section` and `sample-pages-renamed` (0.16.0), and `marker-measured-on-observe` (0.16.2). The ten of 0.5.0 are:
 
 | Id | Reported when a team-owned file still has | Completion step |
 |----|-------------------------------------------|-----------------|

package/payload/docs/product-workspaces.md

@@ -4,7 +4,7 @@ ZZ Meridian's own dashboard is one product with fifteen destinations, grouped in
 
 ## The three workspaces
 
-A workspace is where a person looks. It decides which destinations the rail and the command palette (⌘K) list, and nothing else: what a person may open and change is decided by their role, page by page. Choose a workspace in the menu at the top of the rail, under Show; the menu opens that workspace's home.
+A workspace is where a person looks. It decides which destinations the rail and the command palette (⌘K) list, and nothing else: what a person may open and change is decided by their role, page by page. Choose a workspace in the menu at the top of the rail, under Show. That menu is the one place a workspace and a grant meet, and only in which rows it offers: a workspace is listed when the person may open at least one of its destinations, and a row opens the workspace's home, or the first destination of it the person may open when the home is not one of them. Neither changes what any page allows.
 
 - **[Main](/)**: For everyone who needs the whole product at a glance: how it is doing, who is in it and how it is set up. Its home is Home, the company's page for the period you choose: revenue and its record, customers, tokens served and requests, the days inside the band and compute in use (with compute cost and gross margin for an Owner and an Admin), then the year counted a period at a time, what is sold, Business and Engineering at a glance with a way into each, and what is worth knowing across the company, each line opening the page where it is handled. Main also holds Members, Settings, and the Atlas (Design system and Docs).
 - **[Business](/business)**: For the people who answer for customers and usage: traffic, who relies on the product and what they ask of it. Its home is Revenue, which leads with what customers paid in the period you choose, in its Featured metric with its record and revenue a day, then shows it against a year ago, the best day yet, who is past due, who pays by plan, every customer's week, the customers from a trial up to Enterprise, what is worth a look, what they buy and where they are, each customer it names opening its page. It holds Customers, where a row opens that customer's own page; Usage, which leads with the requests of the period you choose in its Featured metric, against the period before with requests a day, then a year of requests a day a cell, the facts of the period, and over the last 30 days when requests come, where from, what is asked for and how it was answered; and Requests, where a single request opens inside it.
@@ -97,7 +97,7 @@ The word means three different things in this product. They share a name and not
 
 A product declares its workspaces once, in `src/app.config.ts`:
 
-1. Export `workspaces`: an object with one key for each workspace, holding `label` (its name), `audience` (one sentence saying who it is for, in the voice of the rest of the product) and `homeHref` (the entry its menu row opens).
+1. Export `workspaces`: an object with one key for each workspace, holding `label` (its name), `audience` (one sentence saying who it is for, in the voice of the rest of the product) and `homeHref` (the entry its menu row opens; the first destination of the workspace the person may open is what the row opens instead, when the home is not one of them).
 2. Give every entry of `nav` a `workspace` naming one of those keys, and a `needs` that names a feature's need in `src/data/features.ts`.
 3. Keep `src/views/workspaces.ts`, which derives each workspace's navigation (`navOf`) and answers which workspace an address belongs to (`workspaceOf`), and `src/views/workspace-chrome.tsx`, the product's adapter over the console chrome. The layout uses `WorkspaceRail` and `WorkspacePalette` in place of the plain rail and palette.
 

package/payload/next.config.ts

@@ -8,6 +8,9 @@ const config: NextConfig = {
   cacheComponents: true,
   partialPrefetching: true,
   devIndicators: false,
+  // `pnpm verify` sets MERIDIAN_TYPES_CHECKED for its one build, only after its own gate has type-checked this tree with
+  // the same tsconfig, so the build does not check it twice. Every other `next build` checks the types itself.
+  typescript: { ignoreBuildErrors: process.env.MERIDIAN_TYPES_CHECKED === '1' },
   // Card specifications (README.md next to each component) are read at build time by the Design Atlas.
   outputFileTracingIncludes: { '/system/**': ['./src/**/*.md', './app/**/*.md', './docs/**/*.md', './decisions/**/*.md', './*.md', './tokens/**/*.json'], '/icon': ['./tokens/**/*.json'], '/api/assistant': ['./docs/brief.md'] },
 };

package/payload/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zz-meridian-template",
-  "version": "0.16.1",
+  "version": "0.16.3",
   "private": true,
   "license": "MIT",
   "description": "ZZ Meridian: a dashboard design system and starter. Six layers, from DTCG tokens through four layers of React components to product workspaces, and a Design Atlas, in a light and a dark theme.",

package/payload/scripts/ask.ts

@@ -317,11 +317,16 @@ function report(view: View, address: string, persona: string, base: string, page
   return `${out.join('\n')}\n`;
 }
 
-/** The address a page's questions are asked on: the page itself, or for a detail page the first record its listing page links. */
+/**
+ * The address a page's questions are asked on: the page itself, or for a detail page the first record its listing page
+ * links. An optional catch-all (`/docs/[[...path]]`) renders with none of its segments too, so it is asked there; a
+ * catch-all takes a link of any depth.
+ */
 async function addressOf(base: string, cookie: string, page: string): Promise<string | null> {
   if (!/\[[^\]/]+\]/.test(page)) return page;
+  if (/\/\[\[\.\.\.[^\]/]+\]\]$/.test(page)) return addressOf(base, cookie, page.replace(/\/\[\[\.\.\.[^\]/]+\]\]$/, '') || '/');
   const listing = page.split('/[')[0] || '/';
-  const form = page.split('/').map((s) => (/^\[[^\]/]+\]$/.test(s) ? `[^/"'?#\\s<>]+` : s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))).join('/');
+  const form = page.split('/').map((s) => (/^\[\.\.\.[^\]/]+\]$/.test(s) ? `[^"'?#\\s<>]+` : /^\[[^\]/]+\]$/.test(s) ? `[^/"'?#\\s<>]+` : s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))).join('/');
   const html = await (await fetch(`${base}${listing}`, { headers: { cookie }, signal: AbortSignal.timeout(60_000) })).text();
   return new RegExp(`href="(${form})(?:[?#][^"]*)?"`).exec(html)?.[1] ?? null;
 }