/* Proposals — elements the system does not have yet.
   ==================================================================
   A staging tier, not a second design system. Everything here is UNRATIFIED: built
   because a screen needed it, kept out of elements.css until it is signed off.

   Why the tier exists: building the rest of the product means meeting patterns the
   system has not specced — cards, chips, dropdowns, the filter panel. Stopping to ask
   on each one halts every page; adding them straight to elements.css quietly turns
   guesses into system decisions. So they land here instead, where they work but are
   visibly provisional.

   Rules — the same as elements.css, minus one:
   - Tokens only. No hex, no rem, no colour literal. Every value is a var() read
     from tokens.css. Plain px is used ONLY for the one-off outer dimension of a
     floating panel or a thumbnail (min-width, image size) — there is no token for
     "how wide is this popover", the same way index.html's own layout cap is a
     literal. Every gap, padding, margin, radius, colour and font size is still a
     var(), no exceptions.
   - A proposal may NOT add a token. If a pattern needs a value the system has no
     token for, it stops and asks — that is still a system decision, and it is the
     one thing this tier does not buy you.
   - Every class here has a row in docs/proposals.md: what it is, which screen forced
     it, which Figma node it came from, and its status.
   - Prefer deriving from a design over inventing. A proposal traceable to a Figma
     node is a question about intent; an invented one is a question about taste, and
     the second is much harder to sign off.

   On ratification a class moves to elements.css and its row here is deleted. On
   rejection both go. This file being empty is the goal state, not a bug.

   Load order — after elements.css, so a proposal can extend a real element:

     <link rel="stylesheet" href="../../ce-ui/css/tokens.css" />
     <link rel="stylesheet" href="../../ce-ui/css/elements.css" />
     <link rel="stylesheet" href="../../ce-ui/css/proposals.css" />

   ================================================================== */

/* ------------------------------------------------------------------
   Filter drawer — the slide-out CLAUDE.md's "Not yet decided" list named
   ("filter slide-out panel"), now built against the real spec (Figma node
   1705:7147, "CE-Refresh — Design explorations") on the user's direct
   instruction. Replaces the earlier `.filter-panel` popover (docs/proposals.md
   keeps that history). Only the shell is built — title, close, footer action —
   the Channel/Status/date content shown in that frame is intentionally left
   out until it's wired up for real.

   Fixed to the viewport rather than built on .menu: a slide-out has its own
   overlay and needs to sit above the whole page (including the sidebar), which
   a `.menu-wrap`-relative floating panel can't do.
   ------------------------------------------------------------------ */
.filter-drawer-overlay {
  position: fixed;
  inset: 0;
  background: var(--color-overlay);
  opacity: 0;
  transition: opacity 0.2s ease;
  z-index: 200;
}

.filter-drawer-overlay--visible {
  opacity: 1;
}

.filter-drawer {
  position: fixed;
  top: 0;
  right: 0;
  bottom: 0;
  /* One-off outer dimension, same as a floating panel's min-width above — no
     token for "how wide is a drawer". The history: the Figma frame's own 312px,
     widened 20% to 374 on request (2026-08-20) once the Channel list grew long
     enough that channel names were the thing setting the panel's comfort, then
     back down to 300 on request (2026-08-27) — narrower than the frame, so the
     2026-08-20 reasoning is now explicitly overruled rather than merely
     superseded: long channel names wrap or truncate inside their own chips at
     this width, and the panel's compactness beside the table wins over showing
     the longest name on one line.
     KNOCK-ON: in push mode the page is given back 74px, so the table gets 74px
     more room at every width above the push breakpoint. (That breakpoint WAS
     retuned, later the same day and for the opposite reason — the panel's gutter
     made the push reserve 16px MORE, not less, than the 74 the narrowing gave
     back. See its own note below.) */
  width: 300px;
  display: flex;
  flex-direction: column;
  /* White (2026-08-27, on request). Third value this has carried in one day:
     --color-background (#f5f5f5) originally, then --color-page-tint to match the
     page it sits beside, now --color-surface — which reverses that reasoning
     deliberately. The panel is a SURFACE again, the same white the table and the
     cards are, rather than a continuation of the page's own fill; against the
     blue-tinted page it now reads as a distinct thing laid over/beside the page,
     which is what the border-left and (in overlay mode) the shadow already say.
     --color-surface, not a #ffffff literal — it is the system's white. */
  background: var(--color-surface);
  box-shadow: var(--elevation-xl);
  transform: translateX(100%);
  transition: transform 0.2s ease;
  z-index: 201;
}

.filter-drawer--open {
  transform: translateX(0);
}

/* ------------------------------------------------------------------
   EXPLORATION (2026-08-20, on request) — the drawer as a PUSH panel rather than
   an overlay: it slides in and the page narrows to make room instead of the page
   being dimmed behind it. Opt-in per page via .shell--filters-push on .shell, and
   .shell--filters-open while it is open, so Products keeps the overlay drawer and
   the whole thing reverts by deleting the class from orders.html's .shell.

   The drawer itself is barely touched — still position: fixed, still the same
   translateX slide. What "push" means here is a right margin on .page__body,
   which is both far less machinery than moving the drawer into the flex flow and
   the reason this is cheap to revert: nothing about the drawer's own layout
   depends on which mode it is in. (It was padding on [data-page-content] until
   2026-08-28 — see the rule itself for why it moved down to the body.)

   No overlay: nothing is being covered, so dimming the page would describe a
   modality this no longer has. That is suppressed in openFilterDrawer() rather
   than here — the overlay is a SIBLING of .shell, not a descendant, so there is
   no selector to reach it from the mode class without :has() on body.

   NOTE the width below is .filter-drawer's own 300px repeated. There is no token
   for "how wide is a drawer" (see the note on .filter-drawer) and no ancestor
   both rules share to hang a custom property on — if one changes, change both.
   (Both were changed together on 2026-08-27, 374 -> 300.)
   ------------------------------------------------------------------ */

/* Under the global header, not over it: the header is global chrome and stays
   whole and full width, so the panel starts where the page content does. */
/* NOT A CARD ANY MORE (2026-09-08, on request: "the filter in orders looks weird
   as a card now, it shouldn't be placed on a container, just make it feel like
   it's part of the table, so there's a right side divider, then the filter content
   shows. All on a container that spans across the entire background colour page
   area").

   WHAT THIS REPLACES, since it is the third answer to the same question and the
   reasoning for the second is worth keeping: from 2026-08-27 this was a CARD —
   border on all four sides, --radius-md, height following its fields, inset by the
   page's right gutter so its right border landed level with the table's. The
   argument was that a surface running off the bottom of the window beside a table
   that ends in a rounded corner reads as a drawer that forgot to close. True of a
   drawer; the answer here is that this is no longer read as a drawer at all.

   A BAND, THEN. The panel is now part of the page's own field rather than an object
   on it: no radius, no shadow, and a SINGLE LEFT BORDER that is the divider between
   the table and the filters. Read left to right that is exactly the request — table,
   divider, filter content. Nothing is stacked on anything.
   WHITE, NOT THE PAGE FILL (2026-09-08, on the user's screenshot: "the filter
   background should also be white"). It was --color-page for a few minutes, which was
   a misreading of "spans the entire background colour page area" — that phrase was
   about the band's EXTENT, not its colour. On Classic --color-page is the blue tint,
   so the band read as a strip of page pinned beside a white table rather than as the
   table's own continuation. --color-surface is the same white the table is, so the
   divider is the only thing between them, which is what "part of the table" means.
   It also keeps the filter controls legible: they are --color-surface with a
   --color-outline stroke, and on Light, where the page is within a hair of white
   anyway, a page-filled band left them floating on almost their own colour.
   THE DIVIDER IS THE WHOLE CHROME, so it stays --color-outline-card, the 8% stroke
   the table's own frame uses: the two lines meet at the table's right edge and a 15%
   stroke beside an 8% one reads as a mistake (same reasoning tokens.css gives for the
   table frame). It is on the panel's own left edge rather than the table's right, so
   it runs the band's full height, past where the table ends.

   TOP AND BOTTOM. `bottom: 0` and no max-height: the band runs to the bottom of the
   window, which is what "spans the entire page area" asks for and what makes it read
   as a region of the page rather than a floating panel. The TOP is unchanged and
   deliberately so — still the table's own measured top, clamped to one gutter under
   the global header. Starting at the app header instead would put the band over the
   page header's right end, which is where Orders' Export button lives; that exact
   overlap is a bug this rule has already been through once (see the reservation's
   note below on "keep the export button top right").

   Overlay mode (products.html) is untouched — a drawer that slides over a dimmed
   page is exactly what it looks like, and a white surface with a shadow is right
   there. */
.filter-drawer--push {
  /* The panel's top, as a custom property rather than a bare `top`, because a
     PAGE has to be able to move it: how far down the table starts depends on that
     page's own header composition (a bare title row, a tab row, a channel nav —
     all different heights), which is not something this element can know. The
     default clears the global header only, which is where the panel sat until now;
     orders.html overrides it to line up with its own table. Local to this rule, NOT
     a token in tokens.css — it is a hook for one element, and the note on
     .filter-drawer's width explains why there is no shared ancestor to hang it on.
     (It backs the max-height below as well as `top`, now that the card is
     content-height again — the two are read from the same property so the card
     can never bottom out somewhere its top doesn't agree with. Kept as a
     property rather than folded back into `top` because the page override is the
     point of it, not the second read.) */
  /* No `+ 1px` for .app-header's own border-bottom, which an earlier version of
     this rule added and which was simply a bug: box-sizing: border-box is global
     (elements.css *), so the header's `height: var(--app-header-height)` already
     INCLUDES that border. The old comment here claimed it did not. */
  --filter-drawer-top: var(--app-header-height);
  /* The panel starts at the table TOOLBAR's bottom — but never higher than the global
     header's own bottom edge.
     UNDER THE TOOLBAR IN BOTH SHAPES (2026-09-08, on request: "in the default shell,
     make filters also appear the same way as in the l shaped, as in below the table
     header and pushing the content, with a divider on the left too"). The l-shape got
     this structure first, from a mock; the default shell followed the same day, so the
     two now differ only in geometry — where the right edge sits, and what the bottom
     corner does — never in shape. What the anchor is measured against lives in
     syncFilterDrawerTop() (orders.html), which now reports the toolbar's bottom
     whatever the shell shape is.
     WHY THE TOOLBAR AND NOT THE TABLE: the toolbar acts on the whole table, the
     filters included — the Filters button that opens this panel is in it — so a
     control that owns both columns must not sit inside one of them. Once the page is scrolled the table's top passes under that
     header, and a panel that followed it would slide under the app chrome; clamped,
     it stops there and simply gets taller (2026-08-27, on request).
     THE FLOOR LOST ITS GUTTER (2026-09-08, on the user's screenshot: "when scrolling
     up, just move the panel up and so that gap above it is removed"). It was
     app-header + --page-gutter, which parked the scrolled band 16px below the header
     with a strip of page showing between them — right for the CARD this used to be,
     since a card floating one gutter off the chrome is what a card does, and wrong
     for a band, which is a region of the page and has to meet the header the way the
     rail does. Flush at var(--app-header-height), so the band's own top divider now
     sits directly under the header's bottom border while scrolled.
     BOTH SHAPES TAKE THE SAME FLOOR: the l-shape's page card carries margins on its
     right and bottom only — its 24px of top air is PADDING inside the card, not a
     gap above it — so the header's bottom edge is where the page area starts there
     too, and no shape guard is needed.
     max() rather than clamping in JS, so the floor stays expressed in the tokens it
     is made of and the script only has to report where the table is. */
  top: max(var(--app-header-height), var(--filter-drawer-top));
  /* CONTENT HEIGHT again (2026-09-02, on request: "adjust the height of the
     filter page to not span across the entire page height, just enclose the
     elements inside"). This is the third round on the same question — content
     height, then full height on 2026-08-27, now back — so the reasoning that
     full height replaced is stated rather than deleted: a card pinned top and
     bottom ends where the WINDOW ends, which with two fields in it is mostly
     empty white beside a table that stops much higher up.
     The base rule's `bottom: 0` has to be undone explicitly, hence `auto`.
     Nothing is needed for the bottom padding the request asks to match the side
     ones: .filter-fields already carries --space-16 on all four sides, so the
     last field sits one gutter off the card's bottom border by itself.
     max-height keeps the card inside the window once the field list is long
     enough to reach it — same two terms the `top` above is made of, so the card
     bottoms out one --page-gutter from the window's edge and
     .filter-drawer__body (flex: 1, overflow-y: auto) scrolls from there. */
  /* Both restored to the base drawer's own values, undoing the card: the band runs
     from its top to the bottom of the window. `bottom: 0` and `max-height: none`
     are stated rather than deleted because the base .filter-drawer rule sets
     `bottom: 0` and this rule used to override it — leaving `auto` here would keep
     the card's content height, which is the thing being removed. */
  bottom: 0;
  max-height: none;
  /* One page gutter off the window's edge (2026-09-08, on request: "make sure there
     is padding on the right side, now filter is flush to the right edge"). It was
     `right: 0` for a few hours today, on the reading that a region of the page area
     does not float off the edge; the request overrules that — the band is inside the
     page's own gutter like everything else the page draws, and running it into the
     window's edge left the fields' right margin looking like a mistake rather than a
     choice.
     The reservation below and the closed-position transform both carry this term with
     them: the three are one calculation and move together.
     THE L-SHAPE SETS ITS OWN (--space-12, the card's inset) further down. */
  right: var(--page-gutter);
  background: var(--color-surface);
  box-shadow: none;
  /* ONE DIVIDER, ON THE LEFT — the seam between the rows and the filters, and the
     only chrome the band has. --color-outline-card rather than --color-outline: it
     meets the table's own frame, which is the 8% stroke, and a 15% line beside an 8%
     one reads as a mistake (the same reasoning tokens.css gives for the table frame).
     Border-box is global (elements.css), so it sits INSIDE the 300px and the
     reservation below needs no adjustment for it.
     NO TOP BORDER AND NO TOP RADII (2026-09-08, when the default shell adopted the
     l-shape's structure). Both existed for the layout this replaced, where the band
     started at the TABLE's top and had an open top edge to close and visible corners
     to soften. The band now starts under the table TOOLBAR, whose own border-bottom
     runs the full width across both columns and is the line above it — a second stroke
     a pixel below that is doubling, and a curve at either end would cut a notch out of
     an edge that is meant to be continuous with the row above.
     `border-radius: 0` undoes the base .filter-drawer's inherited corners rather than
     restating anything. It has to come AFTER any longhand corner, which is why the
     shape-specific bottom corners below are set in their own rules and not here. */
  border: 0;
  /* 12% with the cards (2026-09-16 — see .card in elements.css). A standing panel beside
     the table is a container edge, not a divider; orders.html's own copies of this border
     follow the same token. */
  border-left: 1px solid var(--color-outline-container);
  border-radius: 0;
  /* UNDER the page's own menus (2026-09-02, on the user's report: the Export
     menu and the toolbar dropdowns "appear below the filter panel"). The base
     rule's 201 is an OVERLAY drawer's number — it sits over a dimmed page and
     over everything in it, which is what modal means. A push panel is the
     opposite: nothing is covered, the page is still live beside it, and its
     controls have to be able to open over the panel's top corner the way they
     open over anything else. 50 is below `.menu`'s 60 (elements.css) and below
     the popovers at 100, and still above the page's own sticky chrome — the
     toolbar and selection bar at 2, the sticky head at 1. */
  z-index: 50;
  /* IT WIPES OPEN FROM THE TABLE'S EDGE, IT DOES NOT SLIDE IN OVER THE PAGE
     (2026-09-08, on the user's report: "there's something a bit off with the way the
     filters panel appears and move away, going over the table and container edge, it
     should look like it comes in from the edge of the table itself").

     WHAT WAS WRONG. The base .filter-drawer animates translateX — right for an OVERLAY
     drawer, which is a sheet flying in from off-screen over the page. A push panel is
     not that: it is a column of the table that opens as the rows narrow to make room.
     Sliding it meant the whole panel, chrome and fields together, travelled across the
     page background and over the table's right edge on the way in, arriving at a seam
     that had already moved to meet it — two motions crossing, which is exactly the
     "off" in the report.
     A clip-path inset from the right reveals the panel IN PLACE: nothing of it is ever
     outside its own column, so the edge of the table is where it appears from and the
     rows' margin animation is the only thing actually moving. Same 0.2s and same easing
     as that margin, so the seam and the reveal stay welded together.
     TRANSFORM EXPLICITLY NONE, because the base rule's translateX is still there for
     overlay mode and would otherwise apply on top of this.
     THE OVERLAY DRAWER IS UNTOUCHED — products.html still slides, and should. */
  transform: none;
  clip-path: inset(0 0 0 0);
  transition: clip-path 0.2s ease;
}

/* THE OPEN-LIST OVERFLOW ESCAPE IS GONE (2026-09-08, with the card). While the
   panel was content-height, .filter-drawer__body's `overflow-y: auto` clipped an
   option list that opened near the card's short bottom edge, so this rule lifted
   the clip for as long as a list was open — accepting that the body could not
   scroll in that state.
   The band runs to the bottom of the window now, so there is no short edge to
   escape: a list opens inside a full-height column and the body's own scrolling is
   the right behaviour again, including for a field list long enough to need it.
   Two earlier answers to the same clipping, both worse and both already reverted,
   are recorded here so they are not tried a third time: growing the card to full
   height while a list was open (on the user's report, "when I press a dropdown,
   the filter panel goes full height for a bit" — the panel flinched on every
   open), and this overflow lift. */

/* THE .filter-drawer--pinned RULE IS GONE (2026-09-08, with the top divider it
   existed to remove). It blanked the band's top border once the band reached the
   global header, because a second horizontal rule a pixel under the header's own is
   doubling. There is no top border left to blank: the toolbar's border-bottom is the
   line above the band in both shapes now. orders.html still toggles the class — it
   costs nothing and is the hook if this edge ever needs a state again. */

/* THE DEFAULT SHELL REDRAWS THE TABLE'S RIGHT EDGE (2026-09-08, with that shell
   adopting this layout). Here the table is a bordered card ending one --page-gutter
   in from the window, and the band's right edge lands on exactly that line — so the
   band paints over the table's own border-right for its full height and the card
   loses its edge from the toolbar down. A matching stroke on the band puts it back;
   it is the same colour on the same pixel, so the card reads as unbroken.
   NOT NEEDED IN THE L-SHAPE: the table is full-bleed there with no side borders at
   all (see the L-SHAPED SHELL section), and the card's own edge is 12px further out. */
html[data-shell-shape="default"] .filter-drawer--push {
  /* FOLLOWS THE TABLE'S OWN EDGE, WHICH WENT TO 15% ON 2026-09-16 (elements.css,
     .table, with the card stroke). The whole point of this rule is to be "the same
     colour on the same pixel" as the border it paints over, so it moves with it.
     (Stale but harmless since 2026-09-15: the panel is an inset card now and no longer
     overlaps the table's right edge at all. Kept because the geometry could come back;
     it costs one declaration.) */
  border-right: 1px solid var(--color-outline-container);
}

/* THE BAND FOLLOWS THE L-SHAPE'S SHEET (2026-09-08, with the band itself).
   `right: 0` above is the DEFAULT shell's geometry, where the page runs to the
   window's edge. In the l-shape the page is a lifted card inset 12px from the right
   and 8px from the bottom (see the L-SHAPED SHELL section), so a band flush to the
   window would paint over that inset and over the sheet's own rounded right corners
   — the filters sitting on top of the card's edge instead of inside it, which is a
   worse version of the card-ness this whole change removes.
   THE VALUES ARE THE SHEET'S OWN, not new numbers, and the bottom pair is split the
   same way the sheet splits it: a page that scrolls has no bottom edge to draw, so
   the band runs to the window like the sheet does, and a page that fits stops on the
   sheet's 8px band and takes the sheet's radius on the one corner it shares with it.
   IF THE SHEET'S INSETS CHANGE, CHANGE THESE. There is no shared custom property to
   read them from — the sheet writes --space-12/--space-8 directly — and inventing one
   for two consumers is a token decision, which CLAUDE.md says to ask about rather
   than take. */
html[data-shell-shape="l-shaped"] .filter-drawer--push {
  right: var(--space-12);
  bottom: var(--space-8);
  border-bottom-right-radius: var(--radius-shell-sheet);
}

/* NO SCROLLABLE OVERRIDE ANY MORE (removed 2026-09-08, on the user's screenshot:
   "the bottom left corner in shell L shaped and bottom right corner should be
   rounded... now it's straight"). It squared the band's bottom-right and ran it to
   the window whenever the page could scroll, mirroring what the card itself does —
   right while the card really does run off the fold, and wrong for Orders, whose card
   ends in a STICKY foot and therefore always shows its bottom edge. The card now keeps
   that edge in exactly that case (see the .page rule in the L-SHAPED SHELL section), so
   the band keeps its 8px band and its rounded corner to stay level with it. */

/* THE L-SHAPE'S BAND STARTS UNDER THE TABLE TOOLBAR, NOT AT THE TABLE'S TOP
   (2026-09-08, on request, with a structure mock: "make filters appear below the
   table toolbar, pushed the column content").

   WHAT THE MOCK CHANGES, and it is structure rather than skin — the panel's content,
   its width and everything else about it are untouched. The toolbar (scope, search,
   Filters, Export) now runs the CARD's full width, unbroken, and the split happens
   BELOW it: rows on the left, filters on the right, one vertical divider between
   them, both running to the bottom of the card. Before this the band's top was the
   table's own top, so it cut the toolbar in half and the search row stopped short of
   the filters.
   WHY IT READS BETTER THAT WAY, since it is worth stating once: the toolbar acts on
   the whole table, including on the filters themselves — the Filters button that
   opens this panel lives in it. A control that owns both columns should not be
   inside one of them.
   THREE PIECES MAKE IT UP, all scoped to this shape: the band's TOP (measured to the
   toolbar's bottom, in orders.html's syncFilterDrawerTop — the one part that cannot
   be CSS), its TOP BORDER (dropped below, because the toolbar's own border-bottom is
   now the line above it), and the RESERVATION, which moves off .page__body and onto
   the table's non-toolbar children so the toolbar keeps its full width. See the
   reservation's own rule further down.
   THE DEFAULT SHELL IS UNCHANGED — full-height band from the table's top, page-body
   reservation, as built earlier today. The request named this shape only, and the two
   are genuinely different framings: there is no card in the default shell for a
   column to be a column OF. */
/* NOTHING SHAPE-SPECIFIC IS LEFT HERE. This rule carried the l-shape's transparent
   top border and, for about a minute, a grey fill; both are now the base rule's own
   (no top border at all, --color-surface). What remains different between the shapes
   is geometry only — the right inset and the bottom corner, set in the rule above
   this block. */

/* THE TOP-RIGHT CORNER RULE IS GONE (added and removed the same day, 2026-09-08). It
   rounded the band's top-right to --radius-shell-sheet while pinned, because the band
   then started at the card's own top edge and squared off its corner. Under the layout
   above the band starts BELOW the toolbar, which is inside the card — there is no card
   corner at its top to match any more, and rounding one would cut a notch of card fill
   out of the band's own edge. The default shell never had the problem: no card, no
   corner. */

/* NO SHAPE-SPECIFIC CLOSED POSITION ANY MORE (2026-09-08, with the wipe). While the
   panel slid, every change to its right inset needed a matching change here — a
   translateX of 100% is the panel's own width, so a band parked 12px in from the
   window left a 12px sliver of itself showing. A clip-path has no such arithmetic:
   `inset(0 0 0 100%)` is fully closed wherever the panel happens to sit, in either
   shape and at any inset. */

/* The closed position has to clear the gutter, or the band parks with a 16px sliver
   of itself still showing at the window's edge — translateX(100%) is 300px, which is
   exactly one --page-gutter short now that the band is inset again.
   :not(--open) rather than a bare override: .filter-drawer--open sits ABOVE this in
   the file and scores the same single class, so an unqualified transform here would
   win over it and the band would never slide in at all.
   (This rule existed from 2026-08-27, went for the few hours the band ran flush to
   the window's edge, and is back with the inset.) */
.filter-drawer--push:not(.filter-drawer--open) {
  transform: none;
  /* Closed IS fully clipped from the right — the column has zero width and the panel
     sits exactly where it will be when open, waiting behind the table's edge. */
  clip-path: inset(0 0 0 100%);
}

/* NOTE for the z-index above: lowering the drawer only works because `.page`
   is not a stacking context of its own. It was one until 2026-09-02 —
   app-transitions.css ran its fade with `animation-fill-mode: both`, and an
   animation that is still filling keeps its element a stacking context forever,
   which trapped every `.menu` inside the page at the page's own level (auto = 0)
   and put ANY positive z-index on the drawer over it. The first fix here was to
   give `.page` a layer above the panel; that traded one bug for a worse one, a
   full-width `.page` painting over the panel and swallowing every click meant
   for it. The fill-mode is the actual cause and is where it is fixed now — see
   app-transitions.css. Nothing in this file should raise `.page`. */

/* THE BODY NO LONGER MOVES, so it no longer animates (2026-09-08). This transition
   smoothed .page__body's right padding while that padding was the reservation; the
   reservation is now a margin on the table's own children and carries its own
   transition, further down. Kept as a note rather than deleted because the two rules
   this sat between still explain WHERE a reservation may not go: never on
   .shell__main, whose other child is .app-header, and never on [data-page-content],
   which holds the page header. */

/* The push itself: the page gives up room on the right and the panel occupies
   it. ALWAYS — there is no width at which the panel goes back to floating over
   the table (2026-08-27, on request: "the filter panel pushes the order table to
   make room for itself, don't overlap it").

   This replaced a @media (min-width: 1400px) gate and its companion query that
   handed the panel its --elevation-xl back below that width. The gate's reasoning
   was that the Orders table is eleven minmax() columns with hard floors — about
   1114px it cannot shrink below — so a narrow window has no room to give and
   floating was "the one thing it can do without shredding the table". That reads
   as a tradeoff and is really a contradiction: a panel that pushes at one width
   and covers the table at another is two elements wearing one class, and the
   window width is not something the user changed to ask for different behaviour.
   What a narrow window actually needs is a SCROLLBAR, which the rules below
   provide. The table stops fitting; it does not stop being reachable.

   WHERE THE RESERVATION LIVES HAS MOVED, and the number with it — see the rule
   further down. From 2026-08-27 to 2026-09-08 it was .page__body's right padding,
   measured from the window's edge: the panel's own inset, its 300px, and 16px of air
   between the table and the divider. That number went 332 -> 316 -> 332 in one day as
   the inset term came and went, and none of it survives: the band now starts under the
   table toolbar, so the reservation is a 300px margin on the table's non-toolbar
   children and the body keeps its ordinary gutter.

   ACCEPTED LIMIT (2026-08-28). While the reservation sat on [data-page-content]
   it also narrowed .page — the scroll container — so a table too wide for the
   space was CLIPPED at the seam and scrollable to reach the rest. On the body,
   .page is full width again: an over-wide card spills into the reserved band and
   goes behind the panel instead of stopping at it. That case is not reachable on
   the one page using push mode — orders.html relaxes its two truncating columns
   while the panel is open, precisely so the card fits — and the cost of the
   alternative was the page header being dragged inward on every screen, which is
   a bug you see every time rather than one you see at one window width. Revisit
   if a second page adopts push mode with a table that cannot compress.

   HISTORICAL NOTE on those three numbers, since they will look arbitrary out of
   context: each was correct for the geometry of its own day, and the term that kept
   moving was the panel's inset from the window, never the 300 or the 16. All three are
   dead now — the reservation is not measured from the window at all any more. */

/* The reservation goes on .page__body, NOT on [data-page-content] — which is
   where it lived until 2026-08-28, and which narrowed the PAGE HEADER along with
   the table. The panel's top edge is already below the title row (that is what
   --filter-drawer-top is for), so the row above it has the full window width
   available and nothing to clear; reserving space on the whole page column
   dragged the page's actions inward for no reason, and Orders' Export button
   ended up floating in the middle of the header (on the user's report: "keep the
   export button top right, the filters panel is pushing it").

   PADDING, and it must be padding. The first attempt at this used margin-right
   and pushed nothing at all — .page__body carries `width: 100%`, so a right
   margin over-constrains the block equation and the used value is thrown away,
   which is why the table went straight back to running under the panel. Padding
   works because box-sizing: border-box is global (elements.css *): the border box
   stays full width and the CONTENT box gives up the reservation, so the card
   inside lands its right border on the seam.

   It REPLACES the body's own --page-gutter on this side rather than adding to it,
   which is why the number is measured from the window's edge and why there is no
   second rule zeroing the gutter (there was one until this became padding). */
/* NOT ON .page__body ANY MORE, IN EITHER SHAPE (2026-09-08). It was
   `padding-right: calc(var(--page-gutter) + 300px + var(--space-16))` = 332px, which
   narrowed the whole table, toolbar included — right while the band was a full-height
   column beside the page, and wrong now that it starts under the toolbar in both
   shapes. The toolbar keeps the page's full width; only the table's other children
   give room up. See the rule below. */

/* THE RESERVATION, on every child of the table EXCEPT the toolbar — head, body, foot,
   selection bar, empty state.
   300px EXACTLY, no gutter added: the band's left edge is 300px in from the table's
   own right edge in both shapes (default shell — the band takes the page gutter, which
   is where the table's edge already is; l-shape — the band takes the card's 12px inset,
   which is likewise the table's edge, since the table is full-bleed there). The rows
   end ON the divider, which is what a column split means; the 16px of air the earlier
   layout kept is what a floating panel needed, not a column.
   MARGIN, NOT PADDING: a row is a grid, and padding-right on .table__head would
   compress its last column inside a box that still spans the page. Margin narrows the
   box, which is what pushes the column content.
   The toolbar is excluded BY NAME rather than by :not(:first-child) — .table__foot and
   .selection-bar are also not-first, and what makes the toolbar special is what it is,
   not where it sits. */
.shell--filters-push.shell--filters-open .page__body--full > .table > *:not(.table__toolbar) {
  margin-right: 300px;
}

/* ...and they animate with the panel, the same 0.2s the body's padding used to, so the
   columns narrow as the band slides in instead of snapping a frame ahead of it. On the
   table's children at all times, not only while open, or the closing half of the
   transition would have nothing to run. */
.shell--filters-push .page__body--full > .table > * {
  transition: margin-right 0.2s ease;
}

/* THE L-SHAPE RESERVES SOMEWHERE ELSE ENTIRELY (2026-09-08, with the layout above).
   The rule before this one narrows .page__body, which narrows the WHOLE table,
   toolbar included — right for the default shell, where the band is a full-height
   column beside the page. In the l-shape the toolbar has to keep the card's full
   width and only the columns below it give room up, so the body goes back to its
   ordinary gutter and the reservation moves onto the table's other children.
     - `padding-right: var(--page-gutter)` undoes the general rule above rather than
       zeroing anything: that IS .page__body's resting value, so the toolbar sits
       where it always did.
     - `margin-right: 300px` on every child of the table EXCEPT the toolbar — head,
       body, foot, selection bar. 300 exactly, with no gutter added: the table is
       full-bleed in this shape (negative side margins, see the L-SHAPED SHELL
       section), so its right edge already IS the card's edge and the band's left
       edge is 300px in from it. The rows end on the divider, which is what a column
       split means; the 16px of air the other shell keeps is what a floating panel
       needed, not a column.
     - The toolbar is excluded by name rather than by :not(:first-child) — .table__foot
       and .selection-bar are also not-first, and what makes the toolbar special is
       what it IS, not where it sits.
   MARGIN, NOT PADDING, on these: a row is a grid, and padding-right on .table__head
   would compress its last column inside a box that still spans the card. Margin
   narrows the box, which is what pushes the column content the request asks for. */
/* THE L-SHAPE'S OWN COPIES OF THESE ARE GONE (2026-09-08). It reserved on the table's
   children first, as the shape that got this layout from the mock; the default shell
   adopted the same structure hours later, so the pair moved up to the unscoped rules
   above and the shape guard came off. */

/* The table can outgrow what the push leaves it, and .page's own
   overflow-x: hidden would CLIP the last columns with no way to reach them.
   Only while the panel is open, so the page keeps its no-horizontal-scroll
   behaviour the rest of the time. Since 2026-08-28 .page is no longer narrowed
   by the reservation (that moved to .page__body), so this only fires when the
   card is wider than the WINDOW — see "ACCEPTED LIMIT" above.
   This is also what makes "always push" safe at any width: .page's box is
   already narrowed by the padding above, and it clips its own overflowing
   children at its own right edge — which is exactly where the panel begins. So
   a table too wide for the space scrolls inside the page and is cut off at the
   seam; it never paints into the panel's column. */
.shell--filters-push.shell--filters-open .page {
  overflow-x: auto;
}

/* NO min-width on .table here, deliberately — it was tried twice on 2026-08-27
   and is wrong both times. Forcing the card to min-content makes it wider than
   the page the push has narrowed, and .page then clips it: the card loses its
   right border and its top-right rounded corner mid-column, which looks far more
   broken than the row spill it was meant to cure.
   The card must FIT. That is a question about the row's own column floors, not
   about the card, so it is answered where those floors live — orders.html, which
   relaxes the two columns designed to truncate while the panel is open. A page
   whose table genuinely cannot compress should let .page scroll (the rule above)
   rather than push its card out of shape. */

.filter-drawer__header {
  display: flex;
  align-items: center;
  justify-content: space-between;
  padding: var(--space-16);
}

.filter-drawer__title {
  margin: 0;
  /* --text-heading-xl (2026-09-03). It took --text-heading-2xl from 2026-08-27, on
     the instruction to "use the biggest header value available in tokens" — 28/32
     then, and 40/48 once the scale was rescaled earlier today, at which point a
     drawer opening over the page was shouting louder than the page it opened from.
     Stepped to --text-heading on "step down the filters header" and then up one to
     --text-heading-xl the same day, which is where it settled: --text-heading put it
     level with the field labels inside the drawer, and a panel's own title has to
     outrank its contents. One step above them does that without competing with the
     page title, which is the same --text-heading-xl the order detail's own title
     takes.
     Weight and family are unchanged: the system has no semibold weight and no
     --font-heading distinct from --font-sans, so this still reuses the system's
     heading convention rather than the Figma frame's own (semibold,
     'Figtree:SemiBold'). */
  font: var(--weight-medium) var(--text-heading-xl) var(--font-sans);
  color: var(--color-text-primary);
}

.filter-drawer__body {
  flex: 1;
  overflow-y: auto;
}

.filter-drawer__footer {
  display: flex;
  align-items: center;
  justify-content: flex-end;
  gap: var(--space-12);
  padding: var(--space-16);
  /* No border-top (removed 2026-08-21, on request). The footer holds a single
     Done that dismisses the panel — it commits nothing, so there is no
     "above the line is your work, below it is the action" split for a rule to
     draw. */
}

/* ------------------------------------------------------------------
   Filter fields — the contents of .filter-drawer, which until now was a shell
   with an empty body. From Figma 2042:14333, which shows the Orders drawer in
   six states: closed, Channel open, Channel with selections, Channel collapsed
   with chips + Status open, Status with selections, and everything collapsed.

   Two of the classes here are named in CLAUDE.md's "Not yet decided — do not
   implement" list: **chips** and **a real form select/combobox**. That list is
   overridden for elements by docs/proposals.md's own rule ("an element — a card,
   a chip, a dropdown — build it in proposals.css, log it, keep going"; a token
   is what stops and asks). Both are logged. Neither adds a token.

   The panel opens INLINE, pushing the fields below it down, rather than floating
   over them the way .menu does. That is what the Figma states show — in the
   "Channel open" state the Created date field has moved down the drawer, it is
   not covered — and it is the right behaviour in a 312px drawer, where a
   floating list would have nowhere to go and would fall outside the panel.
   ------------------------------------------------------------------ */

.filter-fields {
  display: flex;
  flex-direction: column;
  gap: var(--space-24);
  /* padding-top separates the fields from the drawer's header, which carries its
     own --space-16 below the title — so the visible gap is 16 + 16 = 32. */
  padding: var(--space-16) var(--space-16) var(--space-16);
}

/* Positioned, so the options panel can float against THIS field rather than
   against the drawer — see .filter-select__panel. */
.filter-field {
  position: relative;
  display: flex;
  flex-direction: column;
  gap: var(--space-8);
}

/* Label and the field's own Clear on one line — the Clear reads as belonging to
   the field it names rather than to the control below it, and it costs the field
   no extra height because it is capped to the label's own 20px line box. */
.filter-field__header {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: var(--space-8);
  min-height: 20px;
}

.filter-field__label {
  color: var(--color-text-secondary);
  font: var(--weight-regular) var(--text-body-md) var(--font-sans);
}

/* .btn--text supplies the accent colour and the hover underline; this only strips
   the button box so it sits on the label's line instead of setting a 32px row.
   NOT .btn--compact — that is still 28px, taller than the line it has to sit on. */
.filter-field__clear {
  height: 20px;
  padding: 0;
  font: var(--weight-regular) var(--text-body-md) var(--font-sans);
}

/* The closed control, and the box the chips sit in when there are any. Not a
   fixed --control-height: it grows as chips wrap (Figma's Channel field runs to
   three rows), so the height is a minimum and the padding does the rest. */
.filter-select {
  display: flex;
  /* flex-start, not center: once chips wrap to two or three rows the caret has to
     stay level with the FIRST row (top right), not drift to the middle of a tall
     control. The value and the caret below each reserve one row's height, so a
     single-line control still reads as vertically centred — the two rules together
     are what give "centred when short, top-aligned when tall". */
  align-items: flex-start;
  gap: var(--space-8);
  min-height: var(--control-height);
  /* 8px top and bottom, not 4 (2026-08-20, on request). --control-height stays as
     a floor rather than the actual height: one row of chips (20px) plus this
     padding makes the closed control 38px, and it grows from there as chips wrap. */
  padding: var(--space-8);
  box-sizing: border-box;
  background: var(--color-surface);
  border: 1px solid var(--color-outline);
  border-radius: var(--radius-sm);
  cursor: pointer;
  /* NO SIZE TRANSITION HERE, AND THAT IS NOT AN OVERSIGHT (2026-09-16). This control is
     the request's own example — "always smoothly animate size changes in the UI, never
     make these snappy, as an example changing a multi select dropdown in a table
     toolbar" — and it does animate, but it cannot be done from CSS: ticking a value
     changes the control's CONTENT, so its width goes from `auto` to `auto` and there is
     no computed change for a transition to run on. A `transition: width` written here
     would be inert (it was, for one revision).
     THE MECHANISM IS watchSizeChanges() in js/elements.js — a MutationObserver plus a
     Web Animations tween between the measured old and new widths. The Orders toolbar's
     copies are attached in orders.html; docs/foundations.md, "Motion", is the rule and
     says which size changes are CSS's job and which are the helper's. */
}

.filter-select:focus-visible {
  outline: 2px solid var(--color-accent-secondary);
  outline-offset: 1px;
}

/* Chips and the placeholder share this slot. flex-wrap so a full Channel
   selection stacks into rows instead of overflowing the drawer.
   min-height is ONE row — 20px, which is both a .chip's height and body-md's line
   box — and align-content centres a single row within it, so a lone placeholder or
   chip sits centred while a wrapped set grows downward from the top. It was
   derived from --control-height minus the padding while that padding was 4px;
   at 8px that arithmetic gives 16px, which is shorter than the chip it has to
   hold, so the row height is now stated directly. */
.filter-select__value {
  display: flex;
  flex: 1;
  min-width: 0;
  min-height: 20px;
  flex-wrap: wrap;
  align-items: center;
  align-content: center;
  /* Row gap is deliberately larger than the column gap: side by side, 4px reads
     as one field's worth of chips; stacked, the same 4px lets two 20px pills
     collide into a single block. 8px gives the wrapped rows their own rhythm
     without loosening the horizontal set. */
  gap: var(--space-8) var(--space-4);
}

.filter-select__placeholder {
  color: var(--color-text-primary);
  font: var(--weight-regular) var(--text-body-md) var(--font-sans);
}

/* The chevron reuses .menu-chevron's rotation convention rather than a second
   one — see elements.css. Rotated by the --open modifier below, not by
   mountMenus(), since this control is not a .menu. */
/* Same one-row height as the value above, so the caret centres against the first
   row of chips whatever the control has grown to. */
.filter-select__caret {
  flex: none;
  display: inline-flex;
  align-items: center;
  height: 20px;
  color: var(--color-text-secondary);
  transition: transform 0.15s ease;
}

.filter-select--open .filter-select__caret {
  transform: rotate(180deg);
}

/* Proposal-level headings, for the "Headings: Unique" setting — see the matching
   rule and its reasoning in elements.css, including why this is keyed on ["unique"]
   rather than on :not(["match"]). Same font-family-only override; these are the
   titles that live in this file rather than in the ratified set.
   .dashboard-action-row__title IS NOT ONE OF THEM (removed 2026-09-16, on request:
   "on the home screen, the list items in needs your attention titles are all using
   the unique header style, make sure they use whatever font is selected for the rest
   of the UI, in body-md size, medium weight instead"). It was in this list and should
   not have been: the other four name a SURFACE — a drawer, a peek, an empty state, a
   card — while that one is the first line of a ROW in a list, sitting above its own
   subtitle. A display face on a list item makes the rows read as a stack of little
   headings rather than as a list, and at body-md it is the same size as the body copy
   it would then be set in a different face from.
   NOTHING ELSE CHANGED WITH IT: this rule only ever overrode font-family, so the
   title keeps the body-md/medium/--color-text-primary it has always had in
   .dashboard-action-row__title — which is exactly what the request asks for, and is
   already what every other heading setting renders. */
:root:not([data-heading-font="match"]) :is(.filter-drawer__title, .product-peek__title,
  .empty-state__title, .dashboard-channels__title) {
  font-family: var(--font-heading);
  font-optical-sizing: auto;
  font-variation-settings: "wdth" 100;
}

/* Chip — a removable selected value. Fully rounded, per CLAUDE.md's foundation
   rule that badges and chips are fully rounded. NOTE this is a deliberate
   divergence from Figma 2042:14333, which draws these as small-radius
   rectangles; the foundation rule is explicit and a Figma exploration is not
   the place it gets overturned. Flagged in docs/proposals.md. */
.chip {
  display: inline-flex;
  align-items: center;
  gap: var(--space-4);
  height: 20px;   /* a height, not spacing — matches .badge, which is not tokenised either */
  padding: 0 var(--space-4) 0 var(--space-8);
  border-radius: var(--radius-full);
  /* --color-info-tint (#c5e2fb) — the same blue the "In progress" status pill
     carries, per request. Deliberately NOT --color-chip (#f5fafe then, #ecf5fe since
     2026-09-16; Figma's B5,
     which node 2042:14333 draws here): at that lightness a chip barely separated
     from the white control it sits in, and matching the status pill makes the
     toned chips (.chip--info especially) and the untoned ones read as one
     family. Flagged in docs/proposals.md as a divergence from the reference. */
  background: var(--color-info-tint);
  color: var(--color-text-primary);
  /* body-md, matching the option pills in the panel and the control's own
     placeholder text — a chip is a selected VALUE, so it should read at the same
     size as the value it replaced, not at .badge's 13px. The 20px height is
     unchanged: body-md's line box is exactly 20px, so this is a type change only. */
  font: var(--weight-medium) var(--text-body-md) var(--font-sans);
  white-space: nowrap;
}

/* Tone variants, for a chip standing in for a status. Same tints .badge uses, so
   a status reads identically wherever it appears — the Orders table's Status
   column, the filter's option list, and a selected chip are all one mark. The
   chip's own shape is already .badge's (20px, fully rounded), so only the fill
   changes; nothing here is a new colour. A status with no tone in
   CEData.statusTone keeps the neutral --color-chip fill above, exactly as an
   untoned .badge keeps --color-background. */
.chip--success { background: var(--color-success-tint); }
.chip--info    { background: var(--color-info-tint); }
.chip--warning { background: var(--color-warning-tint); }
.chip--error   { background: var(--color-error-tint); }

/* The chip's own remove affordance. A button, not a decorative glyph — it is
   the only way to clear one value without reopening the list. Sized to the
   chip rather than to --control-height: it lives inside a 20px pill. */
.chip__remove {
  display: inline-flex;
  align-items: center;
  justify-content: center;
  width: var(--space-16);
  height: var(--space-16);
  padding: 0;
  border: 0;
  border-radius: var(--radius-full);
  background: none;
  color: var(--color-text-secondary);
  cursor: pointer;
}

/* --color-surface, i.e. white: the chip's own fill is now a tint, so a white
   knockout is what reads as raised out of it. */
.chip__remove:hover {
  background: var(--color-surface);
  color: var(--color-text-primary);
}

.chip__remove .icon {
  width: var(--space-12);
  height: var(--space-12);
}

/* The expanded list — floats OVER the fields below rather than pushing them
   down (2026-08-20; it pushed them at first). Anchored to .filter-field, which
   is why that is positioned. --elevation-lg and the surface/outline pair are
   .menu's, since this is doing .menu's job even though it is not one.

   Transitioned rather than animated, and NOT toggled with [hidden]: an
   animation only plays on the way in, and display:none cuts a transition dead,
   so closing would snap. opacity + a small lift, with `visibility` in the
   transition list so the panel stays hittable until it has actually faded.
   The easing is .menu's own curve, so the two open the same way.

   max-height on the options list below keeps a ten-item Status list from
   running past the drawer.

   PANEL PADDING AND RADIUS ARE .menu's OWN (2026-09-11, request: the filter
   dropdown "looks different" from the export / Order-ID menus). They were 8px
   and --radius-sm against .menu's 4px and --radius-menu, so two panels doing the
   same job read as two components. Only the timing had ever been unified
   (2026-09-10); the geometry is unified here. .menu is the ratified element, so
   this proposal is what moved — nothing in elements.css changed.
   `gap` stays --space-8 and is NOT .menu's 0: it separates the search field from
   the option list, which is group separation, not row spacing. .menu has no
   equivalent child, so there is nothing to disagree with. */
.filter-select__panel {
  position: absolute;
  top: 100%;
  left: 0;
  right: 0;
  z-index: 10;
  display: flex;
  flex-direction: column;
  gap: var(--space-8);
  margin-top: var(--space-4);
  padding: var(--space-4);
  background: var(--color-surface);
  border: 1px solid var(--color-outline);
  border-radius: var(--radius-menu);
  box-shadow: var(--elevation-lg);
  opacity: 0;
  visibility: hidden;
  pointer-events: none;
  transform: translateY(calc(var(--space-4) * -1));
  /* 200ms, matching .menu's own open (elements.css) — every dropdown in the app
     opens on one timing after 2026-09-10's "max. 200 ms" request. This panel was
     already the slower of the two at 180ms; the 20ms is for the match, not for the
     feel. Unlike .menu this one closes as well as opens, because it is toggled by a
     class rather than by [hidden] — so the same curve runs in reverse on dismissal
     and there is nothing extra to wire. */
  transition:
    opacity 0.2s cubic-bezier(0.32, 0.72, 0, 1),
    transform 0.2s cubic-bezier(0.32, 0.72, 0, 1),
    visibility 0.2s;
}

.filter-select__panel--open {
  opacity: 1;
  visibility: visible;
  pointer-events: auto;
  transform: translateY(0);
}

/* An open field has to paint above the fields under it, not just its panel —
   otherwise the next field's own control sits on top of this one's shadow. */
.filter-field:has(.filter-select__panel--open) {
  z-index: 1;
}

@media (prefers-reduced-motion: reduce) {
  .filter-select__panel,
  .filter-select__caret {
    transition: none;
  }
}

/* Rows are FLUSH, as .menu's are (2026-09-11, same alignment pass as the panel
   above). The 8px gap that used to sit here was what gave 28px rows their air;
   the rows are 36px now and carry that air in their own padding, so the gap
   would be air on top of air.
   THE ROW PITCH IS UNCHANGED AT 36px — it was 28 + 8 of gap, it is 36 + 0 — which
   is why max-height did not have to move: the same 7-and-a-bit rows are visible
   before the list scrolls.
   max-height is what makes the list scroll rather than run past the drawer; it is
   a one-off panel dimension, like .filter-drawer's own width. */
/* A search bar inside a menu sits further in than the rows (2026-10-20, on
   request: "add more padding to the search bar shown inside a menu"). The panel's
   own --space-4 padding left the bar's border 4px off the panel's, close enough
   to read as a second border. --space-4 of margin doubles that to 8px on the top
   and sides. width: auto undoes a page's width: 100% (the Dashboard shortcut picker),
   which would add the margin on top and overflow; the column panels stretch it. */
.menu > .search,
.filter-select__panel > .search {
  width: auto;
  /* No bottom margin: the panel's own gap already spaces the list below. */
  margin: var(--space-4) var(--space-4) 0;
}

.filter-select__options {
  display: flex;
  flex-direction: column;
  /* 344px — 264 + 30% (2026-09-11, on request, naming Status and Channels: the
     two lists long enough to be capped). It is a max, so it only ever changes
     those two and any future list of ten or more; a four-option panel still
     shrinks to its content and is untouched.
     At the 36px row pitch this lands on 9.5 rows rather than 7.3, and the half
     row at the fold is deliberate — a clipped row is the clearest signal that the
     list continues, clearer than the scrollbar alone. */
  max-height: 21.5rem;   /* was 16.5rem / 264px — 220 x 1.2 */
  overflow-y: auto;
  /* Reserves the track's width whether or not the list overflows, so adding or
     removing an option never shifts the rows sideways. */
  scrollbar-gutter: stable;
  /* NOTE: the standard scrollbar-width / scrollbar-color are deliberately NOT set
     here. From Chrome 121 they take precedence over ::-webkit-scrollbar, and the
     pseudo-element rules below are the only thing that opts this element out of
     macOS's overlay scrollbars — which hide until you scroll, so a list whose
     scrollability is the point reads as having nothing more in it. Setting both
     means the standard properties win and the scrollbar goes back to hiding.
     Firefox has no equivalent opt-out and keeps its own default. */
}

/* macOS hides overlay scrollbars until you actually scroll, which for a list whose
   scrollability is the point reads as "there is nothing more here". Styling
   ::-webkit-scrollbar opts this element out of the overlay treatment in Blink and
   WebKit, so the track is drawn permanently. Both colours are existing tokens —
   --color-outline is the system's one stroke colour, which is what a thumb this
   quiet should be. */
.filter-select__options::-webkit-scrollbar {
  width: var(--space-8);
}

.filter-select__options::-webkit-scrollbar-track {
  background: transparent;
}

.filter-select__options::-webkit-scrollbar-thumb {
  background: var(--color-outline);
  border-radius: var(--radius-full);
}

/* The whole row is the target, not just the box — a 16px checkbox is a small
   thing to hit. .checkbox itself stays the ratified element; this only lays the
   row out around it.

   PADDING, RADIUS AND HOVER ARE .menu__item's OWN (2026-09-11 — see
   .filter-select__panel above for the request and why this file is the one that
   moved). The row was 4px of padding, --radius-xs and a --color-background hover
   against .menu__item's 8px/12px, --radius-menu-item and --color-chip; it is 36px
   tall now, not 28. The list's own gap went to 0 in the same pass, so the pitch
   is the 36px it already was. */
.filter-option {
  display: flex;
  align-items: center;
  gap: var(--space-8);
  padding: var(--space-8) var(--space-12);
  border-radius: var(--radius-menu-item);
  color: var(--color-text-primary);
  font: var(--weight-regular) var(--text-body-md) var(--font-sans);
  cursor: pointer;
}

.filter-option:hover {
  background: var(--color-chip);
}

/* A status pill in the option list reads at body-md, matching the row's own text
   rather than the 13px .badge normally carries. Height stays .badge's 20px, which
   body-md's own 20px line box fits exactly — so this is a type change only, NOT
   .badge--lg. That matters: CLAUDE.md reserves the 28px pill for a page title and
   says explicitly it is never used in a list, which this is. */
.filter-option .badge {
  font: var(--weight-medium) var(--text-body-md) var(--font-sans);
}

/* Select all — divided from the options so it reads as acting ON them rather than
   being one of them.

   It sits OUTSIDE .filter-select__options, not as its first row: inside, it
   scrolled away with the list (unhelpful for the one control that acts on all of
   it) and its divider was inset from the panel by the scroller's own box, which is
   what made the line look like it stopped short and curved. Now it is a sibling,
   and the negative side margins cancel .filter-select__panel's padding so the
   divider runs the panel's full width, edge to edge — with the border and the
   padding on the SAME element, per CLAUDE.md. THE MARGIN TRACKS THE PANEL'S
   PADDING: --space-4 since 2026-09-11, when the panel took .menu's 4px; at the
   old -8px it would now overhang the panel and clip against its border.
   The 16px side padding is not .filter-option's 12px by accident — it is 12 plus
   the 4 this row gives back in margin, so its label still starts on the same
   vertical as every other row's.

   border-radius: 0 overrides .filter-option's own radius, which rounded the
   ends of the divider itself (a 2px curve on a 1px line — subtle, and exactly the
   "it curves around the edges" this was reported as). THIS RULE MUST STAY BELOW
   .filter-option: the two have equal specificity, so source order is the only
   thing deciding it, and above it the reset silently lost. */
.filter-option--all {
  margin: 0 calc(var(--space-4) * -1);
  padding: var(--space-8) var(--space-16) var(--space-12);
  border-bottom: 1px solid var(--color-outline);
  border-radius: 0;
  font: var(--weight-medium) var(--text-body-md) var(--font-sans);
}


/* ------------------------------------------------------------------
   Selection bar — the bulk-action bar that replaces the table's idle state once
   rows are checked. --color-sidebar is reused deliberately: it is already the
   system's one dark surface, and matching it here reads as "the app's own chrome
   taking over the toolbar" rather than a new colour being introduced.
   ------------------------------------------------------------------ */
.selection-bar {
  display: flex;
  align-items: center;
  gap: var(--space-8);
  /* nowrap since 2026-09-02 (on the user's instruction). A bulk bar that wraps
     puts Export selected on a second line by itself, which reads as a second bar
     rather than as the same one continuing. The bar stays one line and the
     actions that no longer fit go into a "More actions" kebab at its right end —
     measured and moved in JS, since only the page knows how wide its own labels
     are (fitSelectionBar(), prototypes/app/orders.html). */
  flex-wrap: nowrap;
  padding: var(--space-8) var(--space-16);
  /* --color-selection-bar, not --color-sidebar (2026-09-08). Same colour on Classic
     and Dark — the token resolves to the rail's fill there — but Light now keeps the
     bar dark while its rail is pale. See the token's note in tokens.css for why the
     two stopped being one statement. */
  background: var(--color-selection-bar);
  border-radius: var(--radius-md);
  overflow: hidden;
  max-height: 3.5rem;
  opacity: 1;
  transform: translateY(0);
  transition: opacity 0.2s ease, transform 0.2s ease, max-height 0.2s ease, padding 0.2s ease;
}

/* The bar's own open/close, restated at four classes for the same collision the
   sticky head hits right below (2026-09-08): inside the push shell the
   margin-right rule was replacing this list wholesale, so the bar appeared and
   vanished with no animation whatever .selection-bar asked for. Identical list,
   plus the margin-right that has to keep working. */
.shell--filters-push .page__body--full > .table > .selection-bar {
  transition:
    opacity 0.2s ease, transform 0.2s ease, max-height 0.2s ease,
    padding 0.2s ease, margin-right 0.2s ease;
}

/* ...except while a menu inside it is open. `overflow: hidden` above is there
   for the collapse animation — it is what keeps the bar's contents from spilling
   as its max-height goes to zero — but it also clips the overflow kebab's own
   dropdown, which has to hang below the bar to be read at all. The bar is never
   collapsing and showing a menu at the same time, so lifting it in this one
   state costs the animation nothing. */
.selection-bar:has(.menu:not([hidden])) {
  overflow: visible;
}

/* ...and that menu opens without .menu's own 130ms fade. Not a style preference:
   the bar animates max-height, opacity and transform for its collapse, which
   promotes it to a composited layer, and a descendant running its OWN opacity
   animation inside that layer paints semi-transparent — the table rows show
   through the open menu, in headless and in a real browser alike. Killing the
   animation on this one menu is what fixes it; the menu appears at full opacity
   instead of fading in, which at 130ms is a difference you have to be looking
   for. Verified against a row's kebab menu, which is outside the bar, still
   fades, and paints solid. */
.selection-bar .menu {
  animation: none;
}

/* Checking a row toggles this class in JS (see orders.html), not the `hidden`
   attribute — elements.css's own `[hidden] { display: none !important }`
   (its global override of the UA stylesheet, so a class can't defeat it
   either) would collapse straight to display:none with no frame to
   transition from. A dedicated class keeps `display: flex` the whole time —
   the bar stays laid out at zero height/padding/opacity instead of
   disappearing instantly, giving the show/hide something to animate through. */
.selection-bar--hidden {
  max-height: 0;
  padding: 0 var(--space-16);
  opacity: 0;
  transform: translateY(-4px);
  pointer-events: none;
}

/* Warning state — the selection reaches rows the current filter set hides
   (orders.html, 2026-09-02, on the user's instruction). A bulk action still
   applies to every ticked row, including the ones scrolled out of existence by
   a filter, so the count on a dark bar would be quietly lying about what the
   next click hits. The bar turns --color-warning-tint and says so.

   Tint, not --color-warning: the bar carries text and white buttons, and the
   tints are the system's fills sized to sit behind --color-text-primary (see
   tokens.css, "Status") — the same pairing every badge uses. The count gives up
   --color-sidebar-on for the same reason: rail-white type on a pale fill is the
   one thing this swap must not keep.

   max-height is raised because the notice is a sentence: at a narrow table the
   bar wraps to a second line, and the 3.5rem ceiling above (there to give the
   open/close something to animate through) would clip it. */
.selection-bar--warning {
  /* --color-warning-tint knocked back into --color-surface (2026-09-02, on the
     user's instruction: "a more toned down yellow for contrast reasons"). The
     tint is a BADGE fill — sized to carry dark text across a pill-sized patch,
     not across a full-width band with white buttons sitting on it, where it
     reads as the loudest thing on the page and the buttons lose their edge
     against it. color-mix rather than a new token: the same treatment, and the
     same reason, as .dashboard-action-row's tinted rows further down this file.
     The mix only lightens, so the text contrast this state is judged on goes
     UP — --color-text-primary measures 12.5:1+ on the full tint (tokens.css,
     "Status") and more on a paler one.
     No max-height of its own: the notice used to be able to wrap the bar onto a
     second line, and the ceiling was raised to let it. The bar is nowrap since
     2026-09-02, so the state costs no height at all. */
  background: color-mix(in srgb, var(--color-warning-tint) 45%, var(--color-surface));
}

.selection-bar--warning .selection-bar__count {
  color: var(--color-text-primary);
  /* The notice restates what the count means, so the two read as one phrase —
     8px between them, and the notice keeps the 24px that separated the count
     from the action group. */
  margin-right: var(--space-8);
}

.selection-bar__notice {
  display: inline-flex;
  align-items: center;
  flex: none;
  gap: var(--space-8);
  margin-right: var(--space-24);
  color: var(--color-text-primary);
  font: var(--weight-regular) var(--text-body-sm) var(--font-sans);
}

.selection-bar__notice [data-icon] {
  flex: none;
}

/* Square, when the bar lives inside a .table (2026-08-28, on the user's direct
   instruction: "the bulk selection dark row shouldn't have any rounded
   corners"). Inside a table the bar is a full-bleed BAND between the toolbar
   and the header row, not a floating object on the surface — rounded corners
   made it read as a card dropped into the stack, with slivers of table showing
   past its curves at both ends. Its own --radius-md is kept for the standalone
   case (a bar above a card or a bare list), where it IS a floating object.
   orders.html carried this same override page-locally; now that it is here,
   that copy is gone. */
.table > .selection-bar {
  border-radius: 0;
  /* ...WITH A WHITE EDGE ON ITS LEFT (2026-09-08, on request: "so that this
     doesn't blend into the side bar"). Full-bleed, the band's left end stops 16px
     short of the rail, and on Classic and Dark the two are the same dark — near
     enough that the band read as the rail growing an arm across the page rather
     than as a bar belonging to the table. 2px of --color-surface is the page's own
     white restated as a hard edge, which separates the two without introducing a
     line colour that is nothing else in the system.
     BOTH ENDS, 1px each (2026-09-08, revised on request; it was 2px on the left
     alone). The left is the one doing the work the request named, but a band that
     is capped at one end and bleeds at the other reads as unfinished rather than
     as deliberate — the pair says "this is where the bar stops" on both sides.
     1px because at this contrast a hairline is enough: white on a near-black or
     navy fill is the highest-contrast edge the system can draw, and 2 of them read
     as a rule rather than as the band's own end. The 1px it eats from the bar's
     16px inset is below the threshold at which the count would need renudging to
     stay on .table__row's content line.

     --color-selection-bar-on, NOT --color-surface. The obvious choice is the page's
     own white, and it is wrong in the theme this was asked for: on Dark, the rail is
     #030303, the band is #030303 and the gutter between them is dark too — the three
     really are one mass — but --color-surface resolves to #1a1a1a there, so a "white"
     edge would come out a grey barely off the fill it is meant to cut. The bar's INK
     is white wherever the bar is dark, which is the same condition this edge exists
     for. On Classic and Light the gutter is already pale and the edge simply reads as
     the band's own crisp end. */
  border-left: 1px solid var(--color-selection-bar-on);
  border-right: 1px solid var(--color-selection-bar-on);
}

/* Sticky, when the bar lives inside a .table (2026-08-27, on request). Checking
   rows arms a set of bulk actions, and scrolling down the list to check more of
   them must not scroll those actions away — the bar is the same kind of
   always-reachable chrome .table__toolbar already is, only conditional on a
   selection existing.

   Offset by the toolbar's own rendered height, computed from the tokens
   .table__toolbar is built from (min-height + its 12px top/bottom padding + its
   1px border-bottom) rather than a measured pixel — the same technique, and the
   same numbers, as elements.css's sticky-head offset right below it.

   z-index 2 matches .table__toolbar's rather than .table__head's 1: the head is
   later in DOM order, so on a tie it would paint over this bar during the
   moment the two overlap as the bar opens or closes.

   Scoped to a direct child of .table — a selection bar used somewhere else (a
   card, a bare list) has no toolbar above it to clear and no scroll container of
   its own, so it stays in flow. */
.table > .selection-bar {
  position: sticky;
  top: calc(var(--control-height) + var(--space-12) * 2 + 1px);
  z-index: 2;
}

/* ...and the sticky head moves down to sit under it while it is open. The bar's
   own height is its 28px compact buttons plus its 8px top/bottom padding — again
   the tokens the rule above is built from, not a measurement. :not(--hidden)
   because the collapsed bar is still in the DOM at zero height (see above), so
   the head has nothing to clear then.
   Specificity: this has to beat elements.css's own `.table:has(>
   .table__toolbar).table--sticky-head .table__head`, and being linked later is
   not enough on its own — hence the toolbar :has() repeated here.
   The transition keeps the head's own offset moving with the bar's 0.2s open
   rather than jumping to its new position a frame before the bar fills it. */
.table--sticky-head .table__head {
  transition: top 0.24s cubic-bezier(0.32, 0.72, 0, 1);
}

/* ...AND IT HAS TO BE SAID AGAIN AT FOUR CLASSES (2026-09-08). The rule above was
   losing to this file's own `.shell--filters-push .page__body--full > .table > *
   { transition: margin-right 0.2s ease }` (see "THE RESERVATION" further up),
   which is one class more specific and replaces the whole shorthand rather than
   adding to it — so on any page inside the push shell the head had NO top
   transition at all and jumped its 44px in a single frame the moment a row was
   checked. Measured on orders.html: top went 57px to 101px between two
   consecutive animation frames.
   The fix is not to weaken that rule — the columns really do have to narrow with
   the band — but to restate the head's transition at the same weight and carry
   margin-right along in the list, so both animations survive. Same for the bar
   itself, right below.
   0.24s on .menu's easing rather than the old 0.2s linear-ish `ease`: the head is
   travelling under a bar that is arriving at the same moment, and a curve that
   settles late reads as the head being pushed rather than as two things that
   happen to move together. */
.shell--filters-push .page__body--full > .table.table--sticky-head > .table__head {
  transition:
    top 0.24s cubic-bezier(0.32, 0.72, 0, 1),
    margin-right 0.2s ease;
}

.table:has(> .table__toolbar):has(> .selection-bar:not(.selection-bar--hidden)).table--sticky-head .table__head {
  top: calc(
    var(--control-height) + var(--space-12) * 2 + 1px
    + var(--control-height-compact) + var(--space-8) * 2
  );
}

.selection-bar__count {
  margin-right: var(--space-24);
  /* --color-sidebar-on, not --color-on-accent (fixed 2026-09-02 with the Dark
     theme). The bar's fill IS --color-sidebar, as this section's own header says,
     so its ink is the rail's ink — the token added on 2026-08-31 for exactly the
     case where "the fill is the sidebar" and "the fill is an accent" stop being
     the same statement. Classic and Light resolve both to the same colour, so
     nothing showed; Dark is where they part, and on-accent there is a near-black
     ink meant for a light accent fill, which put #0a0a0a on #030303.
     NOW --color-selection-bar-on, which is that same reasoning one step further
     (2026-09-08): the ink has to follow the BAR's fill, and on Light the bar's fill
     and the rail's fill are no longer the same colour. The token resolves to
     --color-sidebar-on everywhere the two still agree. */
  color: var(--color-selection-bar-on);
  font: var(--weight-medium) var(--text-body-sm) var(--font-sans);
  white-space: nowrap;
}

/* The buttons' own row — 8px between each (2026-08-27, on request; was
   --space-4, which is an optical step for work INSIDE a control and read as
   three buttons welded into one segmented block rather than three separate
   actions). --space-24 still separates the count from this whole group. */
.selection-bar__actions {
  display: flex;
  align-items: center;
  gap: var(--space-8);
  flex-wrap: nowrap;
}

/* The trailing slot — pushed to the bar's far right, away from the action group
   on the left (2026-08-28, on the user's instruction). What goes here is the one
   bulk action that does NOT change the selected records: "Export selected".
   Two reasons it is worth a slot of its own rather than being the last button in
   .selection-bar__actions. It is the safe action in a bar whose other members
   include a destructive one, and putting a gap between them means the export is
   never the neighbour of a delete. And it lands in the same place in every bulk
   bar in the app, so it is found by position rather than by reading the row.
   See docs/tables.md, "Bulk actions". */
.selection-bar__end {
  display: flex;
  align-items: center;
  gap: var(--space-8);
  margin-left: auto;
}

/* Shaped like a compact .btn (2026-09-02, on the user's instruction: "make these
   buttons in the header use the same style as small buttons, with a stroke and
   drop shadow effect as well"). It was a flat white slab with `border: 0` — the
   one button in the app that dropped the stroke and the elevation every other
   button carries, which on the pale warning fill left it with no edge at all.
   Border and shadow are .btn's own two declarations, verbatim; the height,
   body-sm type and flex: none stay this element's. */
.selection-bar__btn {
  display: inline-flex;
  align-items: center;
  flex: none;
  height: var(--control-height-compact);
  padding: 0 var(--space-12);
  border: 1px solid var(--color-outline);
  border-radius: var(--radius-sm);
  background: var(--color-surface);
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-body-sm) var(--font-sans);
  white-space: nowrap;
  box-shadow: var(--elevation);
  cursor: pointer;
  transition: opacity 0.12s ease;
}

.selection-bar__btn:hover {
  opacity: 0.85;
}

.selection-bar__btn--danger {
  color: var(--color-error);
}

/* ------------------------------------------------------------------
   Toggle switch — a menu row that's an on/off setting, not an action. First
   need: the order-detail page's "Products" list settings menu (Detailed
   quantities / Stock locations / VAT and commission). No existing element
   covers this — .checkbox is a tick/indeterminate box, not a switch.
   Track/thumb width/height are literal px, same footing as .filter-drawer's
   own 312px above: a one-off outer dimension with no token to reference.
   Radius reuses --radius-full (fully round, same token badges/chips use for
   the same visual effect) rather than adding a scoped switch-radius token.
   ------------------------------------------------------------------ */
.menu__item--toggle {
  justify-content: space-between;
}

.toggle {
  position: relative;
  display: inline-flex;
  align-items: center;
  flex: none;
  width: 32px;
  height: 18px;
  padding: 2px;
  border-radius: var(--radius-full);
  background: var(--color-outline);
  transition: background 0.15s ease;
}

.toggle::before {
  content: "";
  width: 14px;
  height: 14px;
  border-radius: var(--radius-full);
  background: var(--color-surface);
  transition: transform 0.15s ease;
}

.toggle--on {
  background: var(--color-accent-primary);
}

.toggle--on::before {
  transform: translateX(14px);
}

/* ------------------------------------------------------------------
   Preview popover — the Orders table's Products column, where more than one
   line item collapses behind a qty chevron. Built on .menu's floating shape.
   ------------------------------------------------------------------ */
.preview-popover {
  /* 432, 16px wider than the 416 it carried until 2026-09-02 (on request, with
     the right padding below — the two are one change: the card grows by exactly
     the room the quantity's new gutter takes, so the product rows inside it are
     laid out on the same width as before). Same footing as the other one-off
     outer dimensions in this file: there is no token for "how wide is a
     popover". */
  min-width: 432px;
  padding: var(--space-8);
  /* Bigger than the .menu it's built on (a list of full product rows, not a
     handful of text items), so it needs the strongest of the system's
     elevation steps to read as clearly dominant over the table row — and
     everything else on the page — it floats over, not just lifted off it. */
  box-shadow: var(--elevation-xl);
  /* Above .table__toolbar (z-index: 2) and .table--sticky-head (z-index: 1),
     and above .menu's own default (60) — this popover must win over every
     other stacking context on the page, not just its own row. */
  z-index: 100;
}

/* align-items centers the name+codes block against the thumbnail's own
   height, instead of both starting at the same top edge. justify-content
   centers that image+text pair as a group within the row's own full-width
   box — this item is the widest thing .preview-popover lays out, so
   centering it here reads as centering it in the card itself. */
.preview-popover__item {
  display: flex;
  align-items: center;
  /* flex-start, not center (changed 2026-08-20). Centring each row independently
     was fine when a row was thumb + text: every row looked alike. It stopped being
     fine once the quantity moved to the front, because a row with a two-line name
     centres differently from one with a single line — so "3 x" and "1 x" no longer
     sat on the same left edge, and neither did the thumbnails. A leading quantity
     is a column, and a column has to line up. */
  justify-content: flex-start;
  gap: var(--space-12);
  /* --space-12 on both sides since 2026-09-01, when the quantity moved to the
     END of the row: both edges now carry a mark (thumbnail left, count right),
     so neither can keep the 4px gutter the empty side used to have.
     The RIGHT side went to --space-24 on 2026-09-02 (on request: "increasing the
     padding to the right of the values x3, x1"). The two sides are no longer
     equal on purpose — the left gutter is read against a thumbnail's own edge,
     the right one against a bare two-character value, and at 12px that value sat
     on the card's border. --space-24 rather than 12+16=28, which the request's
     arithmetic implies but the spacing scale has no step for; the card's extra
     16px covers the difference and then some. */
  padding: var(--space-8) var(--space-24) var(--space-8) var(--space-12);
}

/* Takes the row's free width, which is what pushes the quantity to the right
   edge. Added 2026-09-01 with that move; before it, the name/codes block was an
   unclassed <div> that only had to sit between two fixed-width marks. */
.preview-popover__main {
  flex: 1;
  min-width: 0;
}

/* How many of this product the order is for. The Products column's own number is
   the order's total UNITS, not its number of distinct products, so a "4" could
   open onto two rows and look wrong; these quantities are what reconcile the two.

   CLOSES the row and reads "x 2" (2026-09-01, on request). It led the row reading
   "2 x" from 2026-08-20 until then — the move follows the Create shipment dialog,
   where the same count is a stepper on the row's right edge, so a product reads
   the same way in both places. min-width keeps the counts on one right edge
   whether it is one digit or two. --weight-medium against the identifiers'
   regular, since it is a value rather than a label. */
.preview-popover__qty {
  flex: none;
  min-width: var(--space-24);
  text-align: right;
  /* --color-text-primary, not secondary (2026-08-20, on request): it is a value,
     and it was the one value in the row set below the weight of everything
     around it. It is also rendered ONLY when the popover has more than one line
     — reconciling the trigger's unit count against the row count is the whole
     reason it exists, and with a single product the trigger's number IS that
     product's quantity, so "1 x" only repeats it. See renderRow(). */
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-body-md) var(--font-sans);
}

.preview-popover__thumb {
  width: 48px;
  height: 48px;
  flex: none;
  border-radius: var(--radius-sm);
  object-fit: cover;
  display: block;
}

/* body-md, not body-sm — a product name here is the primary thing being
   identified in this popover, the same weight/size an order-detail line item's
   own name gets (.order-detail__item-name), not a secondary label. */
.preview-popover__name {
  color: var(--color-accent-primary);
  font: var(--weight-medium) var(--text-body-md) var(--font-sans);
  cursor: pointer;
}

/* GTIN over MPN, stacked (2026-08-20; they sat side by side before, which is why
   the popover was widened to 416px at the time). One per line reads as a list of
   the product's identifiers rather than as a single run-on cluster, and it keeps
   each pill's own left edge aligned under the name above it.
   --space-4, the optical step: these are two lines of one thing, not two blocks. */
.preview-popover__codes {
  display: flex;
  flex-direction: column;
  align-items: flex-start;
  /* --space-8 (2026-08-20, on request — was --space-4): the pills carry their own
     vertical padding, so 4px between two filled boxes read as almost touching even
     though the boxes themselves were a step apart. */
  gap: var(--space-8);
  margin-top: var(--space-4);
}

/* elements.css zeroes the second identifier's left margin via
   `.identifier + .identifier`, to stop two SIDE-BY-SIDE pills' -4px bleeds
   cancelling the gap between them. Its own comment says it is not meant for the
   stacked case — which it dodges because .identifier-stack wraps each row, so the
   pills are never direct siblings there. These two are, now that they are stacked,
   so the rule fires and steps the MPN pill 4px right of the GTIN above it.
   Restoring the bleed puts both left edges back on one line. */
.preview-popover__codes .identifier + .identifier {
  margin-left: calc(var(--space-4) * -1);
}

/* Rows where identifiers sit SIDE BY SIDE: reserve the copy icon's slot at rest and
   reveal it with opacity alone. .identifier__copy's shared behaviour (elements.css)
   collapses the icon to width:0 and animates the width open on hover — fine for a
   lone identifier with nothing to its right, but wrong on a shared line: in the
   product peek GTIN, MPN and Price sit on one flex row, so growing the hovered pill
   pushed everything after it sideways and sweeping the pointer along made the row
   jitter continuously. Reserving the width means the pill's box never changes size,
   so nothing moves. The icon still fades in on hover exactly as before — the shared
   hover rule sets the same width/margin this does, leaving only opacity to animate.
   Scoped deliberately: collapsed-at-rest was ratified 2026-08-18 (see
   .identifier__copy's own comment) and is not changed for identifiers at large.

   .preview-popover__codes was in this list and came OUT (2026-08-21, on request).
   It was added while that popover ran GTIN and MPN side by side on one line; they
   have been STACKED one per line since 2026-08-20, so there is nothing to the right
   of either pill for a hover to push any more and the reservation was buying
   stillness that no longer had to be bought — it just held the pills permanently
   wider than their contents. They use the default identifier now. */
.product-peek__meta .identifier__copy {
  width: var(--icon-size-identifier);
  margin-left: 0;
}

.preview-popover__name:hover {
  text-decoration: underline;
}

/* ------------------------------------------------------------------
   Badge trigger — a status pill that opens something, rather than just
   reporting state. Composed ON .badge (`class="badge badge--info badge-trigger"`),
   so fill, radius, height and type all still come from the ratified element and
   this only adds the affordance: a chevron inside the pill, a pointer cursor and
   a hover state. Proposed 2026-08-19 for Order details' Products table, where the
   line's status pill now discloses its fulfilment breakdown (.fulfillment-popover
   below) instead of that breakdown occupying four permanent columns.
   NOT ratified — .badge is documented as a passive status mark, and making one
   interactive is exactly the kind of change that needs sign-off. Explicitly
   flagged as a try-it-out (may be reverted).
   The chevron is a plain 16px --icon-size, the only general icon size the system
   has; in a 20px pill that reads chunky. A smaller general step would be a new
   token, so it is a question rather than something set here (--icon-size-identifier
   is scoped to .identifier's copy icon and off-limits).
   ------------------------------------------------------------------ */
.badge-trigger {
  border: 0;
  cursor: pointer;
  /* .badge sets its own padding; a <button> would otherwise add the UA's. */
  padding: 0 var(--space-8);
  font: var(--weight-medium) var(--text-body-sm) var(--font-sans);
  transition: filter 80ms ease;
}

/* Darkens whatever tint .badge--* gave it, rather than naming a per-tone hover
   colour — the system has no hover pair for the status tints, and inventing four
   would be four new tokens.
   --hover-brightness, not the literal 0.95 it was until 2026-09-02: the Dark theme
   inverts the tints (they are dark fills under near-white type there), so darkening
   them on hover moves toward the page instead of away from it. The token is 0.95 at
   :root and 1.18 under Dark — the same size of step, the other way. See tokens.css. */
.badge-trigger:hover {
  filter: brightness(var(--hover-brightness));
}

.badge-trigger:focus-visible {
  outline: 2px solid var(--color-accent-secondary);
  outline-offset: 1px;
}

/* ------------------------------------------------------------------
   Flag circle — the country flag inside .badge--logo, sat on its own round
   --color-background disc instead of floating bare on the pill's white fill.
   Composed ON the ratified .badge__flag (elements.css): the disc is a new
   wrapper element, the flag keeps its own class, its 5:4 ratio and its
   --radius-flag corners — this adds the disc and re-sizes the flag to fit it,
   nothing else. Opt-in: a .badge--logo without the wrapper is unchanged.

   24px is a literal, like .badge__flag's own 12x15 and .badge--logo img's 14/18
   heights right beside it — a mark's own dimension, not spacing, and the system
   tokenises neither. It fits the 28px --lg pill the Orders Channel column uses
   with 2px above and below; it is taller than a default 20px badge outright, so
   this variant is --lg only until there's a smaller disc size to ask about.

   At 24px the flag needs no resizing: .badge__flag's ratified 15x12 measures
   19.2px corner to corner, comfortably inside a 24px circle, leaving a 4.5px
   --background ring at the sides and 6px above and below. So the flag here is
   exactly the ratified element, untouched — this adds only the disc. (At the
   18px disc this started as, 15x12's corners overshot the edge and the flag had
   to be scaled to 12.5x10; 24px removes that compromise.)
   ------------------------------------------------------------------ */
.badge__flag-circle {
  width: 24px;
  height: 24px;
  flex: none;
  display: inline-flex;
  align-items: center;
  justify-content: center;
  border-radius: var(--radius-full);
  background: var(--color-background);
}


/* The disc reads as belonging to the logo, so it sits --space-2 after it rather
   than pinned to the pill's right edge — which is what .badge--logo's own
   justify-content: space-between does, and what docs/elements.md's "always
   exactly 8px from the pill's right edge" describes. Scoped to :has(), so only
   a pill using the disc changes; a bare .badge__flag still pins right.
   In the Orders table, where every pill is widened to one shared column width,
   this leaves the spare width as trailing space after the pair instead of
   splitting it between logo and flag. */
.badge--logo:has(.badge__flag-circle) {
  justify-content: flex-start;
  gap: var(--space-2);
}

/* ------------------------------------------------------------------
   Per-asset logo nudge — amazonNL.png only.
   Amazon's wordmark sits high in its own frame: the smile/arrow swoops below
   the baseline, so the artwork's optical centre is ~2px above the file's
   geometric centre. .badge--logo centres the FILE, which lands the mark high
   against every other channel's logo on the same line. 2px down puts it back.

   A per-asset correction, not a system rule — nothing else needs it, and the
   right permanent fix is re-exporting the asset with even padding, at which
   point this rule and its row in docs/proposals.md both go. It lives here
   rather than in a page's own <style> because three surfaces use the same pill
   (Orders' table and Channel row, the dashboard's Channels list, Products'
   preview menu, which carries its own copy on .preview-menu__logo--amazon-nl
   for a mark that is not in a .badge--logo at all), and one per-asset rule
   copied into three <style> blocks is two places too many to keep in step.
   Restored 2026-09-03: orders.html's comment said this had moved here on
   2026-08-21, but the rule itself never landed, so the class it emits was
   styling nothing and the Amazon mark had been sitting high since.
   transform, not margin/position: it must not change the pill's layout, only
   where the ink falls inside it.
   ------------------------------------------------------------------ */
.channel-logo--amazon-nl {
  transform: translateY(2px);
}

/* ------------------------------------------------------------------
   Fulfilment popover — the four quantity buckets (Shipped, Open, Canceled,
   Returned) that used to be four columns of the Order details Products table,
   shown as label-over-value pairs instead of a table. Opened from the row's own
   .badge-trigger above. Built on .menu's floating shape, same as
   .preview-popover, and borrows that element's elevation/z-index reasoning: it
   floats over a table row and has to read as clearly above it.
   position: fixed, not .menu's own absolute — .order-detail__products-scroll is
   an overflow-x: auto scroller, which clips absolutely positioned descendants,
   so orders.html sets top/left from the trigger's own rect on open.
   ------------------------------------------------------------------ */
.fulfillment-popover {
  position: fixed;
  /* --space-16, not .menu's own --space-4 or the --space-12 this started at: the
     content is four label/value pairs reading as a small card, not a list of menu
     rows that each carry their own padding. */
  padding: var(--space-16);
  box-shadow: var(--elevation-xl);
  z-index: 100;
}

.fulfillment-popover__grid {
  display: grid;
  grid-template-columns: repeat(4, max-content);
  gap: var(--space-24);
}

/* Label over value, --space-2 apart — the same stacking .table__lines uses for a
   muted label above its value (elements.css), which is the system's existing
   precedent for this pair rather than a new spacing decision. */
.fulfillment-popover__item {
  display: flex;
  flex-direction: column;
  gap: var(--space-2);
}

.fulfillment-popover__label {
  color: var(--color-text-secondary);
  font: var(--weight-regular) var(--text-body-sm) var(--font-sans);
  white-space: nowrap;
}

.fulfillment-popover__value {
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-body-md) var(--font-sans);
}

/* ------------------------------------------------------------------
   Empty state — lifted from prototypes/empty-state/index.html, which built it
   local to that one page and flagged it as liftable: "NOT SYSTEM YET... built
   here from tokens only, so it can be lifted into the system unchanged if it is
   adopted." A second, unrelated page needing the identical shape (see
   .unbuilt-notice below) is that adoption trigger. Definition unchanged from
   the original; only the location moved.
   ------------------------------------------------------------------ */
.empty-state {
  min-height: 100%;
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  gap: var(--space-8);
  text-align: center;
  padding: var(--space-64) var(--page-gutter);
  box-sizing: border-box;
}

.empty-state__mark {
  display: flex;
  align-items: center;
  justify-content: center;
  width: 48px;
  height: 48px;
  margin-bottom: var(--space-8);
  border: 1px solid var(--color-outline);
  border-radius: var(--radius-md);
  background: var(--color-surface);
  color: var(--color-text-secondary);
}

.empty-state__mark .icon {
  width: 24px;
  height: 24px;
}

.empty-state__title {
  margin: 0;
  font: var(--weight-medium) var(--text-heading) var(--font-sans);
}

.empty-state__body {
  margin: 0;
  max-width: 44ch;
  font: var(--weight-regular) var(--text-body-md) var(--font-sans);
  color: var(--color-text-secondary);
}

.empty-state__actions {
  display: flex;
  align-items: center;
  gap: var(--space-8);
  margin-top: var(--space-8);
}

/* ------------------------------------------------------------------
   Large identifier — .identifier at body-md instead of the default
   --text-identifier (13px). Same --tracking-identifier letter-spacing as the
   default: this is still an identifier, just sized up, not a different kind
   of text. Weight stays regular on both label and value — CLAUDE.md: "there
   is no medium-weight identifier" — .identifier--lg doesn't get an exception.
   ------------------------------------------------------------------ */
.identifier--lg .identifier__label,
.identifier--lg .identifier__value {
  font: var(--weight-regular) var(--text-body-md) var(--font-sans);
  letter-spacing: var(--tracking-identifier);
}

/* ------------------------------------------------------------------
   Copyable text value — .identifier's copy micro-interaction on a value that
   is PROSE, not a code: a buyer's email, phone and the two addresses on Order
   details (2026-09-03, request: "add the little copy icon micro interaction
   in line with address and buyer details as well").

   Why a modifier on .identifier rather than a new .copyable block: the whole
   point is that copying feels the same everywhere, and the hover reveal, the
   checkmark swap and the 500ms fade all live on .identifier__copy /
   .identifier--copied in elements.css. Reusing the markup means
   mountIdentifiers() binds these for free and there is no second copy of the
   animation to drift. What this modifier undoes is only the TYPOGRAPHY, which
   is the one part of .identifier that is about digit strings:
   --text-identifier, --tracking-identifier and tabular figures make an email
   read like a serial number.

   No resting pill, unlike .identifier (ratified 2026-08-18). That fill exists
   to mark a code as copyable among surrounding prose; here the value IS the
   prose and its .card__row-label already names it, so a grey pill on four of a
   card's five rows reads as five input fields. It comes in on hover at the
   same 80ms instead — the affordance still arrives before the click.

   Wrapping, not ellipsis: an address is two or three lines separated by <br>,
   so the value has to be allowed to break. align-items: flex-start then keeps
   the icon on line one; --space-4 of margin-top centres a 12px
   --icon-size-identifier glyph on a 20px body-md line ((20-12)/2), which is
   also exactly where centring puts it on a one-line value.
   ------------------------------------------------------------------ */
.identifier--text {
  align-items: flex-start;
  background: transparent;
}

.identifier--text:hover,
.identifier--text:focus-visible {
  background: var(--color-background);
}

.identifier--text .identifier__value {
  font: var(--weight-regular) var(--text-body-md) var(--font-sans);
  letter-spacing: normal;
  font-variant-numeric: normal;
  overflow: visible;
  text-overflow: clip;
  white-space: normal;
  /* white-space: normal only breaks at SPACES, and the two values that most often
     land here have none — an email address and a street line joined by dots and
     punctuation. In the buyer dialog, which is wide, that never showed; in the
     buyer-details card on the order page (orders.html, buyerTopHtml, 2026-09-10) the
     value column is a third of a 1fr grid column and "soraya.aranda@example.com" ran
     straight through the row's own pencil button.
     This is the same failure .card__row-value's own overflow-wrap note in
     elements.css describes, one level in: min-width: 0 lets the COLUMN shrink, and
     something still has to let the WORD break once it has. Only ever acts when the
     fragment genuinely does not fit, so nothing wider than its content changes.
     ANYWHERE, NOT break-word, AND THAT IS THE WHOLE FIX — break-word was tried
     first and changed nothing, measurably: the value box stayed 208px inside a
     120px column. The two keywords differ in exactly the way that matters here.
     break-word lets a long word break while the box is being LAID OUT, but it does
     not reduce the box's intrinsic min-content width; `anywhere` does. And the box
     around this one is .identifier, an inline-flex (elements.css) whose width comes
     from shrink-to-fit — an INTRINSIC sizing pass. So with break-word the identifier
     kept asking for the whole email, got it, and overflowed the grid cell into the
     row's pencil button; with `anywhere` its min-content collapses and it fits.
     min-width: 0 belongs with it: this element is a flex item of .identifier, and a
     flex item's automatic minimum size is its min-content. The wrapper's own
     min-width: 0 covers the wrapper, not its children — each flex level needs one. */
  min-width: 0;
  overflow-wrap: anywhere;
}

.identifier--text .identifier__copy {
  margin-top: var(--space-4);
}

/* ------------------------------------------------------------------
   Product peek — bottom sheet preview of a product, opened from an order's
   own line-item name (orders.html). Starts as a partial-height card over the
   dimmed order-detail page; scrolling inside it (either direction) grows or
   shrinks it, up to a capped near-full size. `top` is the only thing still
   driven by an inline style from JS as the user scrolls — a continuous 0..1
   progress value, not a fixed set of states to name. It never hands off to
   the product's real page and never goes full-bleed: width is capped to
   --page-width (below) and side/top insets plus corner radius stay constant
   at every progress value, so the dimmed backdrop is always visible around
   it and it always reads as a modal overlay, not a page underneath it.
   Closable via the X, Escape, or a backdrop click at any progress value.

   Confined to the content area right of the sidebar on the user's explicit
   instruction — at rest it must not cover the sidebar, and its own width
   matches a real page's own content width exactly, so it reads as a
   page-shaped card floating over the dimmed page rather than an arbitrary
   panel.
   THE DIM NO LONGER STOPS AT THE GLOBAL HEADER (2026-08-31, on request:
   "the overlay should cover the global header too, now it doesn't"). That
   instruction supersedes the earlier "below the global header" half of the
   one above; the sidebar half stands, so this still starts at
   --sidebar-width and only its `top` moved. See the rule itself.
   ------------------------------------------------------------------ */
.product-peek-overlay {
  position: fixed;
  /* 0, not --app-header-height (2026-08-31). The header is the one piece of
     chrome that stayed lit while the peek was open, which read as the peek
     being a panel WITHIN the page rather than something over it — and the
     header's controls are not reachable while the peek is up anyway, so
     leaving them undimmed advertised an interaction that does not exist.
     The sidebar is a different case and deliberately stays lit: it is the
     app's primary navigation and going somewhere else IS reachable from a
     peek, by clicking straight through to another section.
     This works without touching z-index because .app-header is a plain
     normal-flow box with no `position` and no z-index of its own
     (elements.css), so a positioned z-index: 200 layer paints over it. It
     also relies on no ancestor of this element carrying a transform, filter
     or will-change — any of those would make `fixed` resolve against that
     ancestor instead of the viewport, and this would stop reaching the top
     of the screen. .shell and .shell__main use flex and overflow only, and
     overflow alone does not do that. */
  top: 0;
  left: var(--sidebar-width);
  right: 0;
  bottom: 0;
  background: var(--color-overlay);
  opacity: 0;
  transition: opacity 0.15s ease;
  z-index: 200;
}

/* The fixed-position frame — pure positioning, no visible box of its own.
   `top` is set inline by JS as the user scrolls (setProductPeekProgress() in
   orders.html) rather than a `height` here, so the card's top edge can grow
   toward (not all the way to) the header's own bottom edge. left+right both
   set (rather than a width) makes this element's OWN resolved width exactly
   the sidebar-to-viewport-edge span in pixels — the containing block
   .product-peek's percentage max-width below resolves against. */
.product-peek-frame {
  position: fixed;
  /* Same rail edge as .product-peek-overlay above, and it has to be the same
     one: left+right here resolve this element's own width, which
     .product-peek's percentage max-width is measured against. */
  left: var(--sidebar-width);
  right: 0;
  bottom: 0;
  z-index: 201;
  /* Entrance only, bottom to top, under 300ms — the standard a drawer opens
     with everywhere in the app. transform, not `top` (still the one JS sets
     per-frame as the order-detail peek's own wheel-driven expand runs, see
     orders.html's setProductPeekProgress) — animating a different property
     means the drag stays instant and this only ever plays once, on open. No
     matching close animation: every peek/drawer in the app still hides
     instantly on close, only the open gets this. */
  transform: translateY(100%);
  transition: transform 280ms ease;
}

.product-peek-frame--open {
  transform: translateY(0);
}

/* Capped to --page-width and centred within .product-peek-frame's own pixel
   width, the same way .page-header__row/.page__body cap and centre within
   their own full-bleed page — this only resolves to the same pixel width a
   real page's content uses because it's a normal-flow child of a
   pixel-width frame, not itself position:fixed (a percentage max-width on a
   fixed element resolves against the viewport instead, which is wider than
   the space right of the sidebar and would make this modal wider than a
   real page's own content). */
.product-peek {
  position: relative;
  height: 100%;
  /* Widens as the sheet is scrolled up (2026-09-04, on request: "enlarge its
     width to fill in the space between the side bar and rest of page width").
     --peek-progress is the same continuous 0..1 the sheet's `top` already runs
     on, set per wheel event by orders.html's setProductPeekProgress; CSS does
     the interpolation so there is no second animation to keep in sync and no
     transition to fight the drag — width tracks the pointer exactly as the
     height does.

     Both ends resolve against .product-peek-frame's own pixel width (the
     sidebar-to-viewport-edge span). At rest the sheet is exactly as wide as a
     real page's content (--page-width, 80%); fully expanded it stops
     --space-24 short of the frame on each side rather than filling it edge to
     edge (2026-09-04, on request) — the sheet is a card floating over a dimmed
     page, and a card that runs into the sidebar and the window edge stops
     reading as one. The gutter is the same --space-24 the body already uses
     inside the card, so the expanded sheet sits on the page's own rhythm.

     Falls back to 0 — a sheet built on this shell that never sets the variable
     stays capped at --page-width, which is what it did before this existed.

     max-width rather than width because the `width: 100%` below still has to
     be what makes a narrow window collapse this gracefully. */
  max-width: calc(
    var(--page-width) +
      (100% - var(--space-24) * 2 - var(--page-width)) * var(--peek-progress, 0)
  );
  width: 100%;
  margin: 0 auto;
  display: flex;
  flex-direction: column;
  background: var(--color-background);
  border-top: 1px solid var(--color-outline);
  /* Constant at every progress value (never interpolated toward 0 — see
     orders.html's setProductPeekProgress) — plain CSS rather than a JS-set
     inline style, so every sheet built on this shell (order-detail's product
     peek, products.html's section peek) gets it without re-setting it. */
  border-top-left-radius: var(--radius-lg);
  border-top-right-radius: var(--radius-lg);
  box-shadow: var(--elevation-xl);
  overflow: hidden;
}

/* The default: a peek with no header of its own floats the close button over
   its body's top-right corner. products.html's section peek is still built
   this way. The order-detail peek overrides it below, having gained a real
   header 2026-09-04. */
.product-peek__close {
  position: absolute;
  top: var(--space-16);
  right: var(--space-16);
  z-index: 1;
}

/* Sticky header (2026-09-04, on request: "only keep the modal header sticky").
   Sticky by construction rather than by `position: sticky` — .product-peek is
   already a flex column, so a non-shrinking first child stays put while the
   body beside it is the only thing that scrolls. That also means the header
   never overlaps its own content the way a sticky-positioned bar does, and
   there is no z-index to manage against the card's `overflow: hidden`.

   Bottom border rather than a shadow: it has to read as an edge the moment
   content passes under it, and the card already carries --elevation-xl for
   its own lift — a second shadow inside it reads as a seam.

   The divider is HIDDEN AT REST (2026-09-04, on request: "don't show the modal
   header divider unless I start scrolling into it"). Unscrolled, nothing has
   gone under the header, so there is no edge to mark and a line there just
   cuts the sheet in two below a mostly empty bar. It appears the moment the
   body leaves its top — the line's whole job is to say "there is content above
   this fold", which is only true once there is.

   `transparent` rather than removing the border: the 1px box stays in the
   layout at every state, so the body below it never shifts by a pixel when the
   line arrives. Same reason .product-peek__heading fades instead of toggling
   display. */
.product-peek__header {
  /* OUT OF FLOW (2026-09-04, on request: "move this higher up by default, to
     take up the header space when the page is not yet scrolled"). At rest the
     header is an empty transparent bar — only the close button is in it, since
     the name does not appear until scroll — so as a flex child it was reserving
     ~64px of dead space and pushing the summary down the card. Absolute over
     the body instead: unscrolled, the summary starts at the very top of the
     sheet and the close button floats above it; scrolled, this goes opaque and
     becomes the bar content passes under. Nothing about the body's own layout
     changes between the two states, so there is no jump at the first pixel of
     scroll — only this element's paint.
     .product-peek is already position: relative with overflow: hidden, so this
     resolves against the card and is clipped by its rounded corners. */
  position: absolute;
  top: 0;
  left: 0;
  right: 0;
  z-index: 2;
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: var(--space-16);
  /* --space-16 on all four sides (2026-09-04). Went 24 -> 32 -> 16 on the side
     value across three passes the same day; 16 is the settled one. Matches
     .product-peek__body's own padding below — the header's title has to sit on
     the same left edge as the summary title that scrolls up to replace it, or
     the name visibly jumps sideways during the handover. */
  padding: var(--space-16);
  border-bottom: 1px solid transparent;
  /* Transparent at rest — an opaque bar here would hide the top of the summary
     it is now sitting on top of. It takes the sheet's own background only once
     there is content underneath to cover. */
  background: transparent;
  /* Lets wheel and clicks reach the summary underneath while this is an empty
     transparent bar; the close button opts back in below. Restored to auto when
     scrolled, where the bar is opaque and must not be clicked through. */
  pointer-events: none;
  transition: background-color 0.15s ease, border-color 0.15s ease;
}

/* Set by orders.html the moment .product-peek__body's scrollTop leaves 0.
   Deliberately a separate state from .product-peek__heading--visible: the name
   hands over when the summary's own title clears the header, which is much
   further down than the first pixel of scroll. The divider has to be there for
   all of that travel, not only once the name catches up. */
.product-peek__header--scrolled {
  background: var(--color-background);
  /* NO DIVIDER (2026-09-05, request: header bottom dividers off every dialog
     surface, this one included, "so it's almost consistent"). The 1px transparent
     box on .product-peek__header stays — it is what keeps the body from shifting a
     pixel between the two states — so only the colour is withheld here, and putting
     the line back is a one-property change. What is lost, stated because it is
     real: the opaque fill is now the only thing marking content passing under the
     bar, which reads on a white-on-white sheet only because the fill is
     --color-background against the card's own --color-surface. */
  pointer-events: auto;
}

/* The product name, top left. --text-heading-xl on the user's explicit call
   (2026-09-04) — a step below the --text-heading-2xl a real page title takes,
   which is the same step down order detail's own title makes for the same
   reason: this is a heading inside a sheet, not the page's own.

   HIDDEN AT REST, revealed on scroll (also on request). The name's real home
   is the summary block at the top of the body, above the GTIN and MPN and
   beside the thumbnail — that is the structure the sheet opens with, and a
   name in the header at the same time would be the same title twice, 16px
   apart. It fades in only once the summary's own copy has scrolled out of
   view, so the header picks the name up exactly as the body drops it.

   Kept in the flow (opacity, not display or visibility) so the header never
   changes height and the close button never shifts. aria-hidden is set with
   it in orders.html — a screen reader should not read a title that is
   visually absent, and the summary's own <h2> is the one in the accessibility
   tree at rest. */
.product-peek__heading {
  margin: 0;
  min-width: 0;
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-heading-xl) var(--font-sans);
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
  opacity: 0;
  /* Rises the last few pixels as it fades, so it reads as the name arriving
     from the body below rather than a label blinking on. */
  transform: translateY(var(--space-4));
  transition: opacity 0.15s ease, transform 0.15s ease;
}

.product-peek__heading--visible {
  opacity: 1;
  transform: translateY(0);
}

/* Back into the flex row — the absolute rule above is for the header-less
   peeks, and inside a header the button is just the row's last item.
   pointer-events restored: the header itself is click-through at rest, but the
   close button inside it must be clickable at every scroll position. */
.product-peek__header .product-peek__close {
  position: static;
  flex: none;
  pointer-events: auto;
}

/* Flat --space-16 on every side (2026-09-04) — one inner padding for the whole
   sheet, header included, rather than a header inset and a body inset that
   happen to differ. .product-peek is already capped to --page-width (above), so
   the thumb sits exactly --space-16 from the modal's own left edge; no second
   nested cap needed in here. .product-peek__header repeats the same value, so
   the two titles share a left edge across the scroll handover.
   flex: 1 + min-height: 0 make this the card's only scroll container: without
   the min-height a flex item floors at its content's height and the card grows
   past the frame instead of the body scrolling inside it. */
.product-peek__body {
  flex: 1;
  min-height: 0;
  padding: var(--space-16);
  overflow-y: auto;
}

/* Right inset the width of the floating close button plus a gap — at rest the
   header is transparent and overlapping this block, so a long product name would
   otherwise run under the X. One-off dimension derived from --control-height,
   not a token. */
.product-peek__summary {
  padding-right: calc(var(--control-height) + var(--space-16));
  display: flex;
  align-items: center;
  gap: var(--space-16);
}

.product-peek__thumb {
  width: 6.875rem;
  height: 6.875rem;
  flex: none;
  border: 1px solid var(--color-outline);
  border-radius: var(--radius-sm);
  object-fit: cover;
  background: var(--color-background);
}

.product-peek__main {
  display: flex;
  flex-direction: column;
  gap: var(--space-8);
  min-width: 0;
}

.product-peek__title {
  margin: 0;
  font: var(--weight-medium) var(--text-heading-2xl) var(--font-sans);
  color: var(--color-text-primary);
}

.product-peek__meta {
  display: flex;
  align-items: center;
  gap: var(--space-8);
}

.product-peek__meta .product-card__stat {
  font: var(--weight-regular) var(--text-body-sm) var(--font-sans);
}

.product-peek__meta .product-card__stat-value {
  font: var(--weight-medium) var(--text-body-sm) var(--font-sans);
}

/* Body sections (2026-09-04) — the peek's body was a single summary block, so
   there was nothing below the fold to scroll to once the sheet expanded.
   Containers, not bare stacked text (on request): each section is a ratified
   .card from elements.css, so nothing new is invented for it here and they
   pick up the card outline and radius every other panel in the app uses. This
   rule is only the stack they sit in. */
.product-peek__sections {
  display: flex;
  flex-direction: column;
  gap: var(--space-16);
  margin-top: var(--space-24);
}

.product-peek__text {
  margin: 0;
  max-width: 68ch;
  color: var(--color-text-secondary);
  font: var(--weight-regular) var(--text-body-md) var(--font-sans);
}

/* Reserved space in the sections that have a header but no content yet
   (2026-09-04, on request: "just keep their headers and current height but no
   body text yet"). An empty card would collapse to its title, and the whole
   point of these is that the sheet has a page's worth of height to scroll
   through — so the space its future content will occupy is held open now.
   6.25rem is five lines of --text-body-md's 20px box: a one-off dimension of
   the same kind as .dialog's own 26rem width, deliberately NOT a token, since
   it disappears the moment real content lands here. */
.product-peek__placeholder {
  min-height: 6.25rem;
}

/* End-of-content marker. Centred and secondary so it reads as a boundary the
   page is telling you about, not as one more section with something in it. */
.product-peek__end {
  margin: 0;
  padding: var(--space-32) 0 var(--space-16);
  text-align: center;
  color: var(--color-text-secondary);
  font: var(--weight-regular) var(--text-body-sm) var(--font-sans);
}

/* --------------------------------------------------------------------------
   Dashboard — home. Figma "CE-Refresh — Design explorations" node 808:10598,
   the only Home content nominated so far. Only the Channels and Actions
   containers are built (docs/proposals.md).

   Tabular figures (2026-08-21): every figure below that sits in a column with
   other figures carries font-variant-numeric: tabular-nums — the revenue
   list, the channel amounts and trends, the KPI values, the source counts.
   Same reasoning as .identifier__value in elements.css, and see CLAUDE.md,
   Foundations. Deliberately NOT on the rows' prose (e.g.
   .dashboard-action-row__subtitle, "25 products • CDON"), where a padded 1
   reads as a gap mid-sentence. No fallback is written for it: a typeface
   whose file carries no `tnum` feature ignores the declaration and keeps its
   proportional figures, which is exactly the wanted behaviour.
   -------------------------------------------------------------------------- */

/* Total revenue — Figma node 2039:8937. The stat fans out via a dotted
   connector to 5 top-channel cards. Capped and centred at 75% of the
   viewport width — scoped to this element alone, not the page__body--full
   Channels/Actions grid below it. */
.dashboard-revenue {
  display: flex;
  align-items: center;
  gap: var(--space-24);
  max-width: 75vw;
  margin: 0 auto var(--space-24);
}

/* Same label/value/range shape as the Products detail page header's
   "Completion score" stat (.product-detail-summary__completion,
   products.html): body-sm secondary label and range, --text-heading-2xl
   (the system's largest scale) for the number. No new type styles. */
.dashboard-summary {
  display: flex;
  flex-direction: column;
  gap: var(--space-4);
  flex: none;
}

.dashboard-summary__label,
.dashboard-summary__range {
  color: var(--color-text-secondary);
  font: var(--weight-regular) var(--text-body-sm) var(--font-sans);
}

.dashboard-summary__value {
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-heading-2xl) var(--font-sans);
  font-variant-numeric: tabular-nums;
}

/* Shared date-range label — body-sm/secondary, per the user's explicit
   instruction. Used at the top right of all 3 dashboard-kpis cards
   (.dashboard-kpis__cell-head, in line with each card's own title) and, in
   the Channels card, in line with the tabs on the right (only shown while
   the first tab is selected — see the JS that toggles [hidden] on it). One
   shared class rather than a near-duplicate per context, since it's the
   exact same look everywhere it appears. */
.dashboard-date {
  color: var(--color-text-secondary);
  font: var(--weight-regular) var(--text-body-sm) var(--font-sans);
}

.dashboard-kpis__cell-head {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: var(--space-16);
}

/* Total revenue / Orders / Returns — equal-split KPI row, replacing
   .dashboard-revenue above for now (hidden, not deleted). Left half is
   Total revenue (.dashboard-summary, reused as-is); right half splits again,
   equally, into Orders on top and Returns on bottom. Each cell is a real
   .card (border/radius/padding/surface from elements.css) — plain text
   floating on the page background read as unfinished, per the user's
   explicit follow-up. */
.dashboard-kpis {
  display: flex;
  gap: var(--space-8);
  margin-bottom: var(--space-8);
}

.dashboard-kpis__cell--left,
.dashboard-kpis__right {
  flex: 1;
  min-width: 0;
}

.dashboard-kpis__right {
  display: flex;
  flex-direction: column;
  gap: var(--space-8);
}

/* .card (elements.css) already supplies display:flex/flex-direction:column/
   gap/padding/border/radius/background — flex:1 here is only to stretch
   Orders and Returns to equal height inside .dashboard-kpis__right's own
   flex-column. */
.dashboard-kpis__right .dashboard-kpis__cell {
  flex: 1;
}

.dashboard-kpis__stats {
  display: flex;
  gap: var(--space-24);
}

/* Same font declarations as .dashboard-revenue-card__stat-value/-label
   (this file, below) — a new class rather than reusing that one directly,
   since its own width: 2.75rem is sized for a narrow card column, not a
   2-up KPI row here. Not a new type style either way. */
.dashboard-kpis__stat {
  display: flex;
  flex-direction: column;
  gap: var(--space-4);
}

.dashboard-kpis__stat-value {
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-body-md) var(--font-sans);
  font-variant-numeric: tabular-nums;
}

.dashboard-kpis__stat-label {
  color: var(--color-text-secondary);
  font: var(--weight-regular) var(--text-body-sm) var(--font-sans);
}

/* Dotted fan — a plain SVG approximation of Figma's bezier vectors, not a
   literal port (see the HTML comment above this markup). Height is fixed
   (5 cards × 3.5rem + 4 gaps × --space-12 = 20.5rem) so the viewBox's y
   coordinates line up with the cards column's actual row centres regardless
   of how wide this flexes.
   margin-right cancels .dashboard-revenue's own flex gap on this one side —
   the lines should touch the cards column with no visible gap (each card's
   own ::before dot marks where the line actually ends), while the gap
   before the connector (next to the stat) stays the full --space-24. */
.dashboard-revenue__connector {
  position: relative;
  flex: 1;
  min-width: 3rem;
  height: 20.5rem;
  margin-right: calc(-1 * var(--space-24));
}

.dashboard-revenue__connector svg {
  display: block;
  width: 100%;
  height: 100%;
}

.dashboard-revenue__connector path {
  fill: none;
  /* Closest existing token to Figma's Blue/B40 (#77bff8), which isn't
     itself in tokens.css — not a new colour. */
  stroke: var(--color-info);
  stroke-width: 1.5;
  stroke-linecap: round;
  stroke-dasharray: 1 6;
  /* Without this, the viewBox's non-uniform scale (100 units wide,
     preserveAspectRatio="none", stretched over a much wider flexible box)
     stretches the stroke/dash pattern horizontally along with the path
     shape — round dots become long streaks. non-scaling-stroke renders the
     stroke in screen pixels, independent of that transform, so the dashes
     stay round dots no matter how wide the connector flexes. */
  vector-effect: non-scaling-stroke;
}

.dashboard-revenue__dot {
  position: absolute;
  left: 0;
  top: 50%;
  width: 8px;
  height: 8px;
  margin-top: -4px;
  border-radius: var(--radius-full);
  background: var(--color-info);
}

/* No fixed width — sized to its widest card's content now that a card only
   holds a logo and two stats (no thumbnail/name to justify a wider, fixed
   column). */
.dashboard-revenue__cards {
  display: flex;
  flex-direction: column;
  gap: var(--space-12);
  flex: none;
}

.dashboard-revenue-card {
  position: relative;
  display: flex;
  align-items: center;
  gap: var(--space-12);
  width: 16rem;
  height: 3.5rem;
  padding: 0 var(--space-12);
  /* Card outline at 8% black, not the general --color-outline (2026-08-25, on request). */
  /* 12% with every other card (2026-09-16) — see .card in elements.css. */
  border: 1px solid var(--color-outline-container);
  border-radius: var(--radius-sm);
  background: var(--color-surface);
}

/* Landing dot — half on the card, half on the connector, so each dashed
   line reads as ending AT the card rather than trailing off before it
   (the actual gap between connector and card is 0, see
   .dashboard-revenue__connector's own margin-right above; this dot is what
   makes that join legible). Anchored to the card itself rather than
   computed against the SVG's own coordinates, so it's always exactly at
   this card's vertical centre regardless of viewBox math. */
.dashboard-revenue-card::before {
  content: "";
  position: absolute;
  left: 0;
  top: 50%;
  width: 8px;
  height: 8px;
  transform: translate(-50%, -50%);
  border-radius: var(--radius-full);
  background: var(--color-info);
}

.dashboard-revenue-card__logo {
  flex: none;
  height: 16px;
  width: auto;
}

.dashboard-revenue-card__logo-text {
  flex: none;
  width: 3.5rem;
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-body-sm) var(--font-sans);
}

/* Value-over-label, same pairing the Channels list already uses for its own
   revenue figures (.dashboard-channel-row__amount-line/__trend, deleted in the
   2026-08-25 tile rebuild) — reused
   here rather than a new stat shape. */
.dashboard-revenue-card__stat {
  display: flex;
  flex-direction: column;
  flex: none;
  width: 2.75rem;
}

.dashboard-revenue-card__stat-value {
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-body-md) var(--font-sans);
  font-variant-numeric: tabular-nums;
}

.dashboard-revenue-card__stat-label {
  color: var(--color-text-secondary);
  font: var(--weight-regular) var(--text-body-sm) var(--font-sans);
}

/* 64px below the flow element, per an explicit follow-up — the only new rule
   the Activity/Channels row needed when it came back on 2026-08-21; the row
   itself, and its 40/60 split, are unchanged. --space-64 is the scale's top
   step, so this is a real step, not a doubled --space-32. */
/* General sibling, not adjacent: the hidden .dashboard-kpis row still sits
   between these two in the DOM, so `+` never matches. */
.dashboard-flow ~ .dashboard-grid {
  /* --space-48 (2026-08-25, on request: "add more space below this large
     element, to 48px"). 48 was not on the scale; --space-48 was added to
     tokens.css for it, on the user's explicit instruction and with the value
     they gave — not rounded to --space-32 and not written as a literal.

     NOTE this deliberately un-does the balance the previous value held. The
     comment that stood here explained 24 as matching the 24px ABOVE the flow —
     the flow's own --space-8 plus .page__body's 16px gutter — so the element sat
     centred in its band. At 48 below against 24 above it is no longer centred,
     which is what was asked for; the old symmetry is recorded here rather than
     silently lost, so raising the top gap to match is a one-line change to
     .dashboard-flow's margin-top if the balance is wanted back. */
  margin-top: var(--space-48);
}

/* 60/40 split, per the user's explicit instruction — was a flexible column
   plus a fixed 23rem one. Both sides keep minmax(0, ...) (not bare fr
   tracks): a grid item's default min-width is its content's min-content,
   which floors a track at whatever its widest content demands regardless of
   its fr share — the exact grid-blowout bug already hit and fixed once on
   the PDP's own 60/40 split.

   6fr THEN 4fr, KEYED TO CHANNELS/ACTIVITY BY NAME, NOT TO FIRST/SECOND SLOT
   (2026-09-10, on request: "channels to the left, activity, orders and
   shortcuts to the right" — "keep the ratio as they were before tho"). Two
   earlier swaps (dashboard.html's own comments above the markup) had this
   ratio riding along with whichever container sat first; this time the
   ratio was asked to stay put while only the order flipped, so the link
   between position and share is broken here. Reordering .dashboard-grid's
   two children again means swapping this declaration too — it will not
   follow on its own. */
.dashboard-grid {
  display: grid;
  grid-template-columns: minmax(0, 6fr) minmax(0, 4fr);
  gap: var(--space-8);
  align-items: start;
}

/* A grid item's default min-width is auto (= its content's min-content),
   which floors a track at whatever its widest content demands regardless of
   its own fr/px share — same bug class the PDP 60/40 split hit. Guarded up
   front here instead of discovering it the same way again. */
.dashboard-grid > * {
  min-width: 0;
}

/* This track holds three stacked containers (Activity, then Orders summary,
   then Shortcuts) rather than one, so they need a column wrapper — a third
   (or fourth) direct child of the grid would auto-place into a second ROW,
   which starts below the taller Channels card, not below Activity. It was
   the LEFT track until the 2026-09-10 swap put Channels ahead of it; the
   wrapping reason is unchanged by which side it sits on.
   align-self: stretch overrides .dashboard-grid's own align-items: start for
   this track only, so the column is as tall as the row (i.e. as tall as
   Channels) and the Orders card below can take the leftover height. */
.dashboard-grid__col {
  display: flex;
  flex-direction: column;
  gap: var(--space-8);
  align-self: stretch;
}

/* --------------------------------------------------------------------------
   Dashboard — Orders summary (Figma 2312:12819, 2026-09-10)

   REPLACES the Orders card that stood here — a title, "Last 7 days" and a
   single decorative stroke standing in for a trend. That card said the word
   "orders" and nothing else: the line had no axes, no scale and no series
   behind it, so the only readable content was its heading. This one answers
   the question the dashboard is opened for on a Monday — what happened while
   nobody was watching — with three counts of the weekend just gone (four until
   2026-09-10, when cancellations was dropped on request).

   THE SAME BAND ORDERS.HTML ALREADY CARRIES, in a card. .weekend-item there
   (that page's own <style>) is the row this is built from: a 24px
   --color-info-tint square with a lucide mark, then a count and its noun. The
   two are deliberately NOT one shared class — that one is a filter toggle with
   an --on state wired to the table under it, this one is a link to another
   page, and a class that has to be both is two elements sharing a name. The
   look is shared on purpose so the dashboard's summary and the list's own band
   read as the same object seen twice.

   The frame draws the head (title over "Weekend / 5-7 September") beside the
   four rows, which is the layout below. Its 14px labels, #141414 / #666 text
   and #c5e2fb squares are not literals here but --text-body-sm,
   --color-text-primary / --color-text-secondary and --color-info-tint, which
   hold exactly those values.
   -------------------------------------------------------------------------- */

/* CONTENT-HEIGHT, AND THE ABSORBER MOVED TO ACTIVITY ABOVE IT (2026-09-10: "don't
   change the orders summary height, you just changed it"). This card used to carry
   flex: 1 and take whatever height Activity left in the column — which meant its
   height was a function of how many rows Activity had, and removing Activity's
   fourth row on the same day grew this card by that row's height. Nothing about this
   card had changed; it was measuring the one above it.
   THE COLUMN STILL ENDS LEVEL WITH CHANNELS, which is what the flex: 1 was for.
   .dashboard-actions takes it now (below): the slack goes to the card whose own row
   count created it, so Activity's height tracks its list and this card's height
   tracks its own content — the frame's layout, at the size the frame draws it.
   WHAT IT COSTS: Activity can now have trailing space under its last row when the
   list is short. That is the more honest place for it — a list card with room to
   grow, rather than a fixed summary that silently resizes whenever a sibling
   changes. */
/* Takes the left column's spare height so the track ends level with Channels and
   .dashboard-shortcuts below stays content-height — the job .dashboard-orders-summary
   held until 2026-09-10 (see its note directly below for why it moved). The rows
   themselves stay content-height, so what grows is the card, not the list. */
.dashboard-actions {
  flex: 1;
  min-height: 0;
}

.dashboard-orders-summary {
  flex: none;
  /* .card is a flex column with a --space-16 gap; the frame's layout is a row
     of two, so the direction is overridden here and the gap is restated as a
     pair — 16 between the two when they stack, 24 between them side by side.
     WRAP, NOT A BREAKPOINT. The left column of the dashboard grid is 4fr of the
     page, so it is ~410px on a wide screen and well under 300 on a laptop. Side
     by side is the frame's layout and the right one while it fits; below that
     the head goes above the rows rather than the labels wrapping mid-phrase
     ("22 new / orders", which is what a grid did here first). min-width:
     max-content on the items is what forces the wrap instead of the squeeze —
     the rows refuse to shrink past their longest label, so the flex line breaks.
     No media query and no width literal: the card measures its own content. */
  display: flex;
  /* .card's own direction is column — this row has to say so explicitly. */
  flex-direction: row;
  flex-wrap: wrap;
  gap: var(--space-16) var(--space-24);
  align-items: start;
  align-content: start;
}

/* Title with the period under it. TAKES THE LEFTOVER WIDTH (flex: 1) rather
   than sizing to its own content, which is what pushes the four rows over to
   the card's right edge (2026-09-10, on request: "move the 4 items further to
   the right, much further to the right"). The rows keep their max-content
   min-width, so the head gets everything they do not need.
   --space-8 under the title (2026-09-10, on request). The stamp under it was
   briefly two rows, "Weekend" over the date at --space-4; it is one line again
   as of the same day ("make the second line actually a single line, 'Weekend
   (dot) 5-7 Sept.'"). THE CARD DOES NOT GET SHORTER FOR IT, which the request
   also asked for, and needs no rule: the three rows on the other side of the
   line are 88px of the card's 120 and the head has never been the taller of
   the two — losing a line of it changes where the head ends, not the card. */
.dashboard-orders-summary__head {
  display: flex;
  flex-direction: column;
  flex: 1 1 auto;
  gap: var(--space-8);
}


/* One line: "Weekend · 5-7 Sept." A middle dot rather than a comma or a dash —
   the two halves are a period NAMED and the same period DATED, which is an
   apposition, and the dot is the separator that says so without claiming a
   range (an en dash) or a list (a comma, already spoken for inside "5-7").
   Plain flow text, so it stays one line and wraps like a sentence if it ever
   has to; the two-row flex column it replaces is gone with it. */
.dashboard-orders-summary__period {
  margin: 0;
}

/* The date itself, tabular for the same reason the counts are. */
.dashboard-orders-summary__date {
  font-variant-numeric: tabular-nums;
}

.dashboard-orders-summary__items {
  display: flex;
  flex-direction: column;
  /* Content-width at the right end of the line — the head takes the slack now
     (2026-09-10), so these do not grow into it. min-width: max-content is what
     forces the card to wrap rather than squeeze; see the note on the card.
     Off that right end by a step rather than flush against it: --space-32 when
     the request was "move those 4 items a bit more to the left", now --space-24
     after "move the three items in the order summary a bit more to the right,
     like 8px" (2026-09-10). The 8px is the difference between the two steps, so
     the move stays on the scale instead of becoming 32 minus a literal.
     It is a margin on this column and not padding on the card, so the head keeps
     the full width and only the rows move; and it collapses out of the way when
     the card wraps and this column starts the line instead of ending it. */
  flex: 0 0 auto;
  min-width: max-content;
  margin-right: var(--space-24);
  /* --space-8 between rows: each row already carries 4px of its own padding
     top and bottom (the hover fill's shape), so the space between two labels
     reads as 16. */
  gap: var(--space-8);
}

/* One row. An <a> because Orders is a built destination — the same
   "only a built destination is clickable" line the channel tiles and the
   Shortcuts chips are on, landing on the other side of it. The whole row is
   the target, not just its text, per the foundations' clickable-region rule. */
.dashboard-orders-summary__item {
  display: flex;
  align-items: center;
  gap: var(--space-8);
  /* 4/12/4/4, exactly .weekend-item's own asymmetry and for its reason: the
     row starts with a filled square whose edge is already a hard boundary and
     ends in text that needs the room, so the two sides are not owed the same.
     The negative margins give the padding back to the layout, so the rows
     still start flush with the grid column's edge and the gap between them is
     measured between labels rather than between hover fills.
     EXCEPT ON THE LEFT, since 2026-09-10 ("move the 3 items 8px more to the
     right"): the left margin is +4px rather than -4px, which with the 4px
     padding puts the marks 8px in from the column edge instead of flush with
     it. The rows are therefore no longer aligned with the card title above
     them — indented under it, which is the ask. */
  padding: var(--space-4) var(--space-12) var(--space-4) var(--space-4);
  margin: calc(-1 * var(--space-4)) calc(-1 * var(--space-12))
          calc(-1 * var(--space-4)) var(--space-4);
  border-radius: var(--radius-sm);
  color: var(--color-text-primary);
  /* body-md, on request (2026-09-10) — and the size .weekend-item's own label
     carries in orders.html, so the two bands read at one weight as well as in
     one shape. The frame's 14px is overruled: it sets these against a 24px
     title, where here they sit beside --text-heading. */
  font: var(--weight-regular) var(--text-body-md) var(--font-sans);
  text-decoration: none;
  cursor: pointer;
  transition: background 150ms ease-in-out;
}

@media (prefers-reduced-motion: reduce) {
  .dashboard-orders-summary__item { transition: none; }
}

/* The square's own colour — hovering fills the row with the blue the mark was
   already carrying, and the mark disappears into it. Now --color-chip
   (2026-09-10, on request: "make the hover background the same colour"),
   following the mark down from --color-info-tint so that parity holds.
   IT WAS A DELIBERATELY FAINT HOVER, at ~1.03:1 on the white card: the row read as
   touched mainly by the mark's edge dissolving into the fill rather than by the wash
   itself, with the pointer and the focus ring carrying "this is a link".
   IT IS NOT FAINT ANY MORE, and not by a change here: --color-chip became #ecf5fe on
   2026-09-16 (tokens.css), so the same declaration is now ~1.10:1. The parity with the
   mark is what this rule is about and that still holds — both followed the token — but
   the wash now does real work.
   Departs from .weekend-item in orders.html, which keeps --color-info-tint for both —
   that band's rows are filter toggles whose state has to be visible after the pointer
   leaves, and a status-strength fill is a fair choice for that even now. */
.dashboard-orders-summary__item:hover {
  background: var(--color-chip);
}

.dashboard-orders-summary__item:focus-visible {
  outline: 2px solid var(--color-accent-secondary);
  outline-offset: 2px;
}

/* The frame's blue square, given the icon it was standing in for. One tint for
   every row, so the group reads as one summary rather than as three statuses
   competing for a colour. Radius steps down from the card's --radius-md.

   --color-chip, the lightest blue the system has (#f5fafe then, #ecf5fe since
   2026-09-16 — the mark and the row hover both follow the token), on request
   (2026-09-10: "make the background of the 3 items in the order summary
   lighter, use the lightest blue token"). Was --color-info-tint (#c5e2fb),
   which put three saturated squares down the left edge of a white card and
   read louder than the figures beside them. The icon keeps
   --color-text-primary, so the mark now carries its contrast in the glyph
   rather than in the fill. THE ROW HOVER FOLLOWED IT to the same token, on a
   follow-up the same day, so the mark still dissolves into the row it is
   hovered in — see that rule for what the fainter wash costs. */
.dashboard-orders-summary__mark {
  display: flex;
  align-items: center;
  justify-content: center;
  width: 24px;
  height: 24px;
  flex: none;
  border-radius: var(--radius-sm);
  background: var(--color-chip);
  color: var(--color-text-primary);
}

/* The count is a figure read down a column of others, so it is tabular — but
   only the number: "22 new orders" is prose, and a padded 1 inside a sentence
   reads as a gap (foundations, "Numbers"). Hence the span around the digits
   rather than the declaration on the row. */
.dashboard-orders-summary__count {
  font-variant-numeric: tabular-nums;
}

/* --------------------------------------------------------------------------
   Dashboard — Shortcuts (Figma 2296:34648, 2026-09-09)

   A card of chips, each one a destination. Third in the left column, under
   Orders: content-height, so .dashboard-orders keeps absorbing whatever the
   column has left.

   The frame draws 28px pills with a 4px radius, a #f5f5f5 fill and a 14px
   Medium label. Everything here except the radius is that, reached through
   tokens that happen to hold those values (--control-height-compact,
   --color-background, --text-body-sm) rather than through the numbers — so the
   chip follows a theme instead of pinning one, which is the whole difference in
   dark mode. The radius is the one place the reference is overruled:
   ce-ui's foundations say badges and chips are fully rounded, and 4px is
   neither a chip nor a button.
   -------------------------------------------------------------------------- */

/* Title and its + on one line — the same head shape .dashboard-channels__head
   uses for "Add channel", not a shared class: that one also carries a 16px gap
   for a much longer label, and two heads that happen to look alike are not one
   element. */
.dashboard-shortcuts__head {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: var(--space-8);
}

/* Wrapping rows of chips. The frame lays out two on the first row and one on
   the second, which is not a rule about those three strings — it is what fits
   in that column at those lengths. So this wraps and does not attempt the
   frame's line breaks: rename a shortcut, pick a wider typeface in Settings or
   drag the window narrower and the rows re-form on their own. */
.dashboard-shortcuts__list {
  display: flex;
  flex-wrap: wrap;
  gap: var(--space-8);
}

/* The chip. A <button> rather than an <a>, because none of these destinations
   exists in the prototype yet — see the markup's own note.
   Content-width by inline-flex and never stretched, per "pills never stretch to
   fill a container": in a wrapping flex row a chip would otherwise be free to
   grow, and a row of two would sit at half the card each.
   --space-4 between the mark and the label, --space-8 to the chip's own edges:
   both are optical work INSIDE a control, which is what those two steps are
   for. */
/* OUTLINED AND BUTTON-SHAPED SINCE 2026-09-10, on request: "don't use a
   background, but a stroke, and don't round them fully, just make them similar to
   buttons". It was a --color-background fill at --radius-full — a chip, and CLAUDE.md
   says chips are fully rounded, which is exactly why the shape had to change rather
   than just the radius: a pill with a stroke still reads as a chip, and a chip is a
   label, not something you press. Outlined and at --radius-sm it reads as the control
   it actually is.
   THE THREE VALUES ARE .btn's OWN — --color-outline at 1px, --radius-sm, and
   --color-chip on hover — referenced rather than picked, so a chip and a compact
   button next to each other cannot drift apart.
   TRANSPARENT, NOT --color-surface, which is what a .btn fills with. On this card
   they are the same colour, so it is a choice about intent: the request was for no
   background, and transparent means the chip cannot disagree with whatever it is
   placed on later. If these ever move onto a tinted surface and should stay white,
   that is the line to change.
   WHERE IT STOPS SHORT OF A BUTTON: no --elevation. Every .btn carries one, but a
   wrapped row of six lifted chips reads as a scattering of buttons rather than as a
   list of links, and these are navigation, not actions. Say so if they should be
   .btn outright — at that point they are one, and this whole block goes. */
.dashboard-shortcut {
  display: inline-flex;
  align-items: center;
  gap: var(--space-4);
  height: var(--control-height-compact);
  padding: 0 var(--space-8);
  border: 1px solid var(--color-outline);
  border-radius: var(--radius-sm);
  background: transparent;
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-body-sm) var(--font-sans);
  white-space: nowrap;
  cursor: pointer;
  /* 0.15s is the prototype's one duration, not a new number. Only the fill
     moves, so only the fill is listed. */
  transition: background-color 0.15s ease;
}

/* --color-chip, the tint every hoverable surface in the system moves to — a
   .btn, a menu item, a clickable table row, a flow channel card. Unchanged by the
   2026-09-10 restyle above, and now doing more work than it was: with no fill at
   rest, hover is the only thing that fills the chip at all, which is the same
   rest-to-tint move a secondary .btn makes. */
.dashboard-shortcut:hover {
  background: var(--color-chip);
}

/* The same ring .btn:focus-visible draws, because this is a control of the same
   kind and a second focus treatment on one page is one too many. */
.dashboard-shortcut:focus-visible {
  outline: 2px solid var(--color-accent-secondary);
  outline-offset: 2px;
}

/* Accent, as the frame has them, and NOT .btn .icon's quiet secondary grey: on
   a button the icon supports a label that is already the action, where here the
   mark is what makes a chip scannable in a wrapped row — it is the thing the
   eye lands on before it reads anything. Stroke emphasis (data-icon-emphasis in
   the markup) because the label beside it is medium weight. */
.dashboard-shortcut .icon {
  color: var(--color-accent-primary);
}

/* --------------------------------------------------------------------------
   Dashboard — Shortcuts picker (2026-09-10, on request: "when pressing
   shortcuts show a menu with search in there and people can search any page
   basically to add it in there"). A `.menu` off the head's + button
   (dashboard.html), widened past .menu's own 200px floor so the search bar
   inside it never has to fight the panel for room, and given a fixed list
   height so a long result list scrolls inside the panel instead of pushing
   it past the page. See dashboard.html's own script block for the directory
   (CEShell.NAV, flattened) and the click wiring. */
.dashboard-shortcut-picker {
  width: 17rem;
  display: flex;
  flex-direction: column;
  gap: var(--space-8);
}

/* .search's own 200px floor fits inside 17rem (272px) with the panel's
   --space-4 padding to spare, so no width override is needed here — only the
   side margins .menu's padding would otherwise leave around it. */
.dashboard-shortcut-picker__search {
  width: 100%;
}

.dashboard-shortcut-picker__list {
  display: flex;
  flex-direction: column;
  gap: var(--space-4);
  /* 6 rows' worth before it scrolls (var(--control-height) rows sit shorter
     than that, so this comfortably clears 6 in practice) — a directory this
     size (every NAV section and child, plus Settings) will not fit a menu on
     its own screen at once, and a menu that grows with its result count
     would run off the bottom of the card. */
  max-height: 15rem;
  overflow-y: auto;
}

/* Same row .menu__item already draws; only the group hint is new. */
.dashboard-shortcut-picker__item {
  justify-content: space-between;
}

.dashboard-shortcut-picker__item-label {
  overflow: hidden;
  text-overflow: ellipsis;
}

/* The section a child belongs to ("Shipments" -> "Orders"), so a result
   reads as more than a bare label once the list is holding two dozen NAV
   rows at once. Secondary ink and the smaller size, same pairing a table's
   own subtitle text uses elsewhere on this page (.dashboard-action-row__subtitle). */
.dashboard-shortcut-picker__item-group {
  flex: none;
  color: var(--color-text-secondary);
  font: var(--weight-regular) var(--text-body-sm) var(--font-sans);
}

.dashboard-shortcut-picker__empty {
  margin: 0;
  padding: var(--space-8) var(--space-12);
  color: var(--color-text-secondary);
  font: var(--weight-regular) var(--text-body-sm) var(--font-sans);
  text-align: center;
}

/* "Add channel" now sits in line with the title, not in a separate toolbar
   row below the tabs. */
.dashboard-channels__head {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: var(--space-16);
}

/* Read-only — plain text, not a link (no destination exists for a click at
   the card-header level), so no hover/underline state and no chevron. */
.dashboard-channels__title {
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-heading) var(--font-sans);
}

/* The row holding the card's All / Inactive filter, and the divider under it.
   WAS .dashboard-channels__tabs-row, holding a .tabs bar, until 2026-08-31: the
   control became a .segmented (see dashboard.html for the pattern ruling behind
   that — docs/elements.md "Tabs, dropdown or segmented?", amended the same day to
   let a segmented control carry a filter at up to 3 values). Renamed with it,
   because "tabs-row" would have been the only thing left in the file still calling
   it tabs.
   NO DIVIDER (2026-08-31, on request, immediately after the segmented swap). It was
   a 1px --color-outline-card line at this row's bottom edge, and under .tabs it was
   half of a pair: each .tab drew its own transparent-or-accent bottom border on top
   of it, and the active tab's accent segment was part of how a tab bar reads. Once
   the control became a .segmented — which carries its own track and draws no
   underline — the line was left doing the work alone, and a card that already has an
   outline does not need an internal rule to say where its header ends. Space says it.
   THE BLEED WENT WITH IT. This row carried negative side margins and matching
   padding so the border could reach the card's true outer edge past its --space-16
   padding (the same technique .dashboard-channel-tiles below still uses). With no
   border there is nothing left to bleed, so both halves of that trick are gone
   rather than left cancelling each other out — the row is now an ordinary flex child
   sitting in the card's padding, which is what it looks like.
   margin-top still pulls the row up closer to the header above it (was the card's
   own --space-16 gap; now --space-8) per the user's explicit "move the tabs a bit
   higher up". */
.dashboard-channels__filter-row {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: var(--space-16);
  margin-top: calc(var(--space-8) - var(--space-16));
  /* NO margin-bottom. 16px between the control and the tiles (2026-08-31), and
     .card's own --space-16 flex gap already IS that 16 — it sits between every pair
     of its children, so the value is reached by adding nothing rather than by
     declaring it.
     It was --space-16 here for part of the same day, making 32; before that, 4px of
     padding that existed only to hold the pill off the divider. Both are gone, and
     the absence is deliberate enough to be worth a comment: `margin-bottom: 0` would
     say the same thing while implying something had to be cancelled, and the next
     person to want 16px here should find that it is already the card's default and
     leave it alone. */
}

/* Channel tiles — Figma node 2139:36991, rebuilt 2026-08-25 on the user's
   direct instruction ("rebuild those elements as they're shown in figma").
   REPLACES the five full-width rows this card used to hold: every
   .dashboard-channel-row* class and .dashboard-channel-badge are deleted with
   them, since nothing else referenced them. What went with them, worth
   recording because each was its own decision:
     - the .badge--logo.badge--lg pill (plus its .badge__flag-circle). The
       frame draws a BARE logo with the flag on its own small disc beside it,
       no pill box at all.
     - the revenue column (amount + trend + trending-up icon). The frame's
       tile carries open orders and returns only. So the text-grade
       --color-success-text this card was using for its trend icons is now
       referenced by the GMV flow alone.
     - the row chevron, and the "Top 5 by revenue" tab with the date range
       that only showed beside it. The frame has two tabs, All and Inactive,
       and no date.
   The promo row (.dashboard-promo) is not in the frame either — its markup is
   hidden rather than deleted, like everything else this page has parked
   (.dashboard-kpis, .dashboard-revenue, .dashboard-viewswitch), and its CSS
   below is left intact for that reason.

   Three columns of 172px tiles in the frame; auto-fill rather than repeat(3)
   so the grid drops to two columns and then one as the card narrows, instead
   of squeezing three tiles past what a channel name needs. 10.75rem is the
   frame's own 172px as the floor.
   Full-bleed against the card's own padding, the same negative-margin trick
   the rows before it used, so the tiles sit level with the tab row's divider
   above them. */
.dashboard-channel-tiles {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(10.75rem, 1fr));
  gap: var(--space-8);
  /* No negative pull-up (2026-08-25, on request: 16px from the tab bar to the
     tiles). It was calc(-1 * var(--space-8)), which cancelled half of .card's
     own --space-16 gap and left 8px. Dropping it to 0 lets that gap stand as
     the full 16 — so the spacing is the card's own step, not a second value
     stated here. Only the top margin was ever non-zero; this was never doing
     the horizontal bleed the comment above describes.
     STAYS AT A FLAT 0 (2026-09-10, on request: "the distance between the
     segmented control and channels is 16px only, without changing the size
     of the channels container at all") — a stretch-and-auto-margin version
     stood here briefly, matching this card's height to the taller
     Activity/Orders/Shortcuts column beside it; it was traded for taller
     tiles instead (see .dashboard-channel-tile's min-height below), which
     grows the card by its own content rather than by reaching for a height
     that belongs to the column beside it. The gap to the segmented control
     above is .card's own --space-16 flex gap, untouched either way. */
  margin: 0;
}

/* The tile. Radius --radius-sm inside the card's own --radius-md, outer step
   larger than inner. The gradient is the frame's own — white to Neutral/N10,
   and N10 is exactly --color-background's value, so both stops are tokens and
   no colour is introduced (same as the GMV card's white-to--color-chip). */
.dashboard-channel-tile {
  position: relative;
  display: flex;
  flex-direction: column;
  gap: var(--space-4);
  /* A FLOOR, not a fixed height (2026-09-02, on request: "a bit taller"). The
     tile's content came to roughly 7rem, which left the identity row, the name
     and the two ops lines packed against each other with no air under them.
     8.5rem gives the column somewhere to breathe without pinning it — a tile
     whose content grows past this still grows, and the grid still stretches
     every tile in a row to the tallest, so nothing here can go ragged.
     9rem AS OF 2026-09-10 (on request, "a tiny bit taller" — a follow-up to
     making the Channels card reach the Shortcuts card's bottom edge, this
     time by growing the tiles' own content rather than by stretching the
     card to a height that belongs to the column beside it). */
  min-height: 9rem;
  padding: var(--space-12);
  /* Card outline at 8% black, not the general --color-outline (2026-08-25, on request). */
  /* 12% with every other card (2026-09-16) — see .card in elements.css. */
  border: 1px solid var(--color-outline-container);
  border-radius: var(--radius-sm);
  /* DIALLED DOWN (2026-09-04, request). The bottom stop was --color-background
     flat; it is now that token at HALF strength over the surface, so the tile
     still shades from white but arrives somewhere between white and the page
     grey instead of at it. Two tokens in, no colour added, and no literal — the
     same color-mix-on-tokens move the Activity rows already make for the frame's
     half-strength tints, and that elements.css makes to darken a filled button
     on hover.
     Why it needed dialling: the page tint went behind these tiles, so the
     gradient was running white -> #f5f5f5 against a card that is itself on a
     tinted page, and the bottom of every tile read as a shadow rather than as
     shading. Halving it keeps the direction and drops the weight. */
  background: linear-gradient(180deg, var(--color-surface),
              color-mix(in srgb, var(--color-background) 50%, var(--color-surface)));
}

/* Only a channel with a built shell navigates — same "only a built
   destination is clickable" rule the sidebar's unbuilt sections follow. The
   other eight tiles are static, so they must not offer a pointer. */
.dashboard-channel-tile--linked {
  cursor: pointer;
}

/* Hover is a LIFT, not an outline (2026-08-31, on request). It was
   border-color: --color-accent-secondary, which had two problems beyond being
   asked to go: an accent stroke is the system's SELECTED language — it is what
   .segmented__item--active and a focused input draw — so a hover borrowing it
   said "chosen" about something the pointer was merely passing over; and because
   the tile's resting border is --color-outline-card at 8% black, the swap changed
   the border's colour AND its weight-on-screen at once, which read as the tile
   jumping rather than responding.
   --elevation is the subtlest of the three steps, and the same one the GMV flow's
   channel cards take for their selected state — the two channel elements on this
   page now respond in one vocabulary. The border is deliberately left at its
   resting --color-outline-card: the shadow alone carries the state, so the tile's
   edge never moves and nothing reflows.
   Still only on --linked. The other eight tiles have no destination, so they get
   no cursor and no hover — a lift that leads nowhere is a worse promise than the
   outline was. */
.dashboard-channel-tile--linked:hover {
  box-shadow: var(--elevation);
}

/* Logo, flag, and the kebab's own space. The kebab is positioned rather than
   laid out here (see below), so this row reserves its width with padding-right
   instead — a flex row with three items would let a wide logo push the flag
   under the kebab. */
/* --space-8 between the logo and the flag disc (2026-09-04, request: "move the
   flags a bit further to the right, have 8px from the logo"). It was --space-4,
   the frame's own 4px, which the scale calls an OPTICAL step for work inside a
   control — and that is what this had stopped being once the mark grew to
   1.25rem on 2026-09-02: 4px beside a 20px wordmark read as the disc touching
   it. 8 is the first real layout step, so this moves the pair ONTO the scale
   rather than off it.
   The recommendation tile reuses this class verbatim, so its own logo/flag pair
   moves with the eight connected ones — which is the point, they are one grid. */
/* The right padding keeps the mark clear of whatever sits in the tile's top-right
   corner — the kebab until 2026-09-10, the flag since. Same job, same value; only
   the occupant changed. The gap is now unused in practice (the mark is this row's
   only child) and is left in place because a second identity element would want it
   back. */
.dashboard-channel-tile__identity {
  display: flex;
  align-items: center;
  gap: var(--space-8);
  padding-right: var(--space-24);
}

/* A bare mark, not a pill. The width is capped so a wide wordmark cannot crowd
   the flag beside it — object-fit keeps every mark's aspect ratio inside that
   box, so the cap trims a wide logo's height rather than squashing it.
   1.25rem tall, up from the frame's own 15px (2026-09-02, on request). The mark
   IS the tile's identity — the channel name under it is deliberately a
   secondary caption — and at 1rem it was the same height as the flag disc
   beside it and the caption below, so the one element carrying identity had no
   more presence than its own supporting parts. The tile's new 8.5rem floor is
   what makes the room for it. This settled at 1.25rem after 1.5rem was tried
   the same day and asked back down a step: 1.5 gave the mark the weight but
   started to read as the tile's headline rather than its identity, and left the
   1rem flag disc looking stranded beside it. The cap rises with the height
   (3.5 -> 4.375rem) to keep the same ratio: a wordmark that fitted the old box
   fills the new one rather than hitting the cap and staying 1rem tall. */
.dashboard-channel-tile__logo {
  flex: none;
  /* 22px (2026-09-10, on request), up from the 1.25rem/20px above. In rem like the
     value it replaces, so the mark still scales with the reader's font size — 22/16.
     The max-width cap is NOT raised with it this time: the note above ties the two so
     a wordmark fills the box rather than hitting the cap, but 2px of height on a
     contain fit needs no more width than 4.375rem already gives the widest mark in
     the set (bol, at nothing like the cap). Raise both together if a wider one
     arrives. */
  height: 1.375rem;
  max-width: 4.375rem;
  object-fit: contain;
  object-position: left center;
  /* Same light plate under the brand artwork as .badge--logo img, and for the
     same reason — transparent on every theme but Dark, where a #0100A4 or a
     near-black wordmark has nothing to sit on. See elements.css for the full
     note. The tile's logo is a bare mark rather than one inside a pill, so the
     plate is the only ground it gets. */
  background: var(--color-logo-plate);
  box-shadow: 0 0 0 3px var(--color-logo-plate);
  border-radius: var(--radius-flag);
}

/* The documented no-logo-asset fallback, in the mark's place. It steps up with
   the mark (2026-09-02): body-sm was chosen to sit level with a 1rem logo, and
   left there it would now read as smaller than every real logo beside it — the
   fallback has to hold the same weight in the identity row as the thing it
   stands in for. --text-body-md is the next step, and the only one under the
   headings. */
.dashboard-channel-tile__logo-text {
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-body-md) var(--font-sans);
}

/* THE DISC IS GONE (2026-09-10, request: "remove the circles behind flags, just
   show flags as they are"), and with it the two rules that used to sit here: a
   1.25rem .badge__flag-circle scoped to the tile, and a 14x11 override on the flag
   inside it. Both existed only to shrink the ratified 24px disc down to something
   that would not out-measure a 20px logo — with no disc there is nothing to shrink,
   so the flag is simply .badge__flag at its own ratified 15x12.
   THAT CLOSES AN OPEN QUESTION BY REMOVAL, not by answering it. .badge__flag-circle
   is --lg-only "until there's a smaller disc size to decide on", and this tile was
   the one place asking for one — eight times over. It no longer asks. If a small
   disc is ever specced, this is the element that wanted it.
   WHAT WAS LOST: --color-flag-plate, the white ground that let a half-white flag
   (nl, pl) read as a shape rather than as a stripe bleeding into the tile. On these
   light tiles the loss is slight; under Dark the flag now meets a near-black card
   with no plate at all. Flagged rather than pre-solved, since the request was to
   show the flags as they are.
   ONLY THE CORNER POSITION IS THE TILE'S, and it is stated above with the rest of
   the layout — this class exists so the markup can name what it is rendering and so
   a future tile-only flag rule has somewhere to go. */
.dashboard-channel-tile__flag {
  flex: none;
}

/* --------------------------------------------------------------------------
   Recommendation tile — a channel the merchant is NOT connected to, sixth in
   this grid. Figma node 2127:2977, on the user's direct instruction
   (2026-08-27). PROPOSAL. See docs/proposals.md.

   COMPOSED ON .dashboard-channel-tile, not a tile of its own: it is the same
   172px cell in the same grid, so the width, padding, radius and border are the
   tile's and nothing below restates them. It reuses the tile's own
   __identity / __logo / flag-disc classes verbatim too — only the two rows
   under them differ, which is the whole of this block.

   THE FILL IS THE ONE THING THAT MARKS IT AS A PROMO rather than a tenth
   connected channel. The frame draws a white-to-pale-blue gradient — Blue/B5 to
   Blue/B10 — and both are already tokens: B5 IS --color-chip and B10 IS
   --color-page-tint, exactly. So it introduces no colour. Its stop is the
   frame's 147.94%, rounded to 100% for the same reason the GMV card's own
   gradient rounds 178deg to 180: at this size neither is a visible difference.
   This overrides the tile's own white-to---color-background gradient, so the
   two read as the same kind of object in two different states.
   -------------------------------------------------------------------------- */
.dashboard-channel-recommend {
  background: linear-gradient(180deg, var(--color-chip), var(--color-page-tint));
}

/* The frame's 12px/16px Neutral/N80. 12px is not one of the five sizes, so this
   is --text-body-sm (13px) — the nearest step, and the size every caption in
   this container already takes. N80 is --color-text-secondary exactly.
   The tile's own grid puts its name and ops rows at fixed positions; this row
   simply takes the space they would have. */
.dashboard-channel-recommend__text {
  margin: 0;
  color: var(--color-text-secondary);
  font: var(--weight-regular) var(--text-body-sm) var(--font-sans);
}

/* Bottom right, as the frame places it. A text button with no control box —
   NOT .btn--text, which is a 32px control that would read as an action on the
   whole container. The frame's #0b70c1 is not a token and the two nearest are
   --color-accent-primary (#09599b) and --color-accent-secondary (#2095f3);
   this takes accent-primary, which is what every other link and text action on
   the page already uses, rather than adding a third blue between them.
   SemiBold becomes --weight-medium — there is no 600 in this system.
   .dashboard-channel-tile is a flex COLUMN, so flex-end is the horizontal edge
   and `margin-top: auto` is what pins this to the bottom — it also absorbs the
   height difference against a real tile, which carries a name row and two ops
   counts where this carries one line of copy. In a grid row the tiles stretch to
   equal height, so without it the action would float mid-card. */
.dashboard-channel-recommend__action {
  align-self: flex-end;
  margin-top: auto;
  padding: 0;
  border: 0;
  background: none;
  color: var(--color-accent-primary);
  font: var(--weight-medium) var(--text-body-sm) var(--font-sans);
  cursor: pointer;
}

.dashboard-channel-recommend__action:hover {
  text-decoration: underline;
}

/* Bare icon, no control box, as the frame draws it — same shape as
   .dashboard-promo__close and the GMV card's own gear. Absolutely positioned
   so a long channel name can run under it without the identity row
   reflowing.
   INERT, and for a stated reason rather than an oversight: CLAUDE.md's "not
   yet decided" list still names "channel-level actions beyond Settings", so
   there is no sanctioned set of actions for this menu to hold. It gets its
   tooltip and nothing else until that is decided. */
/* THE FLAG HOLDS THIS CORNER NOW, and .dashboard-channel-tile__kebab is gone with
   its two rules (2026-09-10, request: "remove the 3 dots in channels and replace
   them with the flag now shown in the logo"). The kebab was inert — CLAUDE.md lists
   channel-level actions beyond Settings as undecided — so the tile spent its most
   prominent corner on a button that opened nothing, while the flag competed with
   the wordmark for the identity row.
   ABSOLUTE, INHERITING THE KEBAB'S OWN OFFSETS, so the corner is unchanged and the
   tiles line up with each other exactly as they did. Sizing and the white plate
   still come from .dashboard-channel-tile .badge__flag-circle above — this rule adds
   position and nothing else, so the two cannot disagree about what a tile flag looks
   like.
   The direct-child selector is deliberate: it matches the flag only where the render
   functions now put it, and would not reach one that ended up back inside
   .dashboard-channel-tile__identity.
   It matches the FLAG ITSELF as of 2026-09-10, not the disc that used to wrap it —
   see .dashboard-channel-tile__flag below. */
.dashboard-channel-tile > .badge__flag {
  position: absolute;
  top: var(--space-12);
  right: var(--space-12);
}

/* The frame's 12px N80 -> body-sm secondary, the nearest step. Secondary
   because the LOGO is the tile's identity; the name is the caption under it.
   Truncated rather than wrapped: two lines here would make one tile taller
   than the eight beside it, and the grid stretches every tile in a row to the
   tallest. */
.dashboard-channel-tile__name {
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
  color: var(--color-text-secondary);
  font: var(--weight-regular) var(--text-body-sm) var(--font-sans);
}

/* "12 open orders" over "2 returns" — two lines, primary, as the frame has
   them. margin-top pushes them off the name rather than the tile using one
   gap for everything: the frame sets 16px between the name and this pair
   against 4 above it. */
.dashboard-channel-tile__ops {
  display: flex;
  flex-direction: column;
  /* auto, not --space-8, since the tile gained its 8.5rem floor: the counts sit
     on the bottom edge and the slack opens between them and the name, rather
     than all of it falling under the last line. --space-8 is the minimum, so a
     tile that has no slack still reads exactly as it did before. */
  margin-top: auto;
  padding-top: var(--space-8);
  color: var(--color-text-primary);
  /* body-md, not the frame's 12px -> body-sm (2026-09-02, on request). These two
     lines are the only DATA on the tile — everything above them is identity —
     so they now outrank the name caption in size as well as in colour, where
     before the two differed only by --color-text-secondary. It also re-separates
     them from the name: at one size the four lines read as one block. */
  font: var(--weight-regular) var(--text-body-md) var(--font-sans);
}

/* The count leads each line and is the only part that is a figure, so it is
   the only part that takes tabular-nums — the words after it are prose, where
   CLAUDE.md is explicit that a padded 1 reads as a gap mid-sentence. */
.dashboard-channel-tile__ops-count {
  font-variant-numeric: tabular-nums;
}

/* Promo row — recommending a channel that isn't connected. HIDDEN as of the
   2026-08-25 tile rebuild (the frame has no promo row); kept intact because
   the idea is its own, not something the tiles superseded. The comments below
   describe it against the row list that used to sit above it, which is gone —
   unhiding it wants a look at how it reads against a grid of tiles.
 Zalando isn't in
   CEData (mock-data.js only models the channels this prototype actually
   connects) and has no logo asset, so it renders as plain text, matching the
   bare .channel-mark logos above it rather than a pill. Tinted with the
   shared --color-chip, the same tint a hovered row or menu item already
   uses — not a new colour. */
/* Same author-display-beats-[hidden] trap as .dashboard-viewswitch above —
   the promo is hidden as of 2026-08-25 and this is what makes that bite. */
.dashboard-promo[hidden] {
  display: none;
}

.dashboard-promo {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: var(--space-16);
  padding: var(--space-12) var(--space-16);
  margin: 0 calc(-1 * var(--space-16)) calc(-1 * var(--space-16));
  border-top: 1px solid var(--color-outline);
  border-radius: 0 0 var(--radius-md) var(--radius-md);
  background: var(--color-chip);
}

/* Logo above the text, not beside it, per an explicit follow-up — the same
   stacked shape .dashboard-channel-row__identity used for the connected
   channels above, so the promo reads as one more row in that list rather
   than as a differently-built strip. --space-4 for the same reason it does:
   two lines of one thing. */
.dashboard-promo__identity {
  display: flex;
  flex-direction: column;
  align-items: flex-start;
  /* --space-8, up from --space-4 per an explicit follow-up — at 4px the 18px
     mark and the line under it read as one crowded block. The channel rows
     above keep --space-4: their second line is the channel's own name, part
     of the same identity, where this one is a separate sentence about it. */
  gap: var(--space-8);
  min-width: 0;
}

/* Text fallback for a channel with no logo asset — kept for anything added
   without one, though nothing uses it now that every channel in the fixture
   has a real mark. */
.dashboard-promo__logo {
  flex: none;
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-body-md) var(--font-sans);
}

/* Same 16px the connected rows scale .channel-mark down to
   (the deleted .dashboard-channel-row__identity .channel-mark), so the logo sits
   at the same size as the five above it. */
.dashboard-promo__mark {
  flex: none;
  align-self: flex-start;
  /* 18px — .badge--lg.badge--logo's own logo height (elements.css), so the
     promo's bare mark reads at the same size as the logos inside the pills
     above it. Deliberately still bare: this channel is a recommendation, not
     a connection, so it gets no pill and no country flag. */
  height: 18px;
  width: auto;
}

.dashboard-promo__text {
  color: var(--color-text-secondary);
  font: var(--weight-regular) var(--text-body-sm) var(--font-sans);
}

.dashboard-promo__actions {
  display: flex;
  align-items: center;
  gap: var(--space-8);
  flex: none;
}

/* Just the icon, per an explicit follow-up — it was a .btn--icon.btn--compact
   with its own border, surface and 28px box. Still a real <button> (it does
   something, and it needs a name for screen readers); only the button's
   chrome is gone. Not an .icon-btn-group case either: there is one icon here,
   not two adjacent ones. */
.dashboard-promo__close {
  display: inline-flex;
  align-items: center;
  justify-content: center;
  padding: 0;
  border: none;
  background: none;
  color: var(--color-text-secondary);
  cursor: pointer;
}

.dashboard-promo__close:hover {
  color: var(--color-text-primary);
}

/* Activity card ------------------------------------------------------------
   Rebuilt from Figma node 2139:36991, 2026-08-25, on the user's direct
   instruction. The rows were full-bleed, divider-separated strips; the frame
   makes each one its own small TINTED card inside the Activity card, with the
   severity carried by the fill rather than only by the title's colour.
   So the negative margins are gone (a card inside a card sits inside the
   padding, it does not bleed past it) and so is the border-top per row. */

/* --space-4 between rows, which is the frame's own 4px (its rows sit on a 56px
   pitch over a 52px card). Noted against CLAUDE.md's "2 and 4 are optical, for
   work inside a control — not for laying out a page": this is a stack of cards
   inside one card rather than page layout, and at --space-8 the four rows read
   as four separate objects instead of one list. Flagged rather than rounded. */
.dashboard-action-rows {
  display: flex;
  flex-direction: column;
  gap: var(--space-4);
}

/* Each row is its own bordered, tinted card. --radius-sm inside the Activity
   card's own --radius-md, outer step larger than inner. */
.dashboard-action-row {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: var(--space-16);
  /* 16px on the right, 12 elsewhere (2026-09-10, request: "chevrons at 16px from
     the right edge"). The asymmetry is the requested measurement, not drift: the
     row's affordance is now a 16px glyph rather than a button whose own box
     supplied the optical inset, so the distance from the chevron to the card edge
     has to be stated here. Both values are --space steps. */
  padding: var(--space-8) var(--space-16) var(--space-8) var(--space-12);
  /* Card outline at 8% black, not the general --color-outline (2026-08-25, on request). */
  border: 1px solid var(--color-outline-card);
  border-radius: var(--radius-sm);
  background: var(--color-surface);
  /* THE WHOLE ROW IS THE TARGET NOW. A chevron on the right edge is exactly the
     "clickable region" case CLAUDE.md names, where the hand cursor belongs to the
     region rather than to the visibly-interactive part of it — with the button gone
     there is nothing else for a click to land on. Still inert in the prototype, the
     same way the four buttons were: none of these destinations exists. */
  cursor: pointer;
}

/* THE ROWS LOST THEIR BUTTONS (2026-09-10, request: "replace the buttons inside
   each row with chevrons at 16px from the right edge, just icons not action
   buttons"). Each row carried a .btn--compact naming its own destination ("View
   errors", "View plugin") per docs/elements.md's label rule. What that rule buys is
   a label that reads on its own; what it cost here is four button boxes stacked down
   a 300px-wide card, each with its own border and fill inside a row that already has
   both — the card read as a form, and the one action per row was never a choice
   between alternatives, which is what a button implies.
   A CHEVRON SAYS THE SAME THING WITH NO CHROME: the row goes somewhere. The
   destination is no longer named, which is the real trade — it is now inferred from
   the row's own title ("20 listing errors in Bol" -> the listing errors), and that
   only holds because every title here names its subject. A row whose title did not
   would need its button back.
   SECONDARY INK, NOT THE SEVERITY COLOUR. An alert row turns its TITLE
   --color-error-text; the chevron stays quiet in both kinds of row, because it
   reports where the row leads and not how bad it is — colouring it red would say the
   navigation itself is the alarming part. flex: none so it never shrinks under a
   long title. */
.dashboard-action-row__go {
  flex: none;
  color: var(--color-text-secondary);
}

/* THE TINTS ARE MIXED, NOT LITERAL. The frame fills an error row with
   rgba(252,237,237,0.5) — a much paler red than --color-error-tint (#f6caca),
   which is a badge fill sized to carry dark text. Rather than introduce the
   frame's value or drop the ratified tint in at full strength (which reads as
   an alert banner at this size), each row mixes the existing tint half-and-half
   with the surface it sits on. Two tokens in, no colour added, and the result
   is the frame's own "tint at 50%" intent. color-mix on tokens is already how
   elements.css darkens a filled button on hover.

   DIALLED DOWN 50% -> 25% (2026-08-25, on request). Both rows moved by the same
   amount and stayed in step: the frame gives red and yellow one strength, so a
   change to one that is not made to the other would start saying that severity
   is carried by saturation as well as by hue.
   THE ERROR ROW ALONE WENT 25% -> 35% (2026-09-10, on request: "change the error
   list item opacity colour for the background to 35%"). So the two are no longer
   in step, and that is worth stating plainly rather than quietly: the warning row
   is still at 25%, so red now reads a shade heavier than yellow at the same rank.
   IT IS ALSO MORE DEFENSIBLE THAN IT WAS. When the note above was written, an error
   row said "error" twice — red tint AND a red title. The title override was removed
   earlier the same day, which left the fill as the only severity signal these rows
   have, and the strongest of them carrying the least contrast against the card was
   the wrong way round. If the warning row should follow to 35%, that is one number
   below and the two are a pair again.
   The mechanism is unchanged — still two tokens mixed, still no colour added.
   Legibility is unaffected in the direction that matters: --color-error-tint is a
   badge fill built to carry dark type at FULL strength, so every step toward it is
   a step toward more contrast under --color-text-primary, not less. */
.dashboard-action-row--alert {
  background: color-mix(in srgb, var(--color-error-tint) 35%, var(--color-surface));
}

.dashboard-action-row--warning {
  background: color-mix(in srgb, var(--color-warning-tint) 25%, var(--color-surface));
}

/* 4px BETWEEN THE TWO LINES, STATED (2026-09-10, request: "make sure it's min
   4px"). There was no gap here at all — the space was whatever the two line boxes
   happened to leave (--text-body-md is 16/20 and --text-body-sm 14/16, so a few px
   of half-leading), which means it was never a decision and moved every time the
   type scale did. Both of those sizes are marked "trial" in tokens.css, so this was
   live drift, not a stable default.
   ONE RULE COVERS ALL FOUR ROWS — alert, warning and plain all stack their text in
   this element, so the pair spacing cannot come apart between severities.
   --space-4 is inside CLAUDE.md's "optical, for work inside a control" allowance:
   this is a title and its own subtitle inside one row, not page layout. The next
   step up, --space-8, breaks the pair — at 8px the subtitle starts reading as a
   separate line in the row rather than as the title's own qualifier. */
.dashboard-action-row__text {
  display: flex;
  flex-direction: column;
  gap: var(--space-4);
  min-width: 0;
}

.dashboard-action-row__title {
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-body-md) var(--font-sans);
}

/* NO TITLE IS COLOURED ANY MORE, and the rule that did it is gone rather than
   overridden (2026-09-10, request: "change the red error titles to text primary in
   these activity elements"). .dashboard-action-row__title already sets
   --color-text-primary, so deleting the alert override IS the change — a second rule
   restating primary would leave two declarations arguing about one colour.
   WHAT IT USED TO SAY, since this went through two passes: an alert row's title took
   the text-grade --color-error-text (6.96:1), having earlier used the --color-error
   fill (5.22:1, and a fill by definition). The warning row never had one, because
   --color-warning is a yellow that cannot carry type at any size.
   THE ROWS NOW WORK THE WAY THE WARNING ROW ALWAYS DID: the fill is what carries
   severity and the title is just the title. That is also the more consistent reading
   of a list where three of four rows are tinted — with red type as well as a red
   tint, an error row was making the claim twice, and the warning row beside it was
   making it once.
   IF SEVERITY EVER NEEDS THE TYPE AGAIN, put it back here rather than on the title
   itself, and give the warning row an answer at the same time — the two diverging is
   what made the previous arrangement uneven. */

.dashboard-action-row__subtitle {
  color: var(--color-text-secondary);
  font: var(--weight-regular) var(--text-body-sm) var(--font-sans);
}

/* --------------------------------------------------------------------------
   Dashboard — GMV flow
   Figma "CE-Refresh — Design explorations", node 2138:36975.

   Replaces the earlier sources -> summary -> top-selling-products flow (node
   865:12178) in the same slot, on the user's direct instruction (2026-08-25).
   The connector language carries over (dashed paths, round-capped dots at
   every endpoint); everything the lines join is new. Its colour is the one
   token this element added — see --color-connector below, and in tokens.css. Retired with it, CSS and
   markup deleted rather than hidden, since nothing else used them:
   .dashboard-flow__sources / .dashboard-flow-source* (the three source rows),
   .dashboard-flow__products / __products-head (the products CARD — the frame
   has one small card per product instead) and .dashboard-flow-product__value.

   Three columns, left to right:
     GMV        one card: the label and its gear, the big number, the range
     Channels   the four channels contributing most of it, each with its
                amount and trend, plus an "Others" row for the tail
     Products   the selected channel's best sellers, plus "View more"

   Each column's items are their own small cards, as the frame draws them —
   NOT rows inside one card, which is what the flow this replaces did. So
   .dashboard-flow-channel and .dashboard-flow-product carry their own
   surface/outline/radius rather than using .card: the frame's own corner here
   is 8px (--radius-sm) where .card is --radius-md, and .card's padding and
   gap would both have to be overridden as well. Three of five properties
   replaced is not reuse.

   TWO THINGS ARE NOT IN THE FRAME, both revertible on their own:
   - **The products column is per channel and the channel is selectable.**
     The frame hangs its three products off the second channel row with
     nothing saying why, and "most sold products per channel" is only true of
     a static column by luck. So a channel card is a click target
     (--selectable/--selected), and picking one swaps the products and moves
     the second fan onto it. Revert = drop the two modifiers and always
     select the first channel.
   - **The trend's green is one shade darker than the frame's.** The frame
     draws arrow and figure alike in Green/G80 (#488f3d) or Red/R80
     (#af1d1d). The red is now exactly that; the green is not, and this is
     the one place the build knowingly overrules Figma on a value. G80
     measures 3.98:1 on white — it clears the 3:1 a graphic asks and misses
     the 4.5:1 a 13px figure asks, so adopting it verbatim would have added a
     token that fails the thing it was added for. --color-success-text is
     G80's own hue and saturation one step darker, at 5.00:1. Decided by the
     user on the measurements, 2026-08-25; the whole comparison is in
     tokens.css above the pair. (Before that this was arrow-only with the
     figure on --color-text-secondary, then briefly the fill green at
     2.32:1.)

   GEOMETRY IS MEASURED, NOT WRITTEN DOWN — the one real departure from the
   element this replaces. That one carried a standing "GEOMETRY IS
   LOAD-BEARING" warning: its connectors were paths in a hand-derived 403-unit
   viewBox mirroring the pixel layout, so changing a padding, a row height or
   a type size pulled every line off the row it pointed at — and the settings
   panel's own typeface picker can do exactly that. Here one absolutely
   positioned SVG spans the whole element and drawFlowLinks() (dashboard.html)
   writes its paths from the live element rects, in real pixels, on load, on
   resize, on fonts.ready and on every selection change. Nothing in this
   block is load-bearing for the lines, and a row is free to be whatever
   height its content makes it.
   -------------------------------------------------------------------------- */
.dashboard-flow {
  /* The link layer below is positioned against this. */
  position: relative;
  display: flex;
  align-items: center;
  /* Inset 32px on each side, per an explicit follow-up — it spanned the full
     body width for one revision and read as edge-to-edge. Measured from the
     Activity/Channels row below, which is what "the whole width" is on this
     page: those containers sit on .page__body's own gutter, this one sits
     --space-32 inside it.
     The three columns keep their own widths, so this inset (like the page
     width before it) is absorbed by the two gaps between them — it shortens
     the connectors, it does not squeeze the cards. */
  margin-left: var(--space-32);
  margin-right: var(--space-32);
  /* 24px below the global header (2026-08-25, on request). .page__body's own
     gutter supplies 16 of it, so this is the 8 on top — not --space-24, or the
     element would sit at 40. */
  margin-top: var(--space-8);
}

/* View switch row — right-aligned above the flow.
   HIDDEN as of 2026-08-25, on request, and hidden rather than deleted: the
   control is inert anyway and this is the fourth thing on this page kept in
   the DOM for a possible return (see .dashboard-kpis, .dashboard-revenue).
   It was also what made up most of the band between the global header and the
   flow — 16px of .page__body gutter, this row's 32px control, and its own
   16px below it. With it gone the flow sits on that 16px gutter alone, which
   is 48px higher up the page. No compensating margin was added: moving the
   flow up is the point, and every value between 16 and 64 is off the scale.
   The rules below still apply if it comes back. */
/* An author `display: flex` beats the UA stylesheet's own [hidden] rule
   regardless of specificity, so the attribute has to be said again here to
   bite — the same trap elements.css documents for [data-page-content][hidden]
   and this page's own .page[hidden]. Without this, `hidden` on the row above
   does nothing at all. */
.dashboard-viewswitch[hidden] {
  display: none;
}

.dashboard-viewswitch {
  display: flex;
  justify-content: flex-end;
  margin-bottom: var(--space-16);
  /* Lines the control up with the flow element's right edge below it, not the
     page body's — see .dashboard-flow's own inset. */
  margin-right: var(--space-32);
}

/* A stroke around the track, per an explicit follow-up. SCOPED to the
   dashboard's switch on purpose: .segmented is a ratified element
   (docs/elements.md) and Products uses the same control for its own grid/list
   switch, so putting this border in elements.css would restyle that page too —
   a system decision, not a page one. --control-height is border-box, so the
   track stays 32px and the 64px band above the flow is unaffected. */
.dashboard-viewswitch .segmented {
  border: 1px solid var(--color-outline);
}

/* The connectors, all of them, in one layer over the whole element ---------
   One SVG rather than one per gap: the paths are written in the flow's own
   pixel space, so a single coordinate system is simpler than two, and the
   second fan starts at a channel card that sits in the middle column rather
   than at a gap's edge. No viewBox — user units are CSS pixels here, which is
   what lets the stroke and the dash gap below be real values instead of
   numbers that scale with the element. */
.dashboard-flow__links {
  position: absolute;
  inset: 0;
  width: 100%;
  height: 100%;
  /* It covers the cards it joins, so it must never eat their clicks. */
  pointer-events: none;
  /* ABOVE the cards, not behind them (2026-08-25, on request). Every endpoint
     dot is centred on a card's own edge, so half of each one is inside the
     card — and the GMV card is position: relative (it anchors the gear), which
     puts it in the same paint step as this layer with DOM order deciding, so
     it was covering the hub dot outright. z-index only has to beat a card's
     own auto; the lines themselves run through empty gaps, so nothing else is
     obscured by lifting this. */
  z-index: 1;
}

/* --color-connector, added to tokens.css on the user's direct instruction
   (2026-08-25) with the value they gave: #51acf6, which is the frame's own
   Color/Blue/B50. Until then this line borrowed --color-info as the closest
   existing token, the same substitution .dashboard-revenue__connector above
   still makes and the thing that ledger row flagged — so the substitution is
   now retired here rather than merely noted.

   1.5px, round cap. Not a new value in this file: it is what the hidden
   legacy .dashboard-revenue__connector still uses, and what this element
   itself used before an explicit follow-up took it to 3 and then 2. Back to
   1.5 on request, 2026-08-25. With no viewBox the user unit is a CSS pixel, so
   this is a true 1.5px hairline — 3 device pixels and crisp at 2x, softened by
   antialiasing at 1x.
   `4 8`, from `1 12` (2026-08-25, on request — longer marks, less air between
   them): this is a DASHED line now rather than a dotted one, which is what a
   1-unit mark was. The round cap adds half the stroke width at each end, so at
   1.5 the mark draws ~5.5px with ~6.5px of air, not 4 and 8.
   TWO THINGS DELIBERATELY NOT CHANGED WITH IT, both offered and not taken:
   the dasharray, which would want ~`4.5 7.5` to hold the exact rhythm 2px
   had; and the endpoint dots below, which are independent 8px circles and now
   read heavier against the line than they did.
   vector-effect is gone with the viewBox: there is no non-uniform scale left
   to correct for, so these are plain CSS pixels and the dash no longer
   stretches with the page width the way the old fans' did. */
.dashboard-flow__links path {
  fill: none;
  stroke: var(--color-connector);
  /* 1.2, down from 1.5 (2026-08-25, on request). Unitless, so it resolves in
     the SVG's own user units, which are CSS px here — the layer is inset:0 over
     the element with no viewBox scaling, so 1.2 draws as 1.2px.
     A literal like the 1.5 it replaces: a stroke width is not spacing or
     colour, and the system's only stroke tokens (--icon-stroke,
     --icon-stroke-emphasis) are lucide's own and scoped to icons. */
  stroke-width: 1.2;
  stroke-linecap: round;
  stroke-dasharray: 4 8;
}

/* Endpoint dots — the same 8px marks the old fans placed by percentage, now
   circles the draw pass puts on the rects it measured. Same colour as the
   line they terminate, so the join reads as one mark. */
.dashboard-flow__links circle {
  fill: var(--color-connector);
}

/* The second fan being DRAWN out to the products on a newly picked channel
   (2026-08-27, on request), which is what this transition now carries. It used
   to carry the fan SWEEPING from the old channel to the new one — same
   property, same duration, different starting value: drawFlowLinks() collapses
   each path to zero length at the anchor first, so `d` interpolates from
   nothing rather than from the previous channel's curve. The dash pattern is
   untouched throughout, so the 4/8 dashes extend outward as the path grows.
   The dots use the same mechanism: each rides from the anchor to its card.
   Added by drawFlowLinks() for a SELECTION draw only — a resize redraw must
   land instantly or every line lags behind the layout while the window is
   being dragged.
   300ms, up from the 180ms this ran at until 2026-08-27 ("the way products
   appear when I click different channels is too fast"). 180 was the system's own
   selection-slides duration, lifted from .channel-nav's thumb (elements.css,
   docs/shell-forms.md → Motion) rather than invented, on the reading that this
   is the same gesture — a selection moving between rows. What that missed is
   DISTANCE: a thumb slides ~40px and this fan draws ~250px, so one duration over
   the longer one reads faster.
   THE INTRO'S OWN OVERRIDE IS GONE WITH THIS. The intro ran at 0.3s while a
   selection ran at 0.18s, on the reasoning that a one-off you watch may be
   slower than a control you operate. Both are 0.3s now, so the scoped rule
   holding them apart was deleted rather than left restating this value. One
   duration for the draw, wherever it runs.
   `d` and `cx`/`cy` are real CSS properties on modern engines, so the path
   interpolates as long as both ends are one M plus one C — which is what
   drawFlowLinks()'s single curve() shape guarantees. Where an engine does not
   support animating them the geometry simply lands instantly, which is exactly
   the behaviour this replaces. */
.dashboard-flow__links--animated path {
  transition: d 0.3s ease;
}

.dashboard-flow__links--animated circle {
  transition: cx 0.3s ease, cy 0.3s ease;
}

/* "Top 3" — a label sitting ON the second fan, naming what the products column
   is. On the user's direct instruction (2026-08-27) with a screenshot: "a little
   unique pill on top of the line starting from channels showing products saying
   Top 3, font size 11. Full white background, at 16px distance from the channel
   cards."

   IT MASKS RATHER THAN INTERRUPTS. The three lines are still drawn from the
   channel's edge to each product, unchanged — this pill's opaque fill simply
   covers the stretch where they overlap, so they read as leaving the pill. It
   also means no geometry changed to make room for it, and removing it leaves the
   fan exactly as it was.
   THE FILL IS --color-page, NOT --color-surface (2026-09-10, on request: "make the
   background of the top 3 pill the same as the page background colour"). The
   original instruction said "full white", and white is what the pill sat on when
   the flow had a white ground; the page carries its own tint now, so a white pill
   on it read as a small card floating over the line rather than as a gap in the
   line with a word in it. Matching the page is what makes it read as the second.
   WHAT MUST NOT CHANGE IS THE OPACITY. Any fill here works only if it is a solid
   colour — a translucent one would show the dashes crossing underneath and the
   mask would stop working. --color-page is solid on Classic (#edf4f8) and resolves
   to a solid color-mix on Light; both are opaque. A token with alpha in it is the
   one thing this line cannot take.

   ABOVE the links layer, which is itself z-index 1 over the cards — so 2. And
   pointer-events: none: it is a label, and it sits over the gap the cards do not
   occupy, but it must not become a click target on the way past.

   11px IS A LITERAL AND A DELIBERATE BREAK of "only the five named sizes",
   asked for by size. The smallest step is --text-body-sm at 13px, which at this
   scale would make the pill taller than the 8px gap between two channel rows and
   have it read as a card rather than a mark on a line. Scoped to this one
   element, nothing else may reference it — the same footing as the GMV value's
   bespoke 46px, and it feeds the same open question docs/proposals.md carries
   about whether an element may hold its own type size at all. In rem so it still
   honours the reader's browser font-size.

   Fully rounded, which is the foundation rule for a pill, and the height comes
   from the type plus --space-2/--space-8 rather than being stated. The text
   takes --color-accent-secondary: the screenshot's label is a saturated blue,
   darker than the connector it sits on (--color-connector, #51acf6) and lighter
   than --color-accent-primary, and #2095f3 is that. No colour added.
   -------------------------------------------------------------------------- */
.dashboard-flow__fan-label {
  position: absolute;
  /* left/top are written by drawFlowLinks() from the selected channel's rect.
     The translate centres the pill on that point vertically and is why the
     script does not have to know the pill's own height. */
  transform: translateY(-50%);
  z-index: 2;
  pointer-events: none;
  padding: var(--space-2) var(--space-8);
  border-radius: var(--radius-full);
  background: var(--color-page);
  color: var(--color-accent-secondary);
  font: var(--weight-medium) 0.6875rem/1rem var(--font-sans);   /* 11/16 */
  white-space: nowrap;
}

/* The two gaps the connectors run through. Empty on purpose: they hold no
   markup now that the lines live in the layer above, they only reserve the
   room. Equal, and the only columns allowed to shrink — on a narrow viewport
   they squeeze before any card does, and the paths follow because they are
   measured. 11.5rem is the frame's own ~190px. */
.dashboard-flow__gap {
  flex: 1 1 11.5rem;
  min-width: 2rem;
}

/* The channel and product stacks. --space-8 between cards is the frame's own
   gap (its rows sit on a 49px pitch over a 41px card). */
.dashboard-flow__col {
  flex: none;
  display: flex;
  flex-direction: column;
  gap: var(--space-8);
}

/* Wider than the frame's 161/155px, the same reason the flow this replaces
   was: --text-body-md (15px) sets an amount wider than the frame's own 14px
   does, and the amount, the trend and a 56px logo slot have to sit on one
   line whatever the typeface picker is set to. */
/* 14rem, up from 12 (2026-08-25, on request: "make the middle cards wider ...
   so there is more space between the logo and the value"). The width is the
   whole change: .dashboard-flow-channel's three tracks are logo (4.375rem) |
   1fr | trend (3rem), so the middle track is the only one that grows and the
   amount is right-aligned in it — every one of the 32px lands as gap between
   the logo and the value, and the amounts keep the single right edge that
   fixed outer tracks exist to give them. */
.dashboard-flow__col--channels { width: 14rem; }

/* Top-aligned, not centred with everything else (2026-08-25, on request) —
   three product cards centred against five channel cards left the first
   product sitting a row and a half below the first channel, and the taller
   channel cards above widened that gap. The frame top-aligns the two columns
   outright: its first product and its first channel row share a y. So this is
   the frame's own alignment. (That reasoning used to end "and the 'View more'
   link takes up the slack at the bottom" — the link is gone as of 2026-08-25,
   so the column simply ends after its third card. Top alignment is still what
   keeps the first product level with the first channel row, which is the part
   that matters.)
   The GMV card stays centred — it is the fan's hub, and the frame centres it
   on the middle channel row. */
.dashboard-flow__col--products {
  /* 14.5rem, up from 11.5 (2026-08-25, on request — "increase height and/or
     width of these cards as needed"): the name went to body-md and the
     thumbnail to 38px, and at the old width two lines of 15px type had ~120px
     to work in, which cut most of the fixture's names off. 232px leaves the
     name 168px, enough for the longest of them ("Dyson Supersonic Hair Dryer
     Rose Gold") in the two lines the clamp allows. The two gaps absorb it,
     the same way they absorb the element's own side inset. */
  width: 14.5rem;
  align-self: flex-start;
}

/* GMV card — the first fan's hub. Kept as .dashboard-flow__summary: same
   element in the same slot (a centred label/big-number/date-range card),
   with the label row gaining the gear. Figma draws it with a drop shadow;
   elevation is reserved for interactive elements here (CLAUDE.md), so it
   takes the same 1px outline as its neighbours instead. */
.dashboard-flow__summary {
  flex: none;
  /* The gear is positioned against the card. */
  position: relative;
  display: flex;
  flex-direction: column;
  align-items: center;
  gap: var(--space-8);
  /* 12.5rem = the frame's 201px. Up from 10rem: the label row now has to
     clear the gear pinned to its right. */
  width: 12.5rem;
  /* 24px left and right, --space-16 top and bottom (2026-08-25, on request).
     This SUPERSEDES the horizontal padding that briefly sat on
     .dashboard-flow__summary-value instead: the inset belongs to the card, so
     the label row, the amount and the date all share one left and right edge —
     with it on the value only, the number was inset and the two lines around it
     were not. Both steps are real ones; no literal. */
  padding: var(--space-16) var(--space-24);
  text-align: center;
  /* The frame's own gradient — white at the top to Blue/B5 at the bottom,
     178deg, rounded here to a straight 180. B5 is exactly --color-chip's
     value, so both stops are tokens and no colour is introduced. Overrides
     .card's flat --color-surface; proposals.css loads after elements.css, so
     one class beats one class on source order. */
  background: linear-gradient(180deg, var(--color-surface), var(--color-chip));
}

/* Stretched so the label stays centred on the card, not on the space left
   over beside the gear — the gear is out of flow, so there is nothing to
   balance it and centring the row's content would be centring it against the
   card anyway. Kept as its own row for the same reason the frame has one:
   the two belong on the same line.

   ALIGNED TO THE GEAR, 2026-08-27 (on request: "align the GMV label with the
   settings icon, the GMV label needs to move a bit higher up"). They were on
   the same line only in the sense of being near each other — the label's centre
   sat 6px below the gear's, which at this scale reads as one of them having
   slipped. The arithmetic, all of it from tokens:

     gear centre   = --space-12 (its own top) + --icon-size / 2   = 12 + 8 = 20
     label centre  = --space-16 (the card's pad) + line box / 2   = 16 + 10 = 26

   So rather than nudging the label up by the 6px difference — a literal, and one
   that silently goes wrong the moment the card's padding or the gear's inset
   moves — this row is given the gear's OWN box: the same height, starting at the
   same top. Its centre then lands on the gear's by construction, and it keeps
   landing there if either token changes.

   height is --icon-size, 4px under the label's own 20px line box, so the text
   overflows 2px above and below. Nothing clips it (no overflow is set anywhere
   on this card) and the row has no background or border to reveal the
   difference — the box is here to position the text, not to contain it.

   The margins keep everything BELOW exactly where it was. -4 lifts the row from
   the card's padding to the gear's inset; the box then loses 4px of its own
   height, so +8 gives both back before .card's own --space-16 gap to the value:
   12 + 16 + 8 + 16 = 52, which is where the value started before this. The value
   and the date range have not moved; only the label has. */
.dashboard-flow__summary-head {
  align-self: stretch;
  display: flex;
  align-items: center;
  justify-content: center;
  height: var(--icon-size);
  margin-top: calc(var(--space-12) - var(--space-16));
  margin-bottom: var(--space-8);
}

/* "GMV" — the frame's 15px SemiBold. 15px is --text-body-md exactly; 600 is
   not a weight this system has (regular and medium only), so it takes
   --weight-medium. It was body-md REGULAR SECONDARY when this card said
   "Total revenue": the frame promotes the label to primary and medium, which
   is what makes it read as the card's title rather than its caption. */
.dashboard-flow__summary-label {
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-body-md) var(--font-sans);
}

/* Branding watermark — the ChannelEngine logomark washed into the background
   behind the GMV card. On the user's direct instruction (2026-08-27) with a
   screenshot and the asset, at the size they gave: 174 x 158.

   174/158 ARE INSTRUCTED LITERALS, and they are the asset's own intrinsic size
   (its viewBox is 0 0 174 158), so this states what the file already is rather
   than scaling it. Written in rem like every other dimension in this element, so
   it still honours the reader's browser font-size. Not spacing, so the --space-*
   scale does not govern them — a mark's dimensions are the same case as
   .badge__flag's own 12x15 and .dashboard-channel-tile__logo's 1rem height.

   NO OPACITY AND NO COLOUR HERE. The pale wash is inside the asset — three
   fill-opacity: 0.1 paths over its own two-stop gradient — which is why this is
   a file and not an inlined SVG tinted from a token. It also means the mark
   cannot drift from the brand's own artwork.

   HOW IT PAINTS BEHIND THE CARD, and why there is a wrapper for it. The obvious
   version — the mark as a child of the card with z-index: -1 — works only while
   the card creates no stacking context, and THE INTRO BREAKS EXACTLY THAT: it
   animates .dashboard-flow__summary's opacity, and any opacity below 1 makes the
   card a stacking context, which traps a negative-z child behind the card's own
   background. The mark would vanish for the length of that fade and pop in at
   the end.
   So the mark is a SIBLING placed earlier in DOM order instead, inside a wrapper
   that exists for no other purpose. Earlier siblings paint first, so it sits
   behind the card by document order alone — no z-index anywhere, and nothing to
   break if the card ever gains an opacity, a transform or a hover lift. The
   wrapper is what the mark positions against, which is also what keeps "up and
   left of the GMV card" true at every page width without measuring anything.

   The offset is a fraction of the mark's OWN box, not a length — the card's
   top-left corner lands part-way into it, which is what the screenshot shows.
   Expressed as percentages so the framing survives a change to the size above.
   (The original framing was a quarter across and a fifth up from the bottom;
   the four nudges below have since moved it out to the values in the rule.)

   NUDGED FOUR TIMES NOW (2026-08-27: 24 left and 24 down, then 16 lower again;
   2026-09-08: "move the channelengine logo backdrop 32px lower and to the left").
   The first three were carried as `- var(--space-24)` style corrections ADDED to
   the percentages, so the framing and the nudges stayed legible as separate parts.
   That chain has been RE-DERIVED INTO THE PERCENTAGES, which is exactly what the
   old note said to do rather than adding a third term to it:

     x: -25% of 174 = -43.5, minus 24 minus 32 = -99.5px  ->  -57.2%
     y: -80% of 158 = -126.4, plus 24 plus 16 plus 32 = -54.4px  ->  -34.4%

   So the two numbers below are still pure fractions of the mark's OWN box and the
   framing still survives a change to the size above — which is the property the
   correction terms were protecting, and the reason this is not folded into a pair
   of px literals instead. The arithmetic above is the history; the values are the
   position. Next nudge: redo that sum, do not re-open the chain.
   -------------------------------------------------------------------------- */
.dashboard-flow__hub-wrap {
  position: relative;
  /* The card was the flex item here before the wrapper existed; it has to keep
     its own width, so the wrapper must not stretch or shrink around it. */
  flex: none;
  display: flex;
}

.dashboard-flow__watermark {
  position: absolute;
  left: 0;
  top: 0;
  width: 10.875rem;    /* 174px */
  height: 9.875rem;    /* 158px */
  transform: translate(-57.2%, -34.4%);
  /* Decoration over the gap beside the card — it must never take a click on the
     way past, and it is aria-hidden in the markup for the same reason. */
  pointer-events: none;
}

/* THE DEFAULT SHELL SITS IT 32px RIGHT AND 32px UP FROM THAT (2026-09-08, on
   request: "move the background logo on the dashboard page in the default shell
   32px to the right and 32px up").

   THE FIRST SHAPE-SCOPED POSITION THIS MARK HAS HAD, and the reason it is warranted
   rather than a fourth nudge to the shared value: the two shells frame this card
   differently. The l-shape puts the dashboard on a lifted sheet inset from the rail
   and the header, so the mark washes over a card edge; the default shell has the page
   running straight into the rail, and the same offset carries the mark further into
   the corner than the framing wants. The rule above stays the l-shape's position and
   is still the value every other shape inherits.
   ARITHMETIC, in the same form the note above uses, so the next pass has both:
     x: -57.2% of 174 = -99.5, plus 32 = -67.5px  ->  -38.8%
     y: -34.4% of 158 = -54.4, minus 32 = -86.4px  ->  -54.7%
   POSITIVE GUARD, per the L-SHAPED SHELL section's own rule: `html[data-shell-shape=
   "default"]`, not a :not() on the l-shape. The attribute is written by
   applyShellShape() on every load whichever shape is chosen, so there is no state in
   which it is absent and this fails to match. ("default" was SHELL_SHAPES[0] when
   this was written; since 2026-09-09 the l-shape leads and "default" is the id of
   the SEPARATED shell, labelled "Separated" in the panel — the id stayed put so
   selectors like this one did not have to move. The guard is unaffected either way,
   which is the point of writing it positively.) */
html[data-shell-shape="default"] .dashboard-flow__watermark {
  transform: translate(-38.8%, -54.7%);
}

/* THE ONE THEME-SCOPED RULE IN THE SYSTEM, and it is here for the reason the
   shell's tenant logo has its own (prototypes/app/sidebar-brand-logo.css): this
   is FIXED ARTWORK, so its ink is inside the file and no token reaches it.
   Everything else a theme changes is a token repoint.
   The wash is three fill-opacity: 0.1 paths over the asset's own navy gradient —
   pale against a light page, and against Dark's near-black a dim navy arrow, the
   one blue shape left on a screen that was deliberately neutralised. brightness(0)
   invert(1) flattens the artwork to white first and then keeps the file's own
   opacities, so it becomes the same 10% wash in the other direction. Not plain
   invert(1), which turns the navy a warm cream — the same trap, and the same fix,
   as the tenant mark's note. */
:root[data-theme="dark"] .dashboard-flow__watermark {
  filter: brightness(0) invert(1);
}

/* Trend and date range on one line under the GMV figure, in that order
   (2026-08-27, on request). --space-8 between them: they are two separate
   statements about the same number, not one phrase, so they take a real
   layout step rather than the optical --space-2 that sits inside the trend
   itself. Centred, like everything else in this card. */
.dashboard-flow__summary-foot {
  display: flex;
  align-items: center;
  justify-content: center;
  gap: var(--space-8);
}

/* A bare icon, no control box — as the frame draws it, and the same shape
   .dashboard-promo__close already uses on this page. Inert: there is no
   second GMV window to configure, the same "trigger with nothing wired"
   precedent as the view switch above and the Channels card's own tabs.
   16/12 from the card's edges is the frame's own inset (top 12, right 17),
   and both are --space-* steps. */
.dashboard-flow__summary-settings {
  position: absolute;
  top: var(--space-12);
  right: var(--space-16);
  display: flex;
  padding: 0;
  border: 0;
  background: none;
  color: var(--color-text-secondary);
  cursor: pointer;
}

.dashboard-flow__summary-settings:hover {
  color: var(--color-text-primary);
}

/* BESPOKE 46px, and a deliberate break of "only the five named sizes"
   (2026-08-25, on the user's direct instruction — "use a bespoke size of the
   GMV value, 46px"). It was --text-heading-2xl, the largest existing step at
   28/32, which is nowhere near the number this card is built around.
   46/55 is the frame's own pair: font/size 46 over the 55px line box its text
   node measures. Written in rem like every other size here, so it still
   honours the reader's browser font-size setting.
   The tracking IS now included (2026-08-27, on request: "reduce letter spacing
   to -5% specifically for this text only"). -0.05em against 46px is -2.3px —
   the frame's own tracking, arrived at from the other end. Written in em, not
   px, so it stays -5% of whatever this value's size is rather than drifting if
   the 46 ever moves. NOT --tracking-identifier: that token is 1px POSITIVE and
   explicitly scoped to .identifier. This is a second scoped exception on the
   same element, not a reference to it, and like the size it is off limits to
   anything else.
   SCOPED TO THIS ONE VALUE. Nothing else may reference it, the same way the
   order detail's page-local Barlow scale is scoped to its own header — and it
   feeds the same open question docs/proposals.md already carries: may a page
   (or an element) hold its own type scale at all, and if so through what
   sanctioned mechanism. */
/* NO tabular-nums (2026-08-25, on request). CLAUDE.md's rule is that a figure
   read DOWN a column with other figures gets tabular — an identifier, a table
   money cell, a stat in a list. This one is a single standalone number, the
   only thing at this size on the page, with nothing above or below it to align
   to; at 46px a padded 1 just opens a visible gap inside the amount. The
   channel rows' own amounts further down the flow DO sit in a column and keep
   theirs. */
.dashboard-flow__summary-value {
  color: var(--color-text-primary);
  font: var(--weight-regular) 2.875rem/3.4375rem var(--font-sans);   /* 46/55 */
  /* -5% of the size above. See the note on tracking in the block comment. */
  letter-spacing: -0.05em;
}

/* Channel card — logo slot, amount, trend. A grid, not a flex row, and all
   three tracks are FIXED but the middle: that is what puts every amount in
   the stack on one right edge, including the "Others" row, whose trend cell
   is empty. A flex row would let each amount sit wherever its own trend
   ends. */
.dashboard-flow-channel {
  display: grid;
  /* First track = .dashboard-flow-channel__logo's width; they moved together
     from 3.5rem on 2026-08-25. Keep them equal. */
  grid-template-columns: 4.375rem 1fr 3rem;
  align-items: center;
  gap: var(--space-8);
  /* A selectable channel is a real <button> (Enter/Space and focus for free),
     the "Others" row a plain div — so the type and alignment a button brings
     with it have to be undone here, or the two rows would not match. Each
     cell states its own font below regardless; this covers the box itself. */
  font: inherit;
  text-align: left;
  /* --space-12 all round, up from 8 vertical (2026-08-25, on request — "make
     the cards with channels in the middle taller"). Row height goes 38 -> 46,
     which also lands closer to the frame's own 41px against a 50px product
     card: it draws the products taller than the channels, and at 8 the
     channel card was the taller of the two. */
  padding: var(--space-12);
  background: var(--color-surface);
  /* Card outline at 8% black, not the general --color-outline (2026-08-25, on request). */
  /* 12% with every other card (2026-09-16) — see .card in elements.css. */
  border: 1px solid var(--color-outline-container);
  border-radius: var(--radius-sm);
}

/* Only a channel is selectable — "Others" is an aggregate with no products
   behind it, so it never invites a click. */
.dashboard-flow-channel--selectable {
  cursor: pointer;
  /* Picking a channel is a state change, not a jump (2026-08-25, on request).
     0.15s is not a new number — it is the one duration this prototype already
     uses everywhere (see docs/proposals.md, "The prototype has motion; the
     system has no motion tokens"). Only the two properties selection actually
     changes are listed; transitioning `all` would drag the hover fill through
     the same curve and make the row feel sluggish to point at. */
  transition: background-color 0.15s ease, box-shadow 0.15s ease;
}

.dashboard-flow-channel--selectable:hover {
  background: var(--color-chip);
}

/* The selected channel is where the second fan starts, so it has to read as
   picked rather than merely hovered. Colour plus the small elevation step
   (2026-08-25, on request — an accent stroke was tried first and dropped):
   --color-chip fill and --elevation, the subtlest of the three, so the card
   lifts off the page without shouting. Its border stays --color-outline, the
   same as every other card in the column.
   Elevation is legal here despite "never on cards": this card is a <button>
   and elevation marks the interactive, selected thing — the same reasoning
   .segmented__item--active is raised on its own track (docs/elements.md). */
.dashboard-flow-channel--selected {
  background: var(--color-chip);
  box-shadow: var(--elevation);
}

/* A fixed slot, not the logo's natural width: the marks run 41 to 54px wide
   in the frame alone, and a straight column of amounts beside a ragged
   column of logos is the wrong trade. object-position pins each mark to the
   slot's left edge, so the logos line up with each other as well. Same
   fixed-slot reasoning as the Orders table's Channel column
   (.badge__flag-circle's ledger row). */
/* Bumped 1.25x, 2026-08-25 on request ("increase the logo size a bit"):
   3.5rem/1rem -> 4.375rem/1.25rem. BOTH axes, by the same factor — the slot is
   object-fit: contain, so raising only the height would let a wide mark stay
   pinned to the old width and not grow at all, while raising only the width
   would do nothing for a tall one. The grid's first track moves with it (see
   .dashboard-flow-channel) or the slot and its column disagree.
   rem literals, like the 3.5/1 they replace and like .badge--logo img's own
   heights: a mark's dimension is not something the system tokenises. */
.dashboard-flow-channel__logo {
  width: 4.375rem;
  height: 1.25rem;
  object-fit: contain;
  object-position: left center;
}

/* "Others", and the text fallback for a channel with no logo asset — both
   sit in the logo's own slot, which is what keeps the row shape identical
   whichever it is. */
.dashboard-flow-channel__label {
  grid-column: 1;
  color: var(--color-text-primary);
  font: var(--weight-regular) var(--text-body-md) var(--font-sans);
  /* The slot is 56px and "marktplaats" is not; a wrapped label would make
     this row taller than the rest of the stack. */
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}

/* "Others" as a text button (2026-08-25, on request): accent-primary,
   underlined on hover. NOT .btn--text, which is a 32px control with its own
   horizontal padding — dropping one into a 46px row would both blow the row's
   height and push the label out of the logo's slot, breaking the column the
   labels and logos share. Styled as text instead, the same call
   products.html's own "Active in N marketplaces" row documents ("a bordered
   control in a row of identifier pills would read as a form field"), and the
   same treatment .dashboard-flow-product__name above already uses for a
   product name. A real <button>, so it is keyboard-reachable — inert for now,
   like the GMV card's gear: the frame gives it nowhere to go. */
.dashboard-flow-channel__label--action {
  padding: 0;
  border: 0;
  background: none;
  text-align: left;
  color: var(--color-accent-primary);
  font: var(--weight-regular) var(--text-body-md) var(--font-sans);
  cursor: pointer;
}

.dashboard-flow-channel__label--action:hover {
  text-decoration: underline;
}

/* The frame's 14px Medium -> --text-body-md medium, the nearest step. */
.dashboard-flow-channel__amount {
  text-align: right;
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-body-md) var(--font-sans);
  font-variant-numeric: tabular-nums;
}

/* The tail row's amount when it is a COUNT rather than a euro figure — "5
   channels" in the outliers view (2026-09-09). It takes the trend cell as well,
   which is empty on that row in both views: at 66px the amount track wraps it
   onto two lines and makes the row taller than the four above it. A money
   figure keeps the plain class and stays in its own track, right edge aligned
   with every row above — see flowTailHTML() in dashboard.html. */
.dashboard-flow-channel__amount--wide { grid-column: 2 / 4; }

/* --space-2 between the arrow and the figure is optical work inside a
   control, which is what that step is for.

   SHARED WITH THE GMV CARD'S OWN TREND since 2026-08-27, when that card gained
   the same arrow + % in line with its date range. One rule for both, not a
   lookalike class: two trends on one page must read as one mark, and the
   colour rules below are the part that would have been copied wrong.
   justify-content is a no-op on the summary's copy — it has no free space to
   distribute, being content-sized — so it costs nothing to share. */
.dashboard-flow-channel__trend,
.dashboard-flow__summary-trend {
  display: flex;
  align-items: center;
  justify-content: flex-end;
  gap: var(--space-2);
  font: var(--weight-regular) var(--text-body-sm) var(--font-sans);
  font-variant-numeric: tabular-nums;
}

/* THE WHOLE TREND takes the colour, arrow and percentage alike (2026-08-25,
   on request: "make the % that show increases or decreases use the same
   green/red as the arrows"). It was arrow-only, with the figure on
   --color-text-secondary.
   --color-success-text / --color-error-text, NOT the fill pair: this is 13px
   type, and --color-success measures 2.32:1 against --color-surface. The
   text-grade pair was added to tokens.css the same day on the user's decision,
   after the numbers for all three candidates (the fill green, Figma's own G80,
   and one that actually passes) were put in front of them — see that file for
   which won and why it is not G80. Both now clear 4.5:1 on --color-surface and
   on --color-chip, which are the two fills this row sits on.
   Set on the row, and the icon inherits it — the SVG draws with currentColor,
   so nothing else is needed. */
.dashboard-flow-channel__trend--up,
.dashboard-flow__summary-trend--up { color: var(--color-success-text); }
.dashboard-flow-channel__trend--down,
.dashboard-flow__summary-trend--down { color: var(--color-error-text); }

/* Product card — thumbnail and name, nothing else. The revenue figure the
   previous flow's product rows carried is gone with them: this frame's card
   has no value on it, and the column now answers "which products" for one
   channel rather than "how much" overall. */
.dashboard-flow-product {
  display: flex;
  align-items: center;
  gap: var(--space-8);
  padding: var(--space-8);
  background: var(--color-surface);
  /* Card outline at 8% black, not the general --color-outline (2026-08-25, on request). */
  /* 12% with every other card (2026-09-16) — see .card in elements.css. */
  border: 1px solid var(--color-outline-container);
  border-radius: var(--radius-sm);
}

/* 32px thumbnail on the neutral background the product tiles already use for
   theirs (.product-card__thumb-wrap), so a transparent PNG doesn't float.
   --radius-xs inside the card's own --radius-sm, outer step larger than
   inner. */
.dashboard-flow-product__thumb-wrap {
  flex: none;
  /* 38px (2026-08-25, on request), up from 32. A literal on the same footing
     as .badge__flag's own 12x15 and .badge--logo img's 14/18 heights — a
     mark's dimension, not spacing, and the system tokenises neither. */
  width: 2.375rem;
  height: 2.375rem;
  border-radius: var(--radius-xs);
  background: var(--color-background);
  overflow: hidden;
}

.dashboard-flow-product__thumb {
  display: block;
  width: 100%;
  height: 100%;
  object-fit: cover;
}

/* A clickable product name, styled the way every other one in the system is:
   --color-accent-primary, medium, underline on hover — .product-card__name
   (elements.css), .preview-popover__name (this file) and
   .order-detail__item-name (orders.html) all say the same thing. The size is
   --text-body-sm here, not body-md: the frame's own is 13px, which is that
   token exactly, and a 176px card is not a place to spend the larger step.
   min-height reserves both lines the clamp allows, so a one-line name does
   not make a shorter card than its neighbours. */
.dashboard-flow-product__name {
  min-width: 0;
  display: -webkit-box;
  -webkit-line-clamp: 2;
  -webkit-box-orient: vertical;
  overflow: hidden;
  /* 2 x --text-body-md's own 1.5rem line-height, not a new literal. */
  min-height: 3rem;
  color: var(--color-accent-primary);
  /* body-md (2026-08-25, on request), up from body-sm. The frame's own name is
     13px, which body-sm matched exactly — this is a deliberate step past the
     frame, and the card grew to hold it. */
  font: var(--weight-medium) var(--text-body-md) var(--font-sans);
  cursor: pointer;
  /* A real <a>, unlike .product-card__name's <span> — so the underline has to
     be turned off before :hover can turn it back on. */
  text-decoration: none;
}

.dashboard-flow-product__name:hover {
  text-decoration: underline;
}

/* The name and its figure as one column, in the OUTLIERS view only (2026-09-09).
   Emitted by flowProductHTML() only when there is a delta to show, so the GMV
   view's card keeps the DOM it has always had — see that function's own note
   for why the figure goes under the name rather than beside it.
   min-width: 0 because the name inside it clamps, and a flex item will not
   shrink below its content without it. */
.dashboard-flow-product__text {
  min-width: 0;
  display: flex;
  flex-direction: column;
  gap: var(--space-2);
}

/* How much of its channel's swing this product is carrying. Signed, tabular and
   in the same success/error text pair as every other movement figure on this
   page (.dashboard-flow-channel__trend, .dashboard-flow__summary-trend) — one
   green and one red across the element, not a third pair for a third place a
   number can go up. --text-body-sm against the name's body-md, so it reads as
   the supporting line it is. */
.dashboard-flow-product__delta {
  font: var(--weight-medium) var(--text-body-sm) var(--font-sans);
  font-variant-numeric: tabular-nums;
}

.dashboard-flow-product__delta--up { color: var(--color-success-text); }
.dashboard-flow-product__delta--down { color: var(--color-error-text); }

/* The arriving products fade in when a channel is picked. An animation, not a
   transition: the cards are new elements every swap, so there is no old value
   to interpolate from — and an animation restarts on its own each time the
   class lands on a fresh element. renderFlowProducts() adds it only for a
   selection, so the first render on page load does not replay it. 0.15s, the
   prototype's one duration.

   DELAYED BY THE DRAW (2026-08-27, with the change that made the second fan
   grow rather than slide — see .dashboard-flow__links--animated below). The
   0.3s delay is the draw's own duration, so a card appears as the line
   reaches it rather than sitting there waiting to be connected to. That is
   the "products re-appear" half of the request: they now arrive because
   something arrived at them.

   SLOWED, same day, on request ("the way products appear when I click different
   channels is too fast"). Both halves of the gesture moved, since it is the
   whole thing that read quick: the draw went 0.18s -> 0.3s and this fade
   0.15s -> 0.24s, so a selection now takes 0.54s end to end against 0.33s. The
   fade stays a little shorter than the draw so the sequence does not drag at the
   end — the line arriving is the event, the card is the confirmation.

   `backwards` is load-bearing, not decoration. Without it the card renders at
   full opacity for the whole delay and then blinks out to 0 to start the fade
   — the fill mode is what makes it hold the keyframe's `from` until its turn.
   Nothing staggers the three: they all sit at the same left edge, so their
   lines all complete together, and dealing them out one at a time would be a
   rhythm the geometry does not have. */
@keyframes dashboard-flow-product-in {
  from { opacity: 0; }
  to   { opacity: 1; }
}

.dashboard-flow-product--fade {
  animation: dashboard-flow-product-in 0.24s ease 0.3s backwards;
}

/* --------------------------------------------------------------------------
   Intro — the flow assembling itself on first open (2026-08-27, on request).
   Flagged as possibly reverting right away: REVERT = set FLOW_INTRO to false in
   dashboard.html and delete this block. Nothing else references either class.

   TWO classes, and the split is the whole trick. `--intro` only HIDES, and goes
   on before the cards are ever rendered, so nothing is painted at full opacity
   and then blanked. `--intro-run` attaches the animations, and lands when the
   timeline actually starts — which is after the webfont has settled, an unknown
   delay later. One class carrying both would have every delay below counting
   from page load instead of from the first step, and the fades would drift out
   of step with the lines they are supposed to follow.

   The delays are the JS timeline's own steps (see runFlowIntro), so each set of
   cards appears exactly as the fan pointing at it lands:
     0.00s  GMV card          — the first fan leaves it at 0.24
     0.54s  channel cards     — the first fan lands on them at 0.54
     0.94s  product cards     — the second fan lands on them at 0.94
   ending at 1.2s (2026-08-27, on request — 0.75s, then 1.0s, then 1.5s, now
   this). `backwards` on every one, for the same reason
   .dashboard-flow-product--fade needs it: without the fill mode a card sits
   opaque through its delay and then blinks to zero to start its fade.

   The channel cards fade over 0.34s where the other two take 0.24 and 0.26,
   asked for directly. Five cards arriving at once read faster than one or three
   at the same duration, so they are the one fade deliberately out of step.
   -------------------------------------------------------------------------- */

/* The hub WRAPPER, not the card — so the branding watermark fades in with the
   card it sits behind rather than being there before it. */
.dashboard-flow--intro .dashboard-flow-channel,
.dashboard-flow--intro .dashboard-flow-product,
.dashboard-flow--intro .dashboard-flow__hub-wrap {
  opacity: 0;
}

@keyframes dashboard-flow-intro-in {
  from { opacity: 0; }
  to   { opacity: 1; }
}

.dashboard-flow--intro-run .dashboard-flow__hub-wrap {
  opacity: 1;
  animation: dashboard-flow-intro-in 0.24s ease backwards;
}

.dashboard-flow--intro-run .dashboard-flow-channel {
  opacity: 1;
  animation: dashboard-flow-intro-in 0.34s ease 0.54s backwards;
}

.dashboard-flow--intro-run .dashboard-flow-product {
  opacity: 1;
  animation: dashboard-flow-intro-in 0.26s ease 0.94s backwards;
}

/* UNUSED since 2026-08-25 — the link was removed from renderFlowProducts() in
   dashboard.html on request. Kept rather than deleted, matching how this page
   already parks .dashboard-revenue, .dashboard-kpis and .dashboard-promo; there
   is no version control here to recover it from. Nothing renders it today.

   "View more" — the frame's own trailing link, under the last product card
   and aligned to the column's right edge. Not a .btn: it is a link to the
   Products page, and a bordered control at the end of a column of cards
   would read as an action on the column. */
.dashboard-flow__more {
  align-self: flex-end;
  display: inline-flex;
  align-items: center;
  gap: var(--space-2);
  color: var(--color-accent-primary);
  font: var(--weight-medium) var(--text-body-sm) var(--font-sans);
  text-decoration: none;
}

.dashboard-flow__more:hover {
  text-decoration: underline;
}

/* Every one of the three above is decoration: the selection is legible from
   the fill and the shadow alone, the fan lands in the right place either way,
   and the products are the same products. So they all come off together. */
@media (prefers-reduced-motion: reduce) {
  .dashboard-flow-channel--selectable,
  .dashboard-flow__links--animated path,
  .dashboard-flow__links--animated circle {
    transition: none;
  }

  .dashboard-flow-product--fade {
    animation: none;
  }

  /* dashboard.html does not start the intro under reduced motion at all, so
     these classes should never land. Stated anyway: a card left at opacity 0
     is not a degraded animation, it is missing content. */
  .dashboard-flow--intro .dashboard-flow-channel,
  .dashboard-flow--intro .dashboard-flow-product,
  .dashboard-flow--intro .dashboard-flow__hub-wrap,
  .dashboard-flow--intro-run .dashboard-flow-channel,
  .dashboard-flow--intro-run .dashboard-flow-product,
  .dashboard-flow--intro-run .dashboard-flow__hub-wrap {
    opacity: 1;
    animation: none;
  }
}

/* --------------------------------------------------------------------------
   Channels list — one tile per connected channel.

   Built 2026-08-21, when the sidebar's "Channels" row stopped pointing
   straight at the one connected channel and got a list page of its own (see
   js/routes.js in the app prototype). Only Bol.com is connected in the mock
   data, so the page shows exactly one tile.

   The tile is deliberately the same box as .product-card (elements.css) —
   same border, radius, surface, hover lift, same 262px column — because it
   plays the same role: a tile in a grid that opens the thing it names. It is
   NOT .product-card itself; that element is specced as a product tile, and a
   channel is not a product. Reused by mirroring, not by borrowing the class.
   -------------------------------------------------------------------------- */

/* repeat(auto-fill, 16.375rem), not minmax(...,1fr) like .products-grid: with
   a single channel connected, a 1fr track would stretch that one tile across
   the whole page. Fixed columns keep it product-card sized however many
   there are. 16.375rem is the same 262px floor the products grid uses. */
.channels-grid {
  display: grid;
  grid-template-columns: repeat(auto-fill, 16.375rem);
  gap: var(--space-16);
}

.channel-card {
  display: flex;
  flex-direction: column;
  background: var(--color-surface);
  /* Card outline at 8% black, not the general --color-outline (2026-08-25, on request). */
  /* 12% with every other card (2026-09-16) — see .card in elements.css. */
  border: 1px solid var(--color-outline-container);
  border-radius: var(--radius-sm);
  overflow: hidden;
  cursor: pointer;
  /* Same properties and timing as .product-card's own transition, so a
     channel tile and a product tile settle at the same rate. */
  transition: background-color 0.12s ease, box-shadow 0.12s ease;
}

.channel-card:hover {
  background: var(--color-chip);
  box-shadow: var(--elevation);
}

/* The logo panel stands where a product tile's thumbnail does, at the same
   16/9 the products grid gives its own, on the same --color-background fill.
   A channel has artwork, not a photo, so the logo is centred at its own size
   rather than cropped to fill. */
.channel-card__mark {
  display: flex;
  align-items: center;
  justify-content: center;
  aspect-ratio: 16 / 9;
  background: var(--color-background);
}

/* A channel with no logo asset falls back to its short name as plain text —
   the same convention the dashboard's Channels list and its promo row use
   (docs/proposals.md, "Amazon and Allegro have no logo asset"). */
.channel-card__mark-text {
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-heading) var(--font-sans);
}

.channel-card__body {
  display: flex;
  flex-direction: column;
  align-items: flex-start;
  gap: var(--space-8);
  padding: var(--space-12);
}

/* Same treatment .products-grid gives .product-card__name — heading size, so
   a tile's title reads at card-title weight rather than as body copy. */
.channel-card__name {
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-heading) var(--font-sans);
}

/* --------------------------------------------------------------------------
   Settings page — .settings-*
   PROPOSAL. See docs/proposals.md.

   The styling controls that used to fill the account button's floating panel,
   rebuilt as a page (2026-08-27, on the user's instruction to move them into
   Settings). The panel's own .menu__label / .menu__radio pair is NOT reused:
   both are scoped to a 240px menu column, where this is a page whose rows run
   the width of a card. Same job, different container, so different classes.

   Each group is a real .card — the ratified element, unmodified, one per
   setting. That is what supplies the surface, the outline, the 16px padding
   and the --radius-md corner here; nothing below restates any of them. It also
   sidesteps the divider rule entirely: separate cards need no rules between
   groups, so there is no full-bleed border to get wrong.

   Radios are the browser's own, exactly as the panel's were ("use browser
   native radio buttons"), themed only by accent-color.
   -------------------------------------------------------------------------- */
.settings {
  display: flex;
  flex-direction: column;
  gap: var(--space-16);
  /* A settings form does not want to run the full width of a wide page — the
     radio rows would sit a long way from their labels. 45rem against the
     page's own cap, whichever is smaller. A max-width only caps, so on a
     narrow page this stops binding and the cards fill what they have. */
  max-width: 45rem;
}

/* Title and its optional WIP mark on one line, the mark pushed right. */
.settings-group__head {
  display: flex;
  align-items: center;
  gap: var(--space-12);
}

.settings-group__title {
  margin: 0;
  flex: 1;
  color: var(--color-text-primary);
  font: var(--weight-medium) var(--text-heading) var(--font-sans);
}

.settings-group__hint {
  /* Cancels .card's own 16px gap between the head and this line: a hint belongs
     to the title above it, and at 16 it read as a separate paragraph. The gap
     to the OPTIONS below stays 16, so each group reads as heading+hint, then
     choices. */
  margin: calc(var(--space-16) * -1 + var(--space-4)) 0 0;
  color: var(--color-text-secondary);
  font: var(--weight-regular) var(--text-body-sm) var(--font-sans);
}

/* Options wrap rather than scroll — Typography has five and the rest have two
   or three, so one row holds them at any width this page is read at, and a
   narrow window folds them into a second row instead of clipping. */
.settings-options {
  display: flex;
  flex-wrap: wrap;
  gap: var(--space-8) var(--space-16);
}

.settings-option {
  display: flex;
  align-items: center;
  gap: var(--space-8);
  color: var(--color-text-primary);
  font: var(--weight-regular) var(--text-body-md) var(--font-sans);
  cursor: pointer;
}

.settings-option input[type="radio"] {
  accent-color: var(--color-accent-primary);
  cursor: pointer;
}

/* A group with nothing behind it yet (Theme). The options are shown so the
   intent is legible, and disabled so nothing invites a click that does nothing
   — the WIP badge beside the title says why. Both the label and the input go
   dim, and neither takes the pointer cursor. */
.settings-option--wip,
.settings-option--wip input[type="radio"] {
  color: var(--color-text-secondary);
  cursor: default;
}

/* --------------------------------------------------------------------------
   .card__toolbar — the row of controls that narrows what a CARD shows.

   The same thing .table__toolbar is for a table (search, a scope dropdown, a
   filter trigger), and it pins the same way: a toolbar that scrolls away leaves
   the user looking at a filtered list with no way to change the filter without
   scrolling back. Ruled a system-wide rule on 2026-08-28, on the user's
   instruction — "have this toolbar fixed in tables and containers on scroll" —
   after the product detail's Attributes card scrolled its own search out of
   reach. See CLAUDE.md and docs/tables.md, "Scrolling behaviour".

   Not part of .table__toolbar. The two do the same job but live in differently
   built boxes: a table's toolbar sits inside a bordered shell that already has
   its own padding of 0, while a card carries --space-16 on all four sides, so a
   toolbar in a card has to cancel that padding to reach the card's edges and put
   its own back. One class covering both would be a rule with two bodies.

   `top` reads --sticky-header-height, the property a page writes onto its .page
   when its own header pins (see setStickyHeaderOffset() in products.html). With
   no pinned header the fallback is 0 and the toolbar stops at the scroll
   container's top edge, which is the plain case.
   -------------------------------------------------------------------------- */
.card__toolbar {
  display: flex;
  align-items: center;
  gap: var(--space-8);
  position: sticky;
  top: var(--sticky-header-height, 0px);
  /* Above the card's own rows, and above a .table__head if the card holds one —
     same reasoning .table__toolbar's own z-index carries: a menu opened from
     inside the toolbar must not be painted over by what scrolls under it. */
  z-index: 2;
  background: var(--color-surface);
  /* Out to the card's edges: the negative margins cancel .card's --space-16 on
     three sides so nothing scrolls past in the gutter beside the toolbar, and
     the padding puts the same inset back inside the row. Bottom margin stays 0 —
     .card's own gap supplies the space to the content below. */
  margin: calc(-1 * var(--space-16)) calc(-1 * var(--space-16)) 0;
  padding: var(--space-16);
  /* The card's own radius on the top two corners, since the toolbar's fill now
     runs into them — a square fill inside a --radius-md border shows the corner
     as a notch once the rows scroll under it. */
  border-radius: var(--radius-md) var(--radius-md) 0 0;
  /* The same 8% line .table__toolbar draws under itself, and for the same
     reason: once it is pinned over moving content, the row needs an edge. */
  border-bottom: 1px solid var(--color-outline-card);
}

/* ==========================================================================
   THE L-SHAPED SHELL — the chrome wraps the page, and the page is a card
   ==========================================================================
   CONSOLIDATED 2026-09-07, on request: "the l-shape and this New theme should be
   combined, under l-shape approach for the shell. The shell can be default
   (separated left side bar), or l shaped (mostly the new things we tried), themes
   then get applied to these visually ... the l shape and default differ by the way
   they visually treat global navigation, themes are just colours on these."

   THAT SENTENCE IS THE MODEL, AND IT IS WORTH STATING AS A RULE BECAUSE THE FILE
   SPENT A DAY BREAKING IT: shape is structure, theme is colour, and neither may do
   the other's job. Everything below is keyed on [data-shell-shape] and reads colour
   only through tokens; there is no [data-theme] selector left in this section.

   WHAT THE TWO SHAPES ARE (L-shaped is the DEFAULT of the two as of 2026-09-09 —
   see SHELL_SHAPES in js/shell.js. The other keeps the id "default" for the sake of
   selectors like the two in this file, and is labelled "Separated" in the panel):
     DEFAULT (the id) / SEPARATED (the label) — a left rail with its own
       border, a global header on --color-surface, and page content sitting
       directly on --color-page. No card, no notches, no strip. This is the app
       as it was before the sheet experiment, and it is now the plain option
       rather than the styled one.
     L-SHAPED — the rail and the global header are one continuous band of
       --color-sidebar wrapping the page (elements.css supplies the header's fill,
       its ink and the on-rail treatment of every control in it, and drops the
       rail's border so the fill turns the corner). The page is then a CARD inside
       that L: rounded on its left edge, lifted on --elevation-xl, filled with
       --color-page, with 24px of air above its content.

   WHAT WAS ABSORBED INTO IT. Two settings and a theme collapsed into this one
   option, and all three are gone from Settings:
     - The CONTENT SHEET (2026-09-07, "the main content feeling like it's coming on
       top of the left side bar with the top left and bottom left corner being
       rounded (12px)"), which was built on the DEFAULT shell and applied to every
       theme. Its radius, its strip and its notches are the card below.
     - SHELL STYLE: LAYERED (2026-09-05, from Figma 2258-17649), an inset white
       sheet around the page's own content. It was a second answer to the question
       the card now answers, and keeping both would have meant two sheets on one
       page. Deleted outright rather than left unreachable.
     - The NEW theme, whose whole structural half — header outside the card, header
       on the rail's colour, 24px top inset — is what this shape now is. Its palette
       (a pale blue rail on a white page) went with it, on the same request.

   THE GUARD IS ANCHORED TO `html` ON EVERY SELECTOR HERE AND HAS TO BE. The
   attribute lives on <html>; a bare [data-shell-shape="l-shaped"] .thing matches
   through <body> too, which is harmless for a positive test but was a real bug the
   first time this section used a negative one. The positive form is kept anyway so
   every selector in the section reads the same way.
   ========================================================================== */

/* THE CARD IS .page, NOT .shell__main. The header has to be OUTSIDE it — that is
   what makes the L an L — and .shell__main contains the header. [data-page-content]
   is not a candidate either: it is optional, and dashboard.html's [data-unbuilt-view]
   is a .page that is its SIBLING, so a card on the wrapper would be no card at all
   on the unbuilt state. Every view in every page is a .page. Several can exist at
   once (Orders' list and its detail) but only one is ever displayed, so only one is
   ever a card.
   .page is also already the right box for the job: it is the SCROLLER, so the radius
   clips its own scrolling content — including the sticky page header, which rounds
   into the card's top-left corner instead of running past it.
   LEFT CORNERS ONLY. The card runs to the window's right edge, where a radius would
   cut a notch out of the corner of the screen. --radius-shell-sheet is a scoped token
   tuned by eye at 12px (see tokens.css; it is not --radius-md, though they agree
   today) and the rail strip below reads the SAME token, so the colour behind a corner
   is exactly as wide as the corner that uncovers it.
   ELEVATION ON STATIC CONTENT, WHICH CLAUDE.md FORBIDS — RAISED, NOT SNUCK IN. The
   standing rule is "elevation on interactive elements only", with two existing
   exceptions, both insets that recess. This is a third and the opposite kind. The
   justification is that in this shape the shadow is the ONLY thing separating the
   card from the chrome around it — on Light the rail, the header and the card are
   all within 1.10:1 of each other — and the radius alone reads as a bite out of the
   sheet rather than a sheet over the rail. It is a token, not a literal. If the rule
   is meant to hold absolutely, this is the declaration to delete.
   ONE DECLARATION FOR EVERY THEME — --elevation-sheet, a token of the card's own, at
   half --elevation-xl's alpha with its geometry held (see its note in tokens.css for
   why "softer" is not the same as the next step down).
   A THEME MAY STILL REPOINT THAT TOKEN, and Light does, to a little over half again:
   its card is white against #ecf5fe chrome, a 1.10:1 boundary where the same shadow
   reads far heavier than it does over Classic's navy. That is not the "theme doing
   shape's job" the model forbids — the SELECTOR here names no theme and never will.
   A shadow's alpha is a colour over a ground and belongs in a theme block, which is
   where Dark has kept all four of its elevations since it shipped. */
html[data-shell-shape="l-shaped"] .page {
  /* A BAND OF CHROME DOWN THE RIGHT AND ALONG THE BOTTOM (2026-09-07, on request:
     "for a page that fits in the viewport add a bit of padding from the right/bottom
     edge of the main container, so a little band of colour is visible in the
     remaining space"). The card stops short of the window on those two sides and the
     shell's own fill shows through — which is what turns it from a panel wedged into
     the corner into an object sitting inside the L.
     MARGIN, NOT PADDING, despite the wording: padding would move the content in and
     leave the card itself against the edge, which is the opposite of the ask. The
     card is a flex child, so the margin comes out of its own box and the scroller
     inside it shortens to match.
     LEFT AND TOP STAY FLUSH. They are not "remaining space" — they are where the card
     meets the rail and the header, and a band there would break the L into three
     separate objects.
     CONSTANT, NOT CONDITIONAL ON THE PAGE FITTING. CSS cannot ask whether content
     fits, and a band that came and went with content length would be worse than one
     that is always there: .page is a scroller with a bounded height either way, so a
     long page scrolls inside the card and the band holds. What the request describes
     is when you NOTICE it, not when it should apply. */
  /* 12 on the right, 8 along the bottom (the right went 8 -> 12 on 2026-09-07, on
     request). They are deliberately not one value: the right band runs the full
     height of the window beside a card that is always there, and the bottom one is a
     short strip that disappears entirely the moment the page scrolls (see the rule
     below). Ask for them to match if the mismatch reads as an accident — this note is
     here so the next person does not "fix" it by hand. */
  margin-right: var(--space-12);
  margin-bottom: var(--space-8);
  /* ALL FOUR CORNERS NOW, where it was the left pair. With two edges off the window
     a square right side reads as unfinished — and the top corners simply notch
     against the header the way the left pair has always notched against the rail. */
  border-radius: var(--radius-shell-sheet);
  box-shadow: var(--elevation-sheet);
  background: var(--color-page);
}

/* THE CARD'S RIGHT CORNERS SURVIVE A SCROLLBAR (2026-09-16, on request: "the top right
   and bottom right corners of the container in the L shaped shell are sharp, make them
   rounded like the left ones, even if a scrollbar appears").
   THE RADIUS WAS NEVER MISSING — A SCROLLBAR WAS PAINTING OVER IT. .page is both the
   card and the scroller, and a classic (space-taking) scrollbar is drawn inside the
   element's padding box WITHOUT being clipped by its border-radius: the track's square
   top and bottom filled both right-hand corners, so the card read as sharp on that side
   while the left pair curved. Overlay scrollbars (macOS default) never showed it, which
   is why it survived this long.
   THE TRACK GOES TRANSPARENT, SO NOTHING SQUARE IS PAINTED THERE, and what shows in the
   corner is the card's own background — which IS clipped by the radius. The thumb is
   then kept out of the arc by a margin on the track, one --radius-shell-sheet at each
   end: the exact height the corner curves through, so the thumb starts where the edge
   is straight again. Both corners, so it holds whichever end you scroll to.
   SAME SCROLLBAR VOCABULARY .filter-select__options ALREADY USES — 8px wide, transparent
   track, --color-outline thumb, fully rounded — so the one styled scrollbar in the
   system and this one look like the same scrollbar.
   NOT THE STANDARD scrollbar-color/-width: from Chrome 121 those take precedence over
   ::-webkit-scrollbar, and the pseudo-elements are the only way to reach the TRACK's
   geometry (a margin), which is the whole mechanism here. Firefox has no equivalent and
   keeps its own scrollbar — the corner is square there, and there is no CSS answer for
   it short of moving the radius onto a non-scrolling wrapper.
   SCOPED TO THIS SHAPE: it is the only one whose page card has right-hand corners to
   lose — in Separated the page runs to the window's edge. */
html[data-shell-shape="l-shaped"] .page::-webkit-scrollbar {
  width: var(--space-8);
}

html[data-shell-shape="l-shaped"] .page::-webkit-scrollbar-track {
  background: transparent;
  margin-block: var(--radius-shell-sheet);
}

html[data-shell-shape="l-shaped"] .page::-webkit-scrollbar-thumb {
  background: var(--color-outline);
  border-radius: var(--radius-full);
}

/* A PAGE THAT SCROLLS RUNS OFF THE BOTTOM (2026-09-07, on request: "in a page that
   scrolls, like order details, the main container in l-shaped theme should not have
   rounded corners bottom left and bottom right").

   THE TWO HALVES OF THIS ARE ONE IDEA, and it is the same distinction the band above
   was asked for with — "for a page that FITS in the viewport". A card that fits is an
   object with a bottom edge, so it gets both corners and the 8px band under it. A card
   that does not fit has no bottom to draw: squaring the corners says the surface
   continues past the fold, which is what is actually true.
   THE MARGIN GOES WITH THE CORNERS, and that is a judgement rather than a literal
   reading of the request. Square corners floating 8px above the window's edge would
   read as a rectangle that stops for no reason — the corners and the gap are both
   saying "this is where the card ends", so either both go or neither does. The RIGHT
   band stays: the overflow is vertical, and nothing about the right edge changed.
   [data-page-scrollable] IS SET BY mountScrolledState() IN js/shell.js, which cannot
   be done in CSS — there is no selector for "this element has overflow". See that
   function for what it watches and why the observer had to grow childList to catch a
   table being filtered. */
html[data-page-scrollable][data-shell-shape="l-shaped"] .page {
  margin-bottom: 0;
  border-bottom-left-radius: 0;
  border-bottom-right-radius: 0;
}

/* ...UNLESS THE CARD ENDS IN A STICKY FOOT (2026-09-08, on the user's screenshot:
   "the bottom left corner in shell L shaped and bottom right corner should be rounded,
   so the sticky footer in the Orders table and the filters panel should have these
   rounded corners, now it's straight").

   THE RULE ABOVE IS STILL RIGHT FOR WHAT IT DESCRIBES: a card whose content runs past
   the fold has no bottom to draw, so squaring it says the surface continues. A card
   with a sticky foot is the opposite case wearing the same attribute — the page scrolls,
   so [data-page-scrollable] is set, but the foot is pinned to the card's bottom edge and
   that edge is on screen at all times. Squared, the pagination row ran into the window
   like a sheet cut off with scissors, which is what the screenshot shows.
   :has(.table__foot--sticky), i.e. the structural fact itself, rather than a page-local
   class or a second attribute from mountScrolledState(): the thing that makes the edge
   visible is that a descendant is pinned to it, and that is readable in CSS.
   THE CORNERS COME BACK WITH THE 8px BAND, not on their own — the card's own note on
   the scrollable rule says the two are one statement ("the corners and the gap are both
   saying this is where the card ends, so either both go or neither does").
   THE FOOT ITSELF NEEDS NOTHING. .page is the scroller and its radius clips its own
   scrolling content, sticky children included, so the pagination row is rounded by the
   card's corner rather than by a radius of its own. */
html[data-page-scrollable][data-shell-shape="l-shaped"] .page:has(.table__foot--sticky) {
  margin-bottom: var(--space-8);
  border-bottom-left-radius: var(--radius-shell-sheet);
  border-bottom-right-radius: var(--radius-shell-sheet);
}

/* .shell__main STOPS CLIPPING, AND ONLY IN THIS SHAPE. A box-shadow paints outside
   its own element but is still clipped by an ANCESTOR's overflow, and .shell__main's
   left edge is exactly where the rail begins — so the card's shadow was cut off at
   its own left edge, which is the one direction it exists to travel.
   NOT `overflow: clip` WITH A MARGIN, WHICH WAS TRIED AND IS A TRAP: Safari ships
   `overflow: clip` without overflow-clip-margin, so the margin is ignored, the clip
   falls back to the padding box, and all that survives is the wedge of shadow inside
   the card's own corner notch — a dark smudge in the corner and no shadow anywhere
   else. Both halves of "there's a weird corner ... and the shadow's not even visible"
   were that one declaration.
   `visible` HAS NOTHING LEFT TO GUARD. The overflow:hidden in elements.css predates
   [data-page-content] having its flex properties (see its note there); .page does the
   real scrolling and carries its own overflow-x: hidden, so nothing inside can spill
   sideways. Scoped to this shape so the guard stands where it was never questioned.

   BOTH BOXES, AND MISSING THE SECOND ONE IS WHY THE SHADOW APPEARED ON SOME VIEWS AND
   NOT OTHERS (fixed 2026-09-07, from two screenshots: "something wrong with shadows in
   l shaped light theme", and the earlier "the plugins page shows a shadow, but not
   orders" — which was the same bug and was misread at the time as a page-level
   difference).
   IT IS A VIEW-LEVEL DIFFERENCE, AND IT IS STRUCTURAL. A page's real view sits inside
   [data-page-content], which elements.css also gives overflow: hidden, for the same
   historical reason .shell__main has it. [data-unbuilt-view] is a .page that is a
   SIBLING of that wrapper, so it hangs directly off .shell__main. Unclipping only
   .shell__main therefore freed the unbuilt state's card and left every real view's
   card still clipped at a box its own size — no shadow at all. Two views of the same
   document, one shadowed and one not, which is exactly what the screenshots show.
   Any future box between .shell__main and .page has to be added here too. */
html[data-shell-shape="l-shaped"] .shell__main,
html[data-shell-shape="l-shaped"] [data-page-content] {
  overflow: visible;
}

/* 24px above the card's content, against --page-gutter's 16 elsewhere (2026-09-07,
   "in the main container increase top padding to 24px"). The card's other three
   sides keep the gutter: this is about content not starting hard against the one
   edge the eye lands on, which is the card's own top. A token repoint rather than a
   padding rule, so .page__body's shorthand stays in one place — see elements.css. */
html[data-shell-shape="l-shaped"] {
  --page-body-pad-top: var(--space-24);
}

/* THE STRIP BEHIND THE NOTCHES, and the reason the corners read as a card over the
   rail rather than as two bites out of it. A rounded corner reveals whatever is
   painted behind it, and behind .page is .shell, whose fill is --color-page — so on
   its own the notches show page colour. This paints the RAIL'S OWN IMAGE across a
   strip one radius wider than the rail, behind everything.
   THE IMAGE, NOT A FLAT COLOUR: the first attempt used a spread-less box-shadow on
   .sidebar, which can only be one solid colour, and on a rail with a lit top the
   corner showed a dark wedge against the lit rail two pixels to its left.
   --sidebar-fill-image is defined once on .shell (elements.css) for exactly this
   reason; both consumers are full-height and its stops are px from the top, so the
   strip and the rail render the same ramp and the seam is invisible.
   TWO LAYERS, DOWN FROM FOUR (simplified 2026-09-07 when the card gained its bands).
   The base fill is --color-sidebar rather than --color-page, and that one change
   collapsed the other two away:
     1. the rail's wash, sized to the strip. It has to be its own layer because a
        background-COLOR cannot be sized, and the wash is what keeps the notch
        matching the lit part of the rail two pixels to its left.
     2. --color-sidebar for the whole shell, which is now BOTH the flat block the
        wash sits on and the fill everywhere else.
   WHY THE BASE IS THE CHROME COLOUR: every part of .shell that is still visible is
   chrome. The card paints --color-page itself, so the shell's fill only shows in the
   notches and in the two bands the card's margins leave — and all three want to be
   the rail's colour, not the page's. It also retires the fourth layer, a --color-page
   cover over the top --app-header-height that existed only to hide the strip beside
   the header back when an 8px gap left it exposed. The card is flush under the header
   now, and the header is opaque and full width, so that band covers itself.
   Nothing about the rail changes: it keeps its width, its rows keep their measure,
   nothing reflows, and --sidebar-width still means the card's left edge, which two
   fixed overlays in this file depend on.
   IT DOES NOT TOUCH THE RAIL ITSELF — this is .shell's background and .sidebar
   paints its own fill on top of it, so the cover is invisible everywhere except the
   strip it is there to hide. */
/* THE WASH RUNS THE FULL WIDTH NOW, NOT JUST THE RAIL STRIP (2026-09-08, on the
   user's screenshot: "on the l shaped classic there is a weird effect on the top right
   side, remove any divider if those appear, also something weird with the sudden colour
   transition").

   THERE WAS NO DIVIDER — IT WAS A STEP IN THE FILL, which is worth saying because the
   fix is not where the line looks like it is. The l-shaped header paints
   --sidebar-fill-image across its whole width (elements.css), and that ramp is 150px
   tall measured from the top of the viewport; the header is 44px, so it ends about a
   third of the way down the ramp, still visibly lit on Classic. Below the header, in the
   band of chrome to the RIGHT of the card, this rule was painting the image only across
   a strip as wide as the rail — so the ramp simply stopped at the strip's edge and the
   right-hand band was flat --color-sidebar. Header at 30% glow, band at 0%, meeting on
   one horizontal line at y=44: a hard edge that reads as a stroke somebody drew.
   (The app-header's own border-bottom is already transparent in this shape, further
   down this file, so there was nothing to remove.)
   PAINTING IT EVERYWHERE COSTS NOTHING AND FIXES IT EXACTLY. The card covers the middle
   of the shell, so the image only ever shows in the notches beside the rail's corners
   and in the two bands the card's margins leave — and all of those want to be the same
   lit chrome the header and the rail are. Both elements' stops are px from the top and
   both start at y=0, so the header renders 0..44 of the ramp and the shell renders the
   same 0..44 behind it and 44..150 below: one continuous wash across the whole L, with
   no seam anywhere on it.
   --shell-sheet-strip IS GONE with the sizing that needed it. Its job was to make the
   image reach exactly one radius past the rail so the card's corner notches showed lit
   rail colour rather than flat; a full-width image does that by construction.
   THEMES WITH NO WASH ARE UNAFFECTED: Light and Dark set --color-sidebar-glow to
   transparent, so the image is a no-op and the shell is flat --color-sidebar exactly as
   before. This only ever showed on Classic, which is where it was reported. */
html[data-shell-shape="l-shaped"] .shell {
  background-image: var(--sidebar-fill-image);
  background-color: var(--color-sidebar);
}

/* NO DIVIDER UNDER THE L'S HEADER, AT ANY SCROLL POSITION (2026-09-07, on request:
   "don't show a global header divider at the bottom of the global header in l-shaped
   theme at all"). This went in three steps over the day — permanent, then scroll-only
   and re-coloured from the rail's ink, now gone — and the end state is the one the
   shape argues for: the header and the rail are one continuous band of --color-sidebar,
   and a line across it cuts the L in half. There is also nothing left for it to
   separate. The line's job is to catch content sliding under the header, and in this
   shape nothing does: the card is a separate object with its own edge and shadow, and
   it scrolls inside itself.
   HIGHER SPECIFICITY THAN THE BASE SCROLL RULE, WHICH IS THE POINT. elements.css keeps
   `html[data-page-scrolled] .app-header` at (0,2,1) painting --color-outline-card; this
   is (0,3,1) and wins in both states. The 1px border stays in the box and only its
   colour is withheld, so the header's height and every offset measured against it are
   unchanged — the same technique the base rule uses, for the same reason. */
html[data-shell-shape="l-shaped"] .app-header,
html[data-page-scrolled][data-shell-shape="l-shaped"] .app-header {
  border-bottom-color: transparent;
}

/* --------------------------------------------------------------------------
   FULL-WIDTH TABLES LOSE THEIR CONTAINER (2026-09-07, on request: "the table and
   its header could span across the entire width instead of being containerised").

   THE CARD IS ALREADY THE CONTAINER. In the default shell a .table is a white
   bordered surface floating on the tinted page, and the border is what says where
   the data starts. In the l-shape the page is itself a white bordered lifted card,
   so the table inside it is a second surface inset 16px from the first — two nested
   boxes saying the same thing, which is what "containerised" is describing. The
   table keeps its STRUCTURE and loses its SKIN.

   NEGATIVE SIDE MARGINS, NOT `padding: 0` ON THE BODY, and that is the one real
   decision here. Zeroing .page__body's padding is what the equivalent rule did under
   the old Layered style, and it worked there because that page's body held nothing
   but the table. Orders' body does not: the weekend-summary .card sits above the
   table and is a genuine card on the page, which should keep its inset. Pulling only
   the table out by the gutter it is inset by leaves every sibling alone.
   THE VERTICAL GUTTER STAYS. "Across the entire width" is about width; the table
   still needs air between it and the card above it, and between its foot and the
   bottom of the page.
   CHILD RADII HAVE TO BE ZEROED TOO — elements.css rounds .table's first and last
   child to match the corner this no longer has, and a rounded toolbar inside a square
   table reads as a rendering bug.
   SCOPED TO .page__body--full, i.e. the table pages (Orders, Products, and any other
   list that opts into a full-width body). A capped page's table is centred in a
   column narrower than the card and has no edge to run to, so breaking it out would
   just push it into the card's padding. Sticky behaviour is untouched: the toolbar
   and the foot pin on their own fills, not on the border this removes. */
html[data-shell-shape="l-shaped"] .page__body--full > .table {
  margin-left: calc(var(--page-gutter) * -1);
  margin-right: calc(var(--page-gutter) * -1);
  /* THE FILL STAYS. It was `background: transparent` for an hour and that is a bug in
     every theme whose card is not white (2026-09-07: "in classic l shaped the table in
     orders becomes all blue as if its all hovered"). A .table's rows carry no fill of
     their own — they sit on the table's --color-surface — so dropping it let the card's
     --color-page show straight through every row. On Classic that is #edf4f8, close
     enough to --color-chip's then-#f5fafe that the whole table read as permanently
     hovered. (Both numbers have moved since: Classic's page is #edf4f8 and the chip is
     #ecf5fe, nearer still — the fill this rule keeps is what stops it being a bug.)
     It looked right on Light only by coincidence: there --color-page IS white, so
     transparent and --color-surface resolve to the same pixels.
     The transparent came from the old Layered style, where the sheet under the table
     was --color-surface and dropping the fill was correct. The card is --color-page,
     which is a different token, and that is the whole of the mistake. */
  border-left: 0;
  border-right: 0;
  /* SQUARE AT THE TOP, ROUNDED AT THE BOTTOM (2026-09-08, on request: "in the l
     shaped theme, the bottom left and right corners in the sticky footer table, in
     order should be rounded, not straight lines"). It was `border-radius: 0` on all
     four.
     THE TWO ENDS OF THIS TABLE ARE NOT THE SAME KIND OF EDGE, which is why one pair
     of corners goes back and the other does not. The table's top runs INTO the page
     above it — the summary card, the page header — and squaring it is what makes the
     toolbar read as the top of a full-bleed band rather than as a card floating in the
     body. The bottom is where the list ENDS, with the card's own --color-page below it
     and nothing to run into, so a square bottom reads as the table having been cut off
     by the viewport rather than finished.
     --radius-md, .table's own radius from elements.css, not the card's
     --radius-shell-sheet: this is still a table, and its corner should agree with
     every other table's rather than with the sheet it happens to sit in.
     The SIDE BORDERS ARE STILL GONE, so the curve is drawn by the fill and the bottom
     border alone — the notch it opens shows the card behind it, which is the point. */
  border-radius: 0 0 var(--radius-md) var(--radius-md);
}

/* The children follow the box: elements.css rounds .table's first and last child to
   match the corners the table has, so the foot has to be given back exactly the pair
   the rule above restored — a square .table__foot inside a rounded table paints its
   own fill over the curve and the corner simply does not appear. The first child
   (the toolbar) stays square, with the top corners it belongs to. */
html[data-shell-shape="l-shaped"] .page__body--full > .table > :first-child {
  border-radius: 0;
}

html[data-shell-shape="l-shaped"] .page__body--full > .table > :last-child {
  border-radius: 0 0 var(--radius-md) var(--radius-md);
}
