/* ==========================================================================
   THE KIT — shared assets. Extracted from crm/crm.css 2026-08-13.

   These are NOT CRM things. They were written in the CRM because it was the
   first surface that needed them, with no CRM-specific rule so the extraction
   would be a MOVE rather than a rewrite — and this is that move, done at the
   moment a second consumer appeared (crm/filters.js and crm/columns.js are now
   separate modules and both need the drawer).

   The trigger was the rule in 08-MODULES: extract when there are two consumers,
   because the moment there are two COPIES there are two behaviors.

   Everything here is built to a locked decision, and the decision is named at
   each block. If a rule here disagrees with design-system/01-DECISIONS.md, the
   decision is right and this is the bug.
   ========================================================================== */
/* ══ NOTHING IN THIS SYSTEM IS UNDERLINED (Brandon, 2026-08-27) ════════════
   *"where the actual fuck are all these underlines coming from … there is no
   underline in our kit it doesn't exist."* He is right, and it was true only
   BY ACCIDENT: there was no anchor reset anywhere, and 25 separate
   `text-decoration:none` declarations across eight files each marked a call
   site that happened to remember. Every anchor was therefore a coin flip, and
   the coin came up wrong three times in one afternoon — `.seg-b` when a tab
   became a link, `.tbl2-card` when a row became one, and `.a-srcb` latently
   (an anchor with no text, so nothing rendered, which is worse: it was already
   wrong and nothing could show it).

   ⚠️ THE FIX IS THE ABSENCE OF A RULE, NOT ANOTHER RULE PER COMPONENT. A kit
   class is a LOOK, not an element (L32) — publishing `.seg-b` publishes the
   right to wear it on an `<a>` — so a component cannot be expected to declare
   what its consumer's TAG will do. Stated once, at the scope, it is true for
   every component that exists and every one written next week.

   ⚠️ AN INTENTIONAL UNDERLINE STILL WORKS AND MUST STILL BE WRITTEN. This is
   (0,1,1); `.lead2-kv-a:hover` is (0,2,0) and out-specifies it, which is the
   right way round — an underline should have to be asked for.

   The scopes are the token file's, so the reset reaches exactly what the kit
   paints and nothing outside it: the legacy app is untouched (M6). */
:root[data-dsys] a,
.lab-scope a,
.ash-shell a,
.atlas-scope a{ text-decoration:none }

/* ══ THE KIT DECLARES ITS OWN GEOMETRY (2026-09-08) ═════════════════════════
   ⭐ EVERY RULE IN THIS FILE IS WRITTEN AGAINST `border-box`, AND UNTIL NOW THE
   KIT BORROWED THAT FROM WHOEVER LOADED IT. `index.html:583` sets
   `*, *::before, *::after { box-sizing: border-box }` for the app — but the
   201Sign SIGNER PAGE is a SEPARATE DOCUMENT (unauthenticated, no shell) that
   links the tokens, the kit and its own sheet and nothing else. It never had
   the reset, so the same component computed a different geometry depending on
   which document it was in.

   MEASURED on an iPhone 17 / iOS 26.4, the adopt sheet on the signer page:
       box-sizing content-box · max-height 666px · RENDERED 679px
   — 13px over its own cap, because `padding-top:12px` (the phone sheet's grab
   handle row) and `border-top:1px` sat OUTSIDE the max-height. The sheet's top
   then ate the status-bar clearance MB74 exists to protect, and nothing threw.

   ⚠️ THE ~20 EXPLICIT `box-sizing:border-box` DECLARATIONS BELOW ARE THE SCAR.
   Each one is a component that hit this and patched itself locally; they are
   harmless now and are left alone rather than swept, because a sweep is a
   separate diff. The contract belongs to the kit, stated once.

   ⚠️ SCOPED TO THE TOKEN FILE'S OWN SCOPES, exactly like the anchor reset
   directly above and for the same reason — the reset reaches what the kit
   paints and nothing else, so the legacy app is untouched (M6). The signer
   page carries `data-dsys` on <html>, which is what makes it a consumer.

   ⚠️ `box-sizing` ONLY — deliberately NOT `index.html`'s `margin:0;padding:0`.
   That page's zeroing is a decision about ITS content, and applying it to a
   document authored against UA defaults would silently reflow prose we did not
   come here to touch. Geometry is the part the kit actually depends on. */
:root[data-dsys], :root[data-dsys] *, :root[data-dsys] *::before, :root[data-dsys] *::after,
.lab-scope,      .lab-scope *,       .lab-scope *::before,       .lab-scope *::after,
.ash-shell,      .ash-shell *,       .ash-shell *::before,       .ash-shell *::after,
.atlas-scope,    .atlas-scope *,     .atlas-scope *::before,     .atlas-scope *::after{
  box-sizing:border-box;
}

/* ══ THE DRAWER ═════════════════════════════════════════════════════════════
   Built to the locked spec, not invented: P24 (drawer vs modal), P22 (free-edge
   geometry), P23 (a drawer commits its own work), P25/P26 (one scrim, dims
   never blurs), P43 (distance sets duration), P45 (light dismiss).

   ⚠️ THIS BELONGS IN THE KIT, NOT IN THE CRM. It lives here because there is no
   kit file yet and the CRM is the first surface that needs one. It is written
   with no CRM-specific rule so the extraction is a move, not a rewrite — the
   moment a second surface wants a drawer, this is what gets lifted out. Noted
   in 08-MODULES.

   WHY A DRAWER AND NOT A MODAL (P24): the page behind still matters. Filters and
   Columns are ABOUT the list — you need to see the list you are filtering, which
   is exactly the case a modal blocks. */
/* ══ THE SCRIM (P25/P26/P49) ════════════════════════════════════════════════
   ONE asset for EVERY overlay — drawer, modal, sheet, confirm. P25 already said
   one scrim TOKEN; this is the one scrim ELEMENT, because a color shared by
   four hand-rolled scrims is still four behaviors.

   ⚠️ P49 — IT COVERS THE WHOLE VIEWPORT, INCLUDING THE NAV. It was
   `position:absolute; inset:0` inside the surface's own box, so it dimmed the
   content and left the rail and the tool bar at full brightness. That does not
   read as "a layer above part of the app" — IT READS AS A RENDERING FAILURE,
   because a dim that stops at an arbitrary line looks like something that
   failed to cover rather than something that chose not to.

   Dimming is about DEPTH, not about blocking: the drawer stays `aria-modal
   ="false"` with light dismiss (P24/P45). A scrim says "this is on top", not
   "you are trapped".

   `--scrim-z` lets each family sit its scrim directly beneath itself while
   sharing this one rule — a modal raises it to the modal layer, a drawer takes
   the default. */
.scrim{
  position:fixed; inset:0;
  z-index:var(--scrim-z, var(--atlas-z-drawer));
  background:var(--atlas-scrim);
  opacity:0; pointer-events:none;
  transition:opacity var(--atlas-dur-base) var(--atlas-ease-out);
  /* ⚠️ A SCRIM ABSORBS THE GESTURE, NOT JUST THE TAP (MB170). It already
     swallows a click — that is the whole reason it is a real element rather
     than the box-shadow it used to be. But it measured `touch-action:pan-x
     pan-y`, so a DRAG on the dimmed area still scrolled whatever was behind
     it. Half a barrier is the worst kind: it reads as blocking and is not.
     ⚠️ Correct WHEREVER it is mounted, and deliberately kept even though the
     mount-host fix above removes the scroller it was chaining to — two
     independent reasons the background must not move, and the cheaper one
     should not depend on the structural one holding forever. */
  touch-action:none;
  overscroll-behavior:contain;
}
/* P26 — THE SCRIM DIMS, IT NEVER BLURS. backdrop-filter is banned (L7, the
   glassmorphism tell), it destroys the context the drawer exists to act on, and
   a full-viewport blur over a long table janks the open animation. */
.scrim.is-open{ opacity:1; pointer-events:auto }

.drw{
  /* FIXED, to match the scrim's coordinate space. An overlay is not a page, so
     N5's "no position:fixed inside the shell" does not apply to it: N5 governs
     what lives IN the cell, and this lives ABOVE the shell entirely. Anchoring
     the drawer to the surface while its scrim covered the viewport would put
     the two in different coordinate systems — the dim and the panel it belongs
     to would disagree about where the screen is. */
  position:fixed; top:0; right:0; bottom:0; width:400px; max-width:88%;
  /* ⚠️ `--drw-z` IS A SEAM, NOT A STYLE — the same shape `--scrim-z` already
     establishes a few rules above: a family that must sit at a different rung
     says so with a LADDER TOKEN, and everyone else keeps the default. It exists
     because a sheet can be raised FROM a modal (Market's listing overlay opens
     the send sheet), and a drawer pinned to the drawer rung paints UNDER it —
     measured: overlay 400, sheet 301, the sheet's left edge clipped. The
     default is unchanged, so no existing drawer moves. */
  z-index:var(--drw-z, calc(var(--atlas-z-drawer) + 1));
  /* FOUR rows: header · scrolling body · optional LIVE band · footer. The live
     band is for a drawer whose work has a running RESULT — the smart-list count
     is feedback on everything above it, so it must not scroll away exactly when
     you are adding the filter that changes it. Absent on drawers that have no
     such thing, and the row simply collapses. */
  /* ⚠️ `minmax(0,1fr)` + overflow:hidden, for WebKit (2026-09-04): a grid
     constrained by max-height can let a bare 1fr row keep its content height
     in Safari, overflowing the sheet and pushing the footer row past the
     clipped edge — the adopt drawer's Save landed below the fold on a phone.
     Chromium never shows it; the simulator is the faithful measure. */
  display:grid; grid-template-rows:auto minmax(0, 1fr) auto auto;
  /* ⚠️⚠️ `clip`, NOT `hidden` — A298. `overflow:hidden` still creates a SCROLL
     CONTAINER, and the browser scrolls one to reveal a focused control. Ticking
     a checkbox below the fold therefore scrolled the WHOLE DRAWER: the header
     and body slid up out of sight and the footer came to rest near the top with
     the drawer's own background below it. Measured — `scrollTop` 0 → 395, and
     every other number stayed perfect (tracks summing to the height, footer in
     track 4, no inline styles), which is why three rounds of reading the layout
     found nothing. `clip` clips WITHOUT a scrollport, so the focus walk skips
     this box entirely.
     ⚠️ BOTH DECLARATIONS STAY. `overflow:clip` is Safari 16+; on 15 the value is
     invalid and the declaration is dropped, which with only `clip` present would
     leave `visible` and spill the drawer's content across the app. `hidden`
     first, `clip` second: old engines keep the clip, new ones lose the scrollport.
     The JS backstop below covers the ones that keep `hidden`. */
  overflow:hidden;
  overflow:clip;
  background:var(--atlas-bg-1);
  /* P22 — FREE-EDGE GEOMETRY. Flush to the right edge, so it rounds its LEFT
     two corners only, takes a LEFT border only, and throws its shadow leftward.
     A drawer that rounds all four corners is a card that happens to be at the
     edge. */
  border-left:var(--atlas-bw) solid var(--atlas-line);
  border-radius:var(--atlas-r-lg) 0 0 var(--atlas-r-lg);
  box-shadow:var(--atlas-lift);
  transform:translateX(100%);
  transition:transform var(--atlas-dur-slow) var(--atlas-ease-out);
}
/* P43 — distance sets duration, and a drawer crosses the screen, so `slow`.
   transform only: it is one of the two properties F9 allows to animate. */
.drw.is-open{ transform:none }
@media (prefers-reduced-motion: reduce){
  .drw, .scrim{ transition:none }
}

.drw-hd{
  display:flex; align-items:center; gap:var(--atlas-s8);
  padding:var(--atlas-s16);
  border-bottom:var(--atlas-bw) solid var(--atlas-line);
}
.drw-t{ font-size:var(--atlas-fs-lg); font-weight:var(--atlas-fw-bold); margin:0 }
/* The header close is `.a-x .a-x-lg` from the kit (A39b) — it used to be
   declared here with its own numbers, which is how three different closes
   ended up in one drawer. */
.drw-hd .a-x{ margin-left:auto }

/* ⚠️ NO SCROLLBAR RULES HERE. Six components each declared the same
   treatment, which is why "scrollbars are transparent until you use them"
   would have been a six-file change with one missed. It is ONE sitewide rule
   (index.html) reading two tokens the design system re-points for its own
   scope (atlas-tokens.css). A component that wants a different scrollbar is
   almost always a component that has not noticed there is a global one. */
/* `overscroll-behavior:contain` — the one inner scroller in the kit that did
   not have it (2026-08-29 audit). At the top or bottom of a sheet's body a
   further drag chained to the page behind, which is the "the sheet fights you"
   tell on a phone (03-NATIVE-FEEL §2). */
.drw-b{ overflow-y:auto; min-height:0; padding:var(--atlas-s16); overscroll-behavior:contain }
/* ⭐⭐ AT THE PARTIAL DETENT THE BODY DOES NOT SCROLL — THE GESTURE EXPANDS THE
   SHEET INSTEAD (MB172). Brandon, 2026-09-14: *"it opens halfway like it's
   supposed to, but then when you start scrolling it opens fully which kinda
   glitches things out."*

   ⚠️ TWO SYSTEMS WERE ANSWERING ONE GESTURE. The drag listeners are PASSIVE by
   necessity — nothing can `preventDefault` a native scroll — so the losing side
   has to stand down entirely. `.drw`'s own stand-down covers `pop` sheets and
   already-full drawers and misses exactly this case, so an up-swipe scrolled the
   list natively AND accumulated toward the −40px escalation, which then snapped
   the sheet and killed the gesture mid-flight. Trap 51 again.

   ⚠️ THIS IS WHAT iOS DOES, and it is why the fix is a subtraction rather than
   new gesture code. The HIG: *"A resizable sheet expands when people scroll its
   contents or drag the grabber"* — at the medium detent the scroll gesture IS
   the expand gesture, and content does not move until the sheet is large. With
   nothing to scroll there is only one thing the gesture can mean.

   ⚠️ IT IS NOT `:not(.is-full)` ALONE — THE KEYBOARD WOULD HAVE BEEN COLLATERAL.
   `html.a-kb-open .drw` escalates the cap by MAX-HEIGHT, not by adding
   `.is-full`, so a partial sheet with the keys up still matches `:not(.is-full)`
   and a form would have become unscrollable at exactly the moment someone is
   filling it in. Measured before writing the rule, not after.

   ⚠️ CONTENT IS STILL REACHABLE WITHOUT THE GESTURE, BUT NOT FOR THE REASON I
   FIRST WROTE. `overflow:hidden` blocks USER scrolling and leaves programmatic
   scrolling working — but MEASURED in the real WKWebView, simply focusing a
   control does NOT scroll it into view when clipped (scrollTop stayed 0 with the
   element below the fold); only `scrollIntoView` does. So the kit walks focus in
   by hand on `focusin`. The original claim here was reasoned from the spec and
   was wrong on the device.
   ⚠️ `.pop` is deliberately untouched: a picker has no escalation branch, so its
   list must keep scrolling at its own cap. */
html.a-phone:not(.a-kb-open) .drw:not(.is-full) .drw-b{ overflow-y:hidden }

/* P23 — THE FOOTER IS THE COMMIT SURFACE, and it is pinned. A drawer commits its
   own work and never spawns a modal on top of itself: a destructive confirm
   swaps THIS footer in place, which keeps the decision next to the setting it
   applies to instead of floating it away over two dismissible layers. */
/* ⭐⭐ THE FOOTER IS THE LAST TRACK, EXPLICITLY — and the body is the one that
   absorbs. The grid declares FOUR rows for THREE children (the optional
   `.drw-live` is the fourth and is omitted more often than not), so placement
   was left to auto-flow: header→1, body→2, footer→3, track 4 empty. That is
   correct until anything else lands inside `.drw` — then the footer slides UP
   off the bottom and the body collapses, which is what Brandon photographed
   twice: Cancel/Save pinned under the header with a white void beneath.
   ⚠️ I could not reproduce the cause in any harness (3 children, body 848px,
   footer bottom == drawer bottom, every path). So this does not claim to be the
   fix for it — it makes the SYMPTOM unreachable whatever the cause is, which is
   the right guarantee for the surface where a drawer's commit buttons live.
   ⚠️⚠️ `grid-row:-1` IS NOT "THE LAST TRACK" — it is the last explicit LINE,
   and an item STARTING there spans into an IMPLICIT row after the grid. Written
   that way first, and Brandon's own console caught it: `grid-template-rows`
   computed to FIVE tracks (`65px 674px 0px 0px 69px`) on a four-track template.
   It renders identically, because the two orphaned tracks collapse to 0 — which
   is exactly why it would have survived any amount of looking. The last TRACK is
   line 4 of 5, so that is what this says. */
.drw-b{ grid-row:2 }
.drw-ft{
  grid-row:4;
  display:flex; align-items:center; gap:var(--atlas-s8);
  padding:var(--atlas-s12) var(--atlas-s16);
  border-top:var(--atlas-bw) solid var(--atlas-line);
  /* OPAQUE — the footer is the last grid row, but a body that ever bursts its
     track (the double-compensation bug above) ghosts through a transparent
     footer, and iOS 26's glass keyboard samples whatever is behind it. */
  background:var(--atlas-bg-1);
}
.drw-ft .drw-sp{ flex:1 }
/* ⚠️ A BAND WITH NOTHING IN IT IS A GREY STRIP, WHICH IS WHAT IT LOOKS LIKE.
   `drawer()` already omits `.drw-live` when there is no readout — but a
   consumer that builds its own shell, or a drawer that commits nothing and so
   passes no footer, still emits the empty element, and it paints its padding,
   its border and (for the live band) its recessed background regardless
   (Brandon: *"each drawer has this weird grey strip towards the bottom"*).
   `:empty` is exactly the condition — zero child nodes, text included. */
.drw-live:empty, .drw-ft:empty{ display:none }

/* The live band sits BETWEEN the body and the footer: pinned like the footer,
   but it is a readout, not a commit surface, so it is quieter — recessed
   ground, no top border of its own (the footer's border is the closing line). */
.drw-live{
  padding:var(--atlas-s12) var(--atlas-s16);
  background:var(--atlas-bg-2);
  border-top:var(--atlas-bw) solid var(--atlas-line);
}

/* ── DRAWER CONTENT ───────────────────────────────────────────────────────── */
.drw-sec + .drw-sec{ margin-top:var(--atlas-s20) }
.drw-lbl{
  font-size:var(--atlas-fs-2xs); font-weight:var(--atlas-fw-bold);
  letter-spacing:.09em; text-transform:uppercase; color:var(--atlas-ink-3);
  margin:0 0 var(--atlas-s8);
}
.drw-pills{ display:flex; flex-wrap:wrap; gap:var(--atlas-s6) }

/* ── THE THREE-PANE SURFACE (promoted from Tasks, 2026-08-15) ──────────────
   SCOPE · LIST · DETAIL. Tasks arrived at it first (rail · queue · card) and the
   Directory is the second surface to want exactly the same shape, which is the
   kit's promotion trigger — and the reason to promote it now rather than later
   is that these two would otherwise drift on the numbers that matter least and
   are noticed most: rail width, divider side, which column scrolls.

   ⚠️ GEOMETRY ONLY. What moves here is the grid, the widths, the dividers and
   independent scrolling. What does NOT move is content, selection or the
   keyboard — Tasks owns its own `j/k/x/Enter`, and a layout token that tried to
   own behaviour would have to know what a row means. This is the same line the
   shell draws at N5: it owns where things sit, never what they say.

   ⚠️ THE MIDDLE COLUMN IS FIXED-WIDTH ON PURPOSE. A scan column does not benefit
   from being wider — you are reading down it, not across — so the DETAIL takes
   the slack and caps its own measure. A three-pane surface that shares the extra
   space evenly ends up with a scan column too wide to scan and prose too wide to
   read, which is the failure this shape exists to avoid.

   ⚠️ EACH COLUMN SCROLLS ITSELF (`min-height:0` on all three — the pair that
   lets a CHILD scroll instead of pushing the page taller). The surface never
   scrolls as a whole: the same rule the dashboard canvas follows, for the same
   reason (exactly one thing moves under the pointer). */
.a-3pane{
  display:grid;
  grid-template-columns:var(--atlas-subrail-w) minmax(320px, 400px) 1fr;
  min-height:0; height:100%;
}
.a-3pane > *{ min-width:0; min-height:0 }
/* Hairlines BETWEEN the panes, never around them — one connected sheet, which is
   the house style's whole argument (F13/C40). The last pane draws none. */
.a-3pane > .a-3pane-scope,
.a-3pane > .a-3pane-list{ overflow:auto; border-right:var(--atlas-bw) solid var(--atlas-line) }
.a-3pane > .a-3pane-detail{ overflow:auto }
/* ⚠️ A PANE WITH A FIXED HEAD SCROLLS ITS BODY, NOT ITSELF. Opt-in, because the
   default (the pane is the scroller) is right for a plain list. The moment a
   pane has a SEARCH at the top, the default is wrong twice over: the box you
   need in order to reach what the scroll hid scrolls away with it (L20/A38),
   and the scrollbar takes its width from the head too — so the same field is
   visibly narrower in a long list than a short one, which is the version
   Brandon spotted. A variant in the kit rather than a specificity fight in the
   surface: `.a-3pane > .a-3pane-list` is (0,2,0) and kit.css loads AFTER a
   surface's sheet, so a surface could only win this by arithmetic. */
.a-3pane > .a-3pane-list.is-fixedhead{ overflow:hidden; display:flex; flex-direction:column }
.a-3pane > .a-3pane-list.is-fixedhead > .a-3pane-head{ flex:none }
.a-3pane > .a-3pane-list.is-fixedhead > .a-3pane-body{ flex:1 1 auto; min-height:0; overflow:auto }
/* Below the breakpoint the DETAIL takes the surface and the other two step back
   — a 320px scan column and a readable detail cannot both exist at 900px, and
   shrinking both is how you get two unusable columns instead of one good one. */
@media (max-width: 1100px){
  .a-3pane{ grid-template-columns:var(--atlas-subrail-w) 1fr }
  .a-3pane.is-detail > .a-3pane-list{ display:none }
  .a-3pane:not(.is-detail) > .a-3pane-detail{ display:none }
}

/* ── THREE PANES ON A PHONE (2026-08-25) ───────────────────────────────────
   The rule above takes three columns to two. At 390px there is room for ONE,
   and the collapse is not "hide one more" — it is a different question per
   pane, because the three are not the same kind of thing:

     · the SCOPE is a filter (All / Team / Partners) — a handful of short
       labels. It becomes a horizontal band above the list, which keeps it
       visible and costs one row. Hiding it behind a sheet would be a whole
       layer to open for something you change by tapping a word.
     · the LIST is the page. It is what you came for.
     · the DETAIL replaces the list, exactly as a record does everywhere else,
       and the surface says so with `.is-detail` — the same state the 1100px
       rule already uses, so nothing new has to be tracked.

   ⚠️ `.ash-shell.is-phone`, NOT A WIDTH. The shell owns the question of what a
   phone is; a `max-width` here would also catch a narrow desktop window, where
   three columns are cramped but a horizontal filter band is not the answer. */
.ash-shell.is-phone .a-3pane{
  grid-template-columns:1fr;
  grid-template-rows:auto 1fr;
}
.ash-shell.is-phone .a-3pane > .a-3pane-scope{
  grid-row:1;
  /* A ROW, not a column — and it scrolls sideways rather than wrapping, so a
     tenant with eight lists gets a swipe instead of three stacked rows eating
     the list underneath. */
  flex-direction:row; overflow-x:auto; overflow-y:hidden;
  border-right:0; border-bottom:var(--atlas-bw) solid var(--atlas-line);
  scrollbar-width:none;
}
.ash-shell.is-phone .a-3pane > .a-3pane-scope::-webkit-scrollbar{ display:none }
.ash-shell.is-phone .a-3pane > .a-3pane-scope > *{ flex:none }
.ash-shell.is-phone .a-3pane > .a-3pane-list,
.ash-shell.is-phone .a-3pane > .a-3pane-detail{ grid-row:2; border-right:0 }
/* One of the two, never both — the 1100px rule already says which, and this
   only has to stop the hidden one from claiming a grid row. */
.ash-shell.is-phone .a-3pane.is-detail > .a-3pane-list{ display:none }
.ash-shell.is-phone .a-3pane:not(.is-detail) > .a-3pane-detail{ display:none }
/* Both clear the pill, because neither is a DECLARED scroller (MB44 keys off
   `data-keep-scroll`) and both are the last thing on screen.

   ⚠️⚠️ THE CLEARANCE GOES ON THE SCROLLER, NOT ON ITS CONTAINER — and putting
   it on the container is a bug that looks like a stray white panel. A
   `is-fixedhead` list is `overflow:hidden` with the scrolling in
   `.a-3pane-body`; padding the OUTER box shortens the scrollport by 92px
   instead of padding the content, so the last rows are clipped mid-row and the
   gap below them shows the sheet through — measured on Directory, and reported
   as *"a random white block covering the bottom section"*. Padding is only
   correct on the element that actually scrolls. */
.ash-shell.is-phone .a-3pane > .a-3pane-list:not(.is-fixedhead),
.ash-shell.is-phone .a-3pane > .a-3pane-detail{ padding-bottom:var(--atlas-pill-clear) }
.ash-shell.is-phone .a-3pane > .a-3pane-list.is-fixedhead > .a-3pane-body{
  padding-bottom:var(--atlas-pill-clear);
}

/* ══ THE DRILL-DOWN SLIDE (MB47) ══════════════════════════════════════════
   Brandon: *"should we give huddle chats a right to left slide in like
   instagram dms or most other chat rooms have?"*

   ⭐ IT IS THE KIT'S, NOT HUDDLE'S. Four surfaces already do the same phone
   drill-down — the lead profile, a Huddle channel, a Settings section, a
   Directory detail — and MB31's edge-swipe back lives here for exactly the
   stated reason: *"every record surface on a phone needs the same exit, and the
   second implementation is where they start disagreeing about the threshold."*
   A slide that exists only in Huddle is that mistake one layer up.

   ⭐ AND THE REAL ARGUMENT IS NOT THAT INSTAGRAM DOES IT. The edge-swipe
   already ships and is INVISIBLE: drag past 72px and the pane vanishes, drag
   69px and nothing ever moved. A slide gives that gesture something to hold,
   and makes "which way is back" a fact about the screen rather than something
   you remember. That is spatial, not decorative — it is not L6's problem.

   ⚠️⚠️ THE TRANSFORM MUST NOT SURVIVE THE ANIMATION, and this is the trap this
   system has already paid for. A transform makes an element the containing
   block for every `position:fixed` DESCENDANT — which is precisely MB45: a
   press transform on a sheet's host moved the fixed panel 212px between
   pointerdown and pointerup, and the picker "did nothing" through three wrong
   fixes. So this is an ANIMATION, which leaves nothing behind, and the class is
   stripped on `animationend`. Never park a pane at `translateX(0)`.

   ⚠️ THE INCOMING PANE ONLY. Three of the four surfaces REPAINT — the outgoing
   half is gone before it could be animated — so moving both would work in
   Huddle and quietly do nothing in the other three. One direction, four
   surfaces, identical everywhere.

   ⚠️ AND `will-change` IS DELIBERATELY ABSENT. It promotes a layer for the life
   of the element, not of the animation, and a permanently promoted full-screen
   pane is a memory cost on the device least able to pay it. */
.a-drill-in,
.a-drill-out{
  /* Phase-3 3-B: the drill rides the NAV SPRING (0.38/0.95 as linear() —
     02-STANDARD §6's native re-derivation; minted by gen-spring-linear.mjs,
     MB116's one-physics rule). Fallbacks carry the pre-spring behavior so a
     scope-less mount degrades to the old curve, never to IACVT-inherit
     (trap 60). The lateral axis stays instant — MB20; this is the PUSH axis
     only, and only the incoming pane (see above). */
  animation:aDrill var(--atlas-spring-nav-dur, var(--atlas-dur-slow)) var(--atlas-spring-nav, var(--atlas-ease-out)) backwards;
}
.a-drill-in { --a-drill-from:100% }
/* Back is a PARALLAX, not a mirror: the list was never fully off-screen to the
   left, it was behind the detail. −33% is 02-STANDARD §6's measured number and
   what the edge-back reveal already uses (MB120) — this was −24% until 3-D,
   which made a chevron back start from a different depth than the gesture. */
.a-drill-out{ --a-drill-from:-33% }
@keyframes aDrill{
  from{ transform:translateX(var(--a-drill-from)) }
  to  { transform:none }
}
/* ⚠️ NOT `animation:none` — the class is removed on `animationend`, and an
   animation that never runs never fires it, so the class would stay on the
   element forever and with it a `both`-filled transform: the containing-block
   bug above, arriving through the accessibility path. A 1ms run ends, cleans up
   after itself, and is invisible. */
@media (prefers-reduced-motion:reduce){
  .a-drill-in, .a-drill-out{ animation-duration:1ms }
}

/* ══ EDGE-BACK v2 (MB120) — THE INTERACTIVE POP'S THREE LAYERS ═════════════
   Kit-owned, one copy: the mover rule used to live in THREE surface files
   (lead.css, deal.css, huddle.css — verbatim clones) while campaigns had
   registered the gesture with no visual at all, which is MB115's exact
   failure shape. `K.edgeBack` stamps the classes and drives two vars on the
   container — `--a-edge` (px) and `--a-edge-p` (0..1) — through the drag AND
   the release spring, so all three layers scrub in lockstep.

   `transition:none` on everything: the position is the finger's, not a
   curve's — a transition would lag it by exactly the amount that reads as
   broken (the surface copies' own lesson, kept verbatim). The release is a
   JS spring (`K.spring`), which is why no CSS motion belongs here.

   ⚠️ NO z-index anywhere. The kit inserts the layers in tree order —
   under-pane, veil, mover — and the mover's transform makes it a stacking
   context, so z-auto siblings paint in exactly that order (trap 22's cousin,
   solved by construction instead of by a number).

   ⚠️ Phone-scoped, matching the visual's original gate. The under-pane's
   geometry (display/position/box) is written INLINE by the engine because
   only it knows the measured box; this file owns only motion and paint. */
.ash-shell.is-phone .is-edging{
  transform:translateX(var(--a-edge, 0px));
  transition:none;
  /* ⚠️ OPAQUE, EXPLICITLY. A record pane's white is usually the SURFACE
     beneath it — the pane itself paints nothing — so the moment it moves,
     everything it does not paint shows the reveal through it (measured: the
     lead timeline's text floating over the dimmed list). iOS's leaving view
     is opaque; so is ours. A mover that deliberately paints its own ground
     is unaffected — its rule out-specifies this one. */
  background:var(--atlas-bg-1);
}
/* The pane being returned to: −33% parallax scrubbing to rest as the finger
   opens it — 02-STANDARD §6's Ionic-measured number. */
.ash-shell.is-phone .a-edge-under{
  transform:translateX(calc(-33% * (1 - var(--a-edge-p, 0))));
  transition:none;
  pointer-events:none;
  overflow:hidden;
}
/* The honest approximation where the real pane is another route (the deal
   hub): a surface-coloured slab, so the reveal shows "a surface behind"
   rather than lying about which one. */
.ash-shell.is-phone .a-edge-slab{ background:var(--atlas-bg-1) }
/* ONE veil, two jobs: the dim over the under-pane (0.1 → 0 as it comes
   forward) and the seam shadow riding the mover's left edge (0.7 → 0.03,
   Ionic's scrub). The seam is a GRADIENT STRIP on the veil's own pseudo —
   inside the veil's paint, outside nobody's overflow (trap 58) — translated
   by the same `--a-edge` the mover reads, so the two edges cannot drift. */
.ash-shell.is-phone .a-edge-veil{
  pointer-events:none;
  background:rgb(0 0 0 / calc(0.1 * (1 - var(--a-edge-p, 0))));
  overflow:visible;
}
.ash-shell.is-phone .a-edge-veil::after{
  content:''; position:absolute; top:0; bottom:0; left:-16px; width:16px;
  transform:translateX(var(--a-edge, 0px));
  background:linear-gradient(to left, rgb(0 0 0 / 0.28), rgb(0 0 0 / 0));
  opacity:calc(0.03 + 0.67 * (1 - var(--a-edge-p, 0)));
}

/* ══ THE HERO MOVE (Phase-3 3-B) — the shared element's group animation rides
   the nav spring. `::view-transition-*` pseudos live on the ROOT and cannot be
   scoped to the shell — safe anyway, because the name `a-hero` is only ever
   stamped by K.heroArm/heroPaint, which are phone-gated in JS. The old/new
   image pair keeps the UA's cross-fade; only the GROUP (position/size morph)
   is retimed, or the box would glide on one curve while its content faded on
   another duration. */
::view-transition-group(a-hero){
  animation-duration:var(--atlas-spring-nav-dur, 470ms);
  animation-timing-function:var(--atlas-spring-nav, ease);
}

/* ── @MENTIONS (promoted from Huddle, 2026-08-15) ──────────────────────────
   A transparent textarea over a mirror that paints the same string with the
   mention marked up — the only way to accent part of a textarea's own text. */
/* ⚠️ THE CHROME LIVES ON THE WRAP, NEVER ON THE INPUT, and the two layers share
   ONE padding token. The mirror has to occupy exactly the same box as the text
   it is standing in for; a border or padding on either layer alone shifts one
   relative to the other and every character is off by that much. So the wrap
   carries the border and the fill, both layers are borderless, and the padding
   is a variable neither can set independently.
   `is-boxed` is the standalone field (the dashboard's note); the bare form is
   for a field already sitting inside a card that supplies the border — the CRM
   composer, where a second border would be a box inside a box. */
.a-ment{ position:relative; display:block; min-width:0; --a-ment-pad: var(--atlas-s16) }
.a-ment-mirror,
.a-ment .a-ment-in{
  font:inherit; font-size:var(--atlas-fs-md); line-height:1.55;
  padding:var(--a-ment-pad);
  white-space:pre-wrap; overflow-wrap:anywhere;
  border:0; background:none;
}
.a-ment-mirror{
  position:absolute; inset:0; pointer-events:none;
  color:var(--atlas-ink); overflow:hidden;
}
.a-ment.is-boxed{
  --a-ment-pad: var(--atlas-s10);
  background:var(--atlas-bg-1);
  border:var(--atlas-bw) solid var(--atlas-line-2);
  border-radius:var(--atlas-r-md);
}
.a-ment.is-boxed:focus-within{ border-color:var(--atlas-accent) }
/* ⚠️ THE HIGHLIGHT MAY CHANGE COLOUR AND NOTHING ELSE. The caret belongs to the
   TEXTAREA and is placed by the textarea's own metrics; the mention you SEE is
   painted by the mirror. The moment the two lay text out differently the caret
   drifts — a semibold mention is WIDER than the same characters underneath it,
   so the cursor falls further behind with every one (Brandon hit this in
   Huddle: "the cursor gets caught in between characters and lags behind").
   Weight, letter-spacing, family and `font-variant` are all banned here. The
   RENDERED mention keeps its weight, because a rendered line has no caret. */
.a-ment-mirror .a-at{ font-weight:inherit; letter-spacing:inherit }
.a-ment .a-ment-in{
  position:relative; display:block; width:100%; box-sizing:border-box;
  resize:none; min-height:86px; max-height:40vh; overflow-y:auto; outline:none;
  /* TRANSPARENT TEXT, VISIBLE CARET — without `caret-color` the cursor vanishes
     with the glyphs and the field reads as dead. */
  color:transparent; caret-color:var(--atlas-ink);
}
.a-ment .a-ment-in::placeholder{ color:var(--atlas-ink-3) }
/* The selection must stay visible through a transparent layer, or dragging
   across your own text selects something you cannot see. */
.a-ment .a-ment-in::selection{ background:var(--atlas-bg-3); color:var(--atlas-ink) }
/* THE MENTION ITSELF — accent ink, no slab (L13). Same token in the composer
   and in the rendered timeline, so a mention looks like one thing everywhere. */
.a-at{ color:var(--atlas-accent); font-weight:var(--atlas-fw-semi) }
/* ══ THE FIELD, LOADING ════════════════════════════════════════════════════
   A paragraph skeleton laid over the same box, on the SAME metrics as the text
   it stands in for: it inherits the field's font-size and line-height and wears
   the field's own padding, so the bars start exactly where words start and sit
   on the same baselines. Anything else and the text jumps when it lands.

   ⚠️ THREE BARS, AND THE LAST ONE SHORT. That ragged final line is the entire
   convention — uniform bars read as a loading TABLE, and in a text field that
   is the wrong promise. Widths descend so the block reads as prose.

   ⚠️ THE MIRROR AND THE CARET BOTH HAVE TO GO. The textarea's own text is
   already transparent (the mirror paints it), so hiding the mirror is what
   actually clears the words — and without killing `caret-color` a cursor blinks
   through the shimmer. */
.a-ment-skel{
  position:absolute; inset:0; padding:var(--a-ment-pad); pointer-events:none;
  display:none; font-size:var(--atlas-fs-md); line-height:1.55;
}
.a-ment.is-skel .a-ment-skel{ display:block }
.a-ment.is-skel .a-ment-mirror{ opacity:0 }
.a-ment.is-skel .a-ment-in{ caret-color:transparent }
/* `em`, not px — the bars track the text-size setting the way the text does. */
.a-ment-skel > span{
  display:block; height:0.92em; border-radius:var(--atlas-r-xs);
  margin-bottom:calc(1.55em - 0.92em);
}
.a-ment-skel > span:nth-child(1){ width:92% }
.a-ment-skel > span:nth-child(2){ width:78% }
.a-ment-skel > span:nth-child(3){ width:45% }

.a-ment-pop{ left:0; right:auto; min-width:240px; max-width:320px }

/* ══ THE RICH FIELD (A196) ═════════════════════════════════════════════════
   `.a-ment.is-rich` — the same shell, a contenteditable where the
   mirror+textarea pair was. It KEEPS `.a-ment-in` (metrics, min/max height,
   the phone font pins all apply unchanged); what has to flip is the paint
   model: there is no mirror, so the element draws its own ink and the
   transparent-text rule above must not reach it. */
.a-ment.is-rich .a-rich-in{
  color:var(--atlas-ink); caret-color:var(--atlas-ink); cursor:text;
}
.a-ment.is-rich .a-rich-in::selection,
.a-ment.is-rich .a-rich-in *::selection{ background:var(--atlas-bg-3) }
/* The placeholder. `:empty` cannot carry it — a contenteditable at rest
   usually holds a stray <br> — so JS keeps `.is-empty` honest. In-flow with
   `pointer-events:none`: the caret blinks at the line start over the ghost. */
.a-ment.is-rich .a-rich-in.is-empty::before{
  content:attr(data-ph); color:var(--atlas-ink-3); pointer-events:none;
}
/* Loading: no mirror to hide — the element's own text steps aside. */
.a-ment.is-rich.is-skel .a-rich-in{ opacity:0 }
/* What formatting looks like INSIDE the editor — the same as it renders in the
   timeline, which is the WYSIWYG promise the sign editor already makes. */
.a-rich-in :is(ul,ol){ margin:2px 0; padding-left:22px }
.a-rich-in a{ color:var(--atlas-accent); text-decoration:underline; text-underline-offset:2px }
.a-rich-in .a-at{ cursor:default }
/* The link pop — one row: URL, Apply, (Remove when already inside one). */
.a-rich-linkpop{ left:0; right:auto; min-width:300px; padding:var(--atlas-s8) }
.a-rich-linkrow{ display:flex; align-items:center; gap:var(--atlas-s8) }
.a-rich-linkrow .drw-in{ flex:1; min-width:0; height:var(--atlas-h-control); font-size:var(--atlas-fs-sm) }
.a-rich-linkrow .a-btn{ height:var(--atlas-h-btn-sm); font-size:var(--atlas-fs-sm); flex:none }

/* ── THE FIELD GROUP (2026-08-15) ──────────────────────────────────────────
   A LABEL AND ITS CONTROL, WITH THE GAP THAT SEPARATES THEM. This did not
   exist: `.drw-lbl` above is the SECTION heading (uppercase, tracked), and
   every drawer that needed a plain field label invented its own wrapper — New
   lead has `.nl-f`/`.nl-l`/`.nl-c` in its own stylesheet. The dashboard's
   announcement drawer then wrote `.drw-f`/`.drw-l`, which matched nothing at
   all, so the fields stacked with no gap and the labels sat on top of the
   inputs (Brandon: *"the spacing is way too tight"*).

   Exactly the shape of the `.a-btn.is-icon` bug found the same day: a class
   name that reads like a system token, defined nowhere, failing silently
   because missing CSS throws nothing. The numbers are New lead's, unchanged —
   it is the drawer with the most fields and nobody has complained about its
   rhythm, so the fix is to SHARE what works rather than to invent a second
   spacing. `.nl-f` stays until it can be retired onto this in one pass. */
.drw-f{ display:flex; flex-direction:column; gap:var(--atlas-s6); padding:var(--atlas-s6) 0 }
.drw-f > .a-capture{ margin-top:var(--atlas-s2) }
/* ⚠️ `align-self` IS WHAT KEEPS THE CHECKBOX HUGGING ITS WORDS. `.crm2-check` is
   `inline-flex`, but a direct child of a flex container is BLOCKIFIED — the
   computed display becomes `flex` — and `align-items:stretch` then paints it the
   full width of the drawer, which is the grey-button look all over again. It
   only looked right in New lead because `field()` wraps its body in a block, so
   the control was never a flex item there. Stated here rather than at the call
   site, because the next drawer to drop one straight into a field group would
   hit exactly the same thing. */
.drw-f > .crm2-check{ margin-top:var(--atlas-s2); align-self:flex-start }
.drw-l{ font-size:var(--atlas-fs-xs); color:var(--atlas-ink-2) }

/* A3 — pills are OUTLINE ONLY, two states, NO checkmark: the accent border and
   accent label already say "selected", so a tick is a second signal for one
   fact. Fixed height + line-height:1 (A21), because centering a line box is not
   centering the glyphs. */
/* ⚠️ THE OUTLINE IS `bw-em`, NOT `bw` (Brandon, 2026-08-13 — "that goes for all
   pills"). A pill is OUTLINE-ONLY: it has no fill, so the border is not chrome
   around the control, IT IS THE CONTROL. At hairline weight it reads as a
   suggestion of a boundary — the same reasoning A24 already applied to the mark
   controls, where 1px "does not read at all" at small sizes. K13's two weights
   are `structure` and `emphasis`, and a thing whose only visible form is its
   edge is the definition of the second one.

   ⚠️ RENAMED `.crm2-pill` → `.a-pill` (2026-08-15) WHEN HUDDLE BECAME THE
   SECOND CONSUMER. L32: a kit class is a LOOK, not a location, and a shared
   asset still wearing one surface's prefix invites the next surface to
   hand-roll its own rather than reach for something that looks like it belongs
   to the CRM. Huddle's settings drawer did exactly that — it wrote
   `class="a-pill"` for its group selector on the assumption the kit's pill was
   already called that, matched NOTHING, and rendered as the browser's default
   button (Brandon's screenshot: four grey rectangles where the pills should
   be). Renamed at all 14 call sites rather than aliased, per C23. */
/* THE ANY-OF PILL (A3 → A341, 2026-10-26): a 1px hairline at rest with a 500
   label, and the ACCENT FILL when selected — the primary button's face, the
   label in `--atlas-on-accent`. The 1.75px outline read heavy at 28px, and the
   old selected state was two signals in the third colour (accent border +
   accent label). Still no checkmark: a fill already says selected. A display
   pill (one that reports rather than toggles) is always the `.is-on` version,
   as A3 said; a removable chip (tags) stays neutral — a filing system, not a
   status. The press stays the kit depress: a pill carries no mark (A344). */
.a-pill{
  display:inline-flex; align-items:center; gap:var(--atlas-s6);
  height:var(--atlas-h-pill); box-sizing:border-box;
  padding:0 var(--atlas-s12); line-height:1;
  border:var(--atlas-bw) solid var(--atlas-line-2); border-radius:var(--atlas-r-sm);
  background:transparent; color:var(--atlas-ink-2);
  font:inherit; font-size:var(--atlas-fs-xs); font-weight:var(--atlas-fw-medium);
  cursor:pointer; white-space:nowrap;
  transition:color var(--atlas-dur-instant),border-color var(--atlas-dur-instant),background var(--atlas-dur-instant);
}
@media (hover: hover){ .a-pill:not(.is-on):hover{ color:var(--atlas-ink); border-color:var(--atlas-ink-3) } }
.a-pill:active{ transform:var(--atlas-press-t, translateY(1px)); transition:var(--atlas-press-in, none) }
.a-pill.is-on{ background:var(--atlas-accent); border-color:var(--atlas-accent); color:var(--atlas-on-accent) }

/* ══ THE STATUS PILL — `.a-st` (K9 → A342, 2026-10-26) ═══════════════════
   TWO TIERS. In a row or a table the status is DOT + TEXT: a 7px dot in the
   tone and the label in ink-2 at regular weight, no box, no border — the
   colour carries the meaning on seven pixels and a column of them leaves the
   names in charge. Where the status IS the content — a record header, a
   checklist item, a drawer's one status line, a quiz verdict — it is FILLED
   (`.is-fill`): the tone as a solid ground, the label in `--atlas-on-accent`.
   The outlined pill (2026-08-12's answer, and a never until today) retires;
   the dot variant that proof rejected is now the row form. Research and
   Brandon's ruling: A342. Not a tint (L3): a tint is a wash behind a coloured
   label; this is a dot, or a solid ground.
   ⚠️ IT IS NOT `.a-pill`, WHICH IS A CONTROL. That one is a filter you press —
   `cursor:pointer`, a hover, a press translate and an `is-on`. This one is a
   READOUT: it says what state a record is in and there is nothing to click.
   ⚠️ THE TONE VOCABULARY IS UNIONED, NOT CHOSEN — `is-closed`/`is-done` both
   mean money, `is-active`/`is-review` both mean accent; both names stay on one
   rule (promoted 2026-08-26 from two surface copies). What must NOT happen is
   a third word for either. The tone is ONE custom property, `--st-tone`, read
   by the dot and by the fill, so a tone is declared once. */
.a-st{
  display:inline-flex; align-items:center; gap:var(--atlas-s6); flex:none;
  height:var(--atlas-h-status); padding:0; border:0; border-radius:0;
  background:transparent; color:var(--atlas-ink-2);
  font-size:var(--atlas-fs-xs); line-height:1; white-space:nowrap;
  --st-tone:var(--atlas-ink-3);
}
.a-st::before{ content:""; width:7px; height:7px; border-radius:50%; background:var(--st-tone); flex:none }
.a-st svg{ flex:none }
.a-st.is-sm{ font-size:var(--atlas-fs-2xs); color:var(--atlas-ink-3) }
.a-st.is-active,
.a-st.is-review{ --st-tone:var(--atlas-accent) }
.a-st.is-closed,
.a-st.is-done  { --st-tone:var(--atlas-money) }
.a-st.is-urgent{ --st-tone:var(--atlas-urgent); color:var(--atlas-ink) }     /* urgent earns the full ink */
.a-st.is-warn  { --st-tone:var(--atlas-warn) }
.a-st.is-dead  { --st-tone:var(--atlas-line-2); color:var(--atlas-ink-3) }
.a-st.is-draft,
.a-st.is-back  { --st-tone:var(--atlas-hue-3) }
/* FILLED — where the status is the content: the checklist (K9's first consumer),
   a record header, a verdict. */
.a-st.is-fill{
  padding:0 var(--atlas-s8); border-radius:var(--atlas-r-sm);
  background:var(--st-tone); color:var(--atlas-on-accent); font-weight:var(--atlas-fw-medium);
}
.a-st.is-fill::before{ display:none }
.a-st.is-fill.is-dead{ background:var(--atlas-line-2); color:var(--atlas-ink-2) }
.a-st.is-fill.is-sm{ color:var(--atlas-on-accent) }
.a-st.is-fill.is-sm.is-dead{ color:var(--atlas-ink-2) }
.a-st.is-fill.is-draft,
.a-st.is-fill.is-back  { background:var(--atlas-hue-3) }
.a-st.is-fill.is-dead,
.a-st.is-fill.is-quiet { background:var(--atlas-bg-3); color:var(--atlas-ink-2) }
/* ON A PHONE THE FILL STAYS A PILL. The outlined pill drops its chrome there
   ("just text", above) because the label alone still carries the colour; a
   filled label with its ground removed would be the label alone in the
   on-colour ink — white on white. So the fill keeps its box. */
.ash-shell.is-phone .a-st.is-fill{
  height:var(--atlas-h-status); padding:0 var(--atlas-s8);
  border:var(--atlas-bw-em) solid transparent; border-radius:var(--atlas-r-sm);
}

/* A5 — THE LABEL IS THE HIT TARGET, not just the 19px box. A checkbox whose
   words do nothing is the single most common form bug.

   ⚠️ A5 WAS NEVER ACTUALLY IMPLEMENTED, AND THIS CLASS IS WHY IT LOOKED LIKE IT
   WAS (audited 2026-08-15). Every call site put the words OUTSIDE `.crm2-check`
   as a sibling, so this rule was styling a span containing exactly one 19px box:
   the `gap` had nothing to space, and the "row" hover was a halo around the mark.
   The click handlers read `closest('[data-*-toggle]')`, and that attribute sat on
   the box-span, so a click on the words walked straight past it — and because the
   control is a `<span role="checkbox">` rather than an `<input>`, the wrapping
   `<label>` gave no native forwarding either. Verified live in New lead: clicking
   "They are selling this address" did nothing, twice; clicking the box toggled.
   `.nl-check` even set `cursor:pointer` on the row, so the words ADVERTISED a
   target that was not there. A5 was aspirational text for four months.

   ⚠️ THE WORDS NOW LIVE INSIDE THIS ELEMENT, and the toggle attribute belongs on
   it. That is the whole fix — one element that is the control, the label and the
   hit target, so `closest()` finds it from anywhere inside.

   ⚠️ AND IT IS `inline-flex`, NOT `flex` (Brandon, 2026-08-15). A block-level
   control fills its container, so a single setting painted a full-width band on
   hover and read as a big grey button — which is what he flagged in the
   announcement drawer. Hugging its content keeps the fill the size of the thing
   you are actually clicking. The fill itself is unchanged: `bg-2` hover, `bg-3`
   press, the same two steps every other control in Atlas uses.

   ⚠️ WHEN NOT TO USE THIS — the distinction Brandon drew, stated structurally:
   does the text belong to the CHECKBOX, or to a RECORD?
     · The words ARE the setting ("They own their home", "Keep this pinned",
       "Create another") → this class. The words are the control.
     · The words are a RECORD's identity (a task's title, a lead's name) → a bare
       `.crm2-box[role="checkbox"]`. The row already has its own job — opening
       the task, opening the lead — so making the title also toggle a checkbox
       would give one piece of text two meanings. The task queue, the table's row
       selector and Huddle's permission matrix are all correctly box-only, and
       they stay that way. */
.crm2-check{
  display:inline-flex; align-items:center; gap:var(--atlas-s10);
  padding:var(--atlas-s6) var(--atlas-s6); border-radius:var(--atlas-r-sm);
  cursor:pointer; font-size:var(--atlas-fs-sm); color:var(--atlas-ink);
  transition:background var(--atlas-dur-instant);
  -webkit-user-select:none; user-select:none;   /* a target you double-click must not select text */
}
/* The words. They inherit the control's size and colour rather than declaring
   their own, because three surfaces had three different answers (fs-xs/ink-2 in
   New lead, fs-md/ink on the dashboard) for the same kind of sentence. */
.crm2-check-l{ min-width:0 }
@media (hover: hover){ .crm2-check:hover{ background:var(--atlas-bg-2) } }
/* ⚠️ DOWN, NOT SIDEWAYS, AND ON THE TOKEN. This was `translateX(1px)` — the
   press slid the control to the RIGHT, which reads as a drag rather than a
   push, and it hardcoded the distance so it could not follow
   `--atlas-press`. P39/P41: a press translates DOWN, because that is the
   direction a physical control moves under a finger. (Brandon, 2026-08-14 —
   spotted in the New-lead drawer, but the bug was in the shared token and
   every checkbox in Atlas had it.) */
/* the row no longer translates — the BOX is the mark and the mark compresses (A344) */
/* ⚠️ .88, NOT THE THUMB'S .96 (A344 amended 2026-10-27): on a 19px mark .96 moves the edge under a pixel —
   Brandon could not see it. A press moves a mark's edge ~2px whatever its size: .96 at 100px, .88 at 19px. */
.crm2-check:active .crm2-box{ transform:scale(.88); transition:transform 90ms var(--atlas-ease-out) }

@media (pointer: fine){ .crm2-check:active{background:var(--atlas-bg-3); } }
/* A24 — MARK controls (checkbox, radio) are 19px and take the EMPHASIS border:
   at that size a 1px hairline does not read at all. Container controls keep 1px.
   Square vs round IS the distinction between the two marks. */
.crm2-box{
  width:var(--atlas-h-mark); height:var(--atlas-h-mark); flex:none;
  border:var(--atlas-bw-em) solid var(--atlas-line-2); border-radius:var(--atlas-r-xs);
  display:grid; place-items:center; color:transparent;
  transition:background var(--atlas-dur-instant),border-color var(--atlas-dur-instant);
}
/* WHEN THE MARK **IS** THE CONTROL it takes the cursor and the press, like
   every other control in the system (P20/P48/P39). `[role="checkbox"]` is the
   honest test rather than a second class: inside `.crm2-check` the ROW is the
   control — it already points and presses, and the box carries no role — so a
   press here as well would move the mark inside a moving row. The table's
   header box is the case that exposed it: nothing above it sets a cursor, so
   select-all was the one checkbox in Atlas that did not look clickable. */
.crm2-box[role="checkbox"]{ cursor:pointer }

/* ── THE SWITCH (A228, 2026-09-05) — a real on/off toggle for SETTINGS.
   Brandon: strict progression "should be a real on and off toggle… in our
   kit". This amends A24's one-binary-control law with a second, DISTINCT
   vocabulary: the CHECKBOX marks and selects (rows, perms, lists); the
   SWITCH flips a live mode on or off, alone on a settings row. Never both
   for the same question. Geometry only — hairline track, sliding knob,
   accent when on; the knob is border-box 14px inside a 36×20 track, travel
   = 16px. Markup: <button class="a-tgl" role="switch" aria-checked>
   <span class="a-tgl-knob"></span></button>. */
/* ══ THE EDGE TAB — a pull-tab flush on a seam (promoted from Market, where
   the collapsed-list tab and the filters tab both wear it — the surface's one
   affordance vocabulary: tabs on a seam extend surfaces). `.is-right` hangs
   off a RIGHT seam (rounded left, no right border); `.is-left` mirrors it.
   `.a-etab-n` is the tab's count — a plain tabular number, never a filled
   badge (colour carries meaning, not arithmetic). Placement (position/top/
   z-index) stays the consumer's. ══ */
.a-etab{
  display:inline-flex; align-items:center; justify-content:center; gap:var(--atlas-s6);
  height:var(--atlas-h-btn-sm); min-width:var(--atlas-h-btn-sm);
  background:var(--atlas-bg-1); color:var(--atlas-ink-2);
  border:var(--atlas-bw) solid var(--atlas-line);
  font:inherit; font-size:var(--atlas-fs-xs); font-weight:var(--atlas-fw-semi);
  cursor:pointer;
}
.a-etab.is-right{ padding:0 var(--atlas-s10) 0 var(--atlas-s8); border-right:0; border-radius:var(--atlas-r-md) 0 0 var(--atlas-r-md) }
.a-etab.is-left{ padding:0 var(--atlas-s8) 0 var(--atlas-s10); border-left:0; border-radius:0 var(--atlas-r-md) var(--atlas-r-md) 0 }
@media (hover: hover){ .a-etab:hover{ background:var(--atlas-bg-2); color:var(--atlas-ink) } }
.a-etab:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press))); transition:var(--atlas-press-in, none) }
@media (pointer: fine){ .a-etab:active{ background:var(--atlas-bg-2) } }
.a-etab-n{ font-variant-numeric:tabular-nums }

/* THE SWITCH (A228, rebuilt as A339 on 2026-10-26). It was a bordered track
   holding a bordered knob with no shadow — a box in a box, the seg's disease —
   and in dark the off knob was DARKER than its track, a hole. Now: no borders,
   a 20px knob on the thumb lift with a 2px inset, the off track one step down
   the ladder (`--atlas-tgl-off`), on the accent, the knob the bright end in
   both themes (`--atlas-knob`). The knob STRETCHES 4px while held, anchored on
   the side it sits on (Apple's press), and DRAGS — kit.js follows the pointer
   and lets the switch's own click commit the side it lands on, so no consumer
   changed. The press is the mark's (A344): the switch itself never moves. */
.a-tgl{
  width:40px; height:24px; flex:none; position:relative; box-sizing:border-box;
  border:0; border-radius:999px; padding:0; cursor:pointer;
  background:var(--atlas-tgl-off); --tgl-x:2px; --tgl-w:20px;
  transition:background var(--atlas-dur-fast);
  -webkit-tap-highlight-color:transparent; touch-action:pan-y;
}
.a-tgl-knob{
  position:absolute; top:2px; left:0; width:var(--tgl-w); height:20px; box-sizing:border-box;
  border-radius:10px; background:var(--atlas-knob); box-shadow:var(--atlas-lift-thumb);
  transform:translateX(var(--tgl-x)); pointer-events:none;
  transition:transform var(--atlas-dur-fast) var(--atlas-ease-out), width var(--atlas-dur-instant) var(--atlas-ease-out);
}
.a-tgl.is-on{ background:var(--atlas-accent) }
.a-tgl.is-on .a-tgl-knob{ --tgl-x:18px }
.a-tgl:active .a-tgl-knob, .a-tgl.is-hold .a-tgl-knob{ --tgl-w:24px }                    /* held: the knob stretches… */
.a-tgl.is-on:active .a-tgl-knob, .a-tgl.is-on.is-hold .a-tgl-knob{ --tgl-x:14px }        /* …anchored on its own side */
.a-tgl.is-drag .a-tgl-knob{ transition:width var(--atlas-dur-instant) var(--atlas-ease-out) }   /* the pointer owns x */
.a-tgl:disabled{ opacity:.5; cursor:not-allowed }
.a-tgl:focus-visible{ outline:none; box-shadow:0 0 0 2px var(--atlas-bg-1), 0 0 0 3.5px var(--atlas-accent) }
@media (prefers-reduced-motion: reduce){ .a-tgl, .a-tgl-knob{ transition:none } }

/* ── THE RICH FIELD'S INLINE IMAGE (2026-09-05) — dropped in, dragged into
   place (the surface wires the mechanics; the caret is the drop indicator).
   It owns its line; capped so a screenshot never floods the column; the grab
   cursor promises the drag (P38). */
/* ⚠️ INLINE-BLOCK, NOT BLOCK (Brandon, 2026-09-08: *"i need to be able to use
   the alignment tool on them"*). The toolbar's align buttons are
   `justifyLeft/Center/Right`, and every one of them writes `text-align` on the
   LINE CONTAINER — which moves inline-level content and does nothing whatever
   to a block-level box with non-auto side margins. So the button applied, the
   wrapper really did carry `text-align:center`, and the image sat flush left:
   nothing was broken except the one property that decides whether the
   instruction can land. Inline-block keeps the "owns its line" behaviour the
   note below describes (it is the only thing on its line) while making it
   something alignment can actually move. `vertical-align:top` kills the
   baseline descender gap an inline-block otherwise sits on. */
.a-rich-img{
  display:inline-block; vertical-align:top; max-width:min(520px, 100%); height:auto;
  border:var(--atlas-bw) solid var(--atlas-line); border-radius:var(--atlas-r-md);
  margin:var(--atlas-s8) 0;
  cursor:grab;
}
.a-rich-img:active{ cursor:grabbing }
.a-rich-img.is-uploading{ opacity:.55 }
.crm2-box[role="checkbox"]:active{ transform:scale(.88); transition:transform 90ms var(--atlas-ease-out) }
.crm2-check.is-locked .crm2-box{ cursor:not-allowed }
/* ⚠️ THE MARK OWNS ITS OWN STATE. This was written ONLY as
   `.crm2-check.is-on .crm2-box` — the on-state lived on the PARENT ROW, so a
   checkbox used anywhere without that wrapper (the table's, which is a cell,
   not a row of its own) could never turn on. It selected, it spined, it
   counted, and the box stayed empty.
   A24 amended: A CONTROL'S STATE BELONGS TO THE CONTROL. A parent may still
   carry it for a whole row, but the mark must not DEPEND on one. */
.crm2-box.is-on,
.crm2-check.is-on .crm2-box{
  background:var(--atlas-accent); border-color:var(--atlas-accent); color:var(--atlas-bg-1);
}
/* THE DRAW AND THE POP (A343, 2026-10-26) — only on a check you just made.
   kit.js stamps `is-arm` on the box for half a second after a click or a
   keypress, so a page that renders with checked boxes does not animate them
   all on arrival. The glyph is Phosphor's filled check, so "drawing" it is a
   left-to-right clip reveal; the box pops on the control spring. */
/* both homes of `.is-on` — on the box (the table) and on the row (every label checkbox) */
.crm2-box.is-arm.is-on svg, .crm2-check.is-on .crm2-box.is-arm svg{ animation:a-check-draw 160ms var(--atlas-ease-out) 40ms both }
.crm2-box.is-arm.is-on, .crm2-check.is-on .crm2-box.is-arm{ animation:a-mark-pop 260ms var(--atlas-ease-out) }
@keyframes a-check-draw{ from{ clip-path:inset(0 100% 0 0) } to{ clip-path:inset(0 0 0 0) } }
/* the small mark's pop — from the press depth THROUGH an overshoot, so it is seen at 19px (A344 amended) */
@keyframes a-mark-pop{ 0%{ transform:scale(.88) } 55%{ transform:scale(1.08) } 100%{ transform:scale(1) } }
@media (prefers-reduced-motion: reduce){ .crm2-box.is-arm svg, .crm2-box.is-arm{ animation:none } }
/* ⚠️ THE OTHER MARK (A24), promoted from the lab when the lead panel needed it.
   SQUARE VS ROUND IS THE DISTINCTION — a checkbox says "any number of these", a
   radio says "one of these" — so a system with only the square one ends up with
   square boxes that silently untick their neighbours, which is a control lying
   about what it does.

   The ON state is the BORDER COLLAPSING INWARD (6px of accent) rather than a
   dot drawn inside it: one element, no centring to get wrong at any size, and
   the transition is a single property.

   `--atlas-h-mark-sm` here, not the 19px standalone size — same reasoning as
   the table's checkbox: it repeats once per row and competes with the value
   beside it, and the whole row is the hit target. */
/* ⚠️ THE ON STATE IS THE CHECKBOX'S (A348, 2026-10-27): an ACCENT FILL with a bg-1
   dot, not the border collapsing to a ring — two marks in one family had two ideas
   of "on", and the fill-plus-dot is Apple's radio on every platform. The dot is a
   `::after` that scales in, so the mark stays one element with nothing to centre
   by hand. The lead rail's contact radios keep the row size (`mark-sm`); the kit
   row below takes the standalone 19px. */
.crm2-radio{
  position:relative;
  width:var(--atlas-h-mark-sm); height:var(--atlas-h-mark-sm); flex:none;
  border:var(--atlas-bw-em) solid var(--atlas-line-2);
  border-radius:var(--atlas-r-full); box-sizing:border-box; background:transparent;
  transition:border-color var(--atlas-dur-instant), background var(--atlas-dur-instant), transform 90ms var(--atlas-ease-out);
}
.crm2-radio::after{
  content:""; position:absolute; inset:0; margin:auto; width:38%; height:38%;
  border-radius:var(--atlas-r-full); background:var(--atlas-on-accent);
  transform:scale(0); transition:transform var(--atlas-dur-instant) var(--atlas-ease-out);
}
.is-on > .crm2-radio,
.crm2-radio.is-on{ background:var(--atlas-accent); border-color:var(--atlas-accent) }
.is-on > .crm2-radio::after,
.crm2-radio.is-on::after{ transform:scale(1) }

/* ══ THE RADIO ROW AND GROUP — `.a-radios` > `.a-radio` (A348, 2026-10-27) ═══
   A one-of question with three to seven answers whose labels need room (the
   Controls chapter's rule; the seg is for two to four short ones). The ROW is
   the whole target — the standalone 19px mark, the label at the form's size,
   the kit hover and press, a locked state — and the GROUP stacks rows at the
   kit gap, carries one accessible name, and arrow keys walk it (kit.js moves
   `.is-on` at capture on a pick, as it does for the seg, and arms the pop).
   Rows are <button type="button"> so Space and Enter are the browser's. */
.a-radios{ display:flex; flex-direction:column; gap:var(--atlas-s2); min-width:0 }
/* ⚠️ THE ROW FITS ITS ANSWER, NOT THE COLUMN (Brandon, 2026-10-27, on the inspection
   election: a hover band stretched across 560px of nothing beside a two-word answer).
   `max-content` shrink-wraps the row to the mark, the label and 8px of air each side —
   the air stays, because a highlight that touches its own text reads cramped (every
   macOS menu and sidebar row pads). The group still stacks them left-aligned, and the
   label is still the whole target (A5); what went is the empty run to the right. */
.a-radio{
  display:flex; align-items:center; gap:var(--atlas-s10); box-sizing:border-box;
  width:max-content; max-width:calc(100% + 2 * var(--atlas-s8)); margin:0 calc(-1 * var(--atlas-s8));
  height:var(--atlas-h-field); padding:0 var(--atlas-s10) 0 var(--atlas-s8);
  border:0; border-radius:var(--atlas-r-md); background:none; text-align:left;
  font:inherit; font-size:var(--atlas-fs-md); color:var(--atlas-ink); cursor:pointer;
  -webkit-user-select:none; user-select:none; -webkit-tap-highlight-color:transparent;
  transition:background var(--atlas-dur-instant);
}
.a-radio .crm2-radio{ width:var(--atlas-h-mark); height:var(--atlas-h-mark) }
/* `.is-sm` — the rail rung (2026-11-03, A348 amended): the same row, press and pop at the
   in-field height with the 16px mark and the small label, for a one-of mark that sits beside
   a value (the lead rail's Best) rather than under a question. Not a different asset. */
.a-radio.is-sm{ height:var(--atlas-h-infield); gap:var(--atlas-s6); padding:0 var(--atlas-s8) 0 var(--atlas-s6); margin:0; font-size:var(--atlas-fs-xs) }
.a-radio.is-sm .crm2-radio{ width:var(--atlas-h-mark-sm); height:var(--atlas-h-mark-sm) }
.a-radio-l{ flex:1 1 auto; min-width:0 }
@media (hover: hover){ .a-radio:hover{ background:var(--atlas-bg-2) } }
@media (pointer: fine){ .a-radio:active{ background:var(--atlas-bg-3) } }
.a-radio:active .crm2-radio{ transform:scale(.88) }                      /* the press is the mark's (A344) */
.a-radio.is-on.is-arm .crm2-radio{ animation:a-mark-pop 260ms var(--atlas-ease-out) }
.a-radio.is-on.is-arm .crm2-radio::after{ animation:a-dot-in 220ms var(--atlas-ease-out) 30ms both }
@keyframes a-dot-in{ 0%{ transform:scale(0) } 70%{ transform:scale(1.25) } 100%{ transform:scale(1) } }
.a-radio:focus-visible{ outline:none }
.a-radio:focus-visible .crm2-radio{ box-shadow:0 0 0 2px var(--atlas-bg-1), 0 0 0 3.5px var(--atlas-accent) }
.a-radio.is-locked, .a-radio[disabled]{ opacity:.55; cursor:not-allowed }
@media (prefers-reduced-motion: reduce){ .a-radio .crm2-radio, .a-radio .crm2-radio::after{ animation:none; transition:none } }

.crm2-check.is-locked{ opacity:.55; cursor:not-allowed }
/* C4 — a disabled control STATES WHY. "Locked" on its own is a shrug. */
.crm2-why{ margin-left:auto; font-size:var(--atlas-fs-2xs); color:var(--atlas-ink-3) }

/* ══ ACTION BUTTONS ═════════════════════════════════════════════════════════
   P35's OTHER family. A toolbar button OPENS; an action button COMMITS — so a
   drawer footer takes these, not toolbar buttons. The first cut used .crm2-tb
   for both footer buttons, which is why "Reset" and "Show results" competed:
   two identical outlined controls, no weighted action, nothing for the eye to
   land on.

   ONE WEIGHTED ACTION per footer (the lab's do/don't): primary filled, secondary
   recedes, destructive sits FAR LEFT away from the button being reached for.
   Values mirror the lab's .lab-btn family through TOKENS — nothing hardcoded, so
   changing the token changes both. ⚠️ KIT-BOUND: this is not a CRM asset. */
/* ⚠️ FIXED HEIGHT, BORDER-BOX — so no member of the family can be a different
   size for wearing a different border. Without it the AI button (`bw-em`,
   1.75px) stood 1.5px taller than the commit button next to it: invisible at
   DPR 1 where the engine rounds the border to 1px, obvious on a retina screen.
   That is A21's rule, which this family was the one to be missing. */
.a-btn{
  /* Same reason as `.a-tb`'s (MB157): a styled button must not also be a native
     control, or the platform decides what its background is. `.a-btn-p` has
     always LOOKED filled because a `border` declaration is enough to drop
     WebKit's theming on this family — which is luck, not a rule, and luck that
     `.a-tb` did not share. */
  appearance:none; -webkit-appearance:none;
  display:inline-flex; align-items:center; justify-content:center; gap:var(--atlas-s8);
  height:var(--atlas-h-btn); box-sizing:border-box;
  font:inherit; font-size:var(--atlas-fs-md); font-weight:var(--atlas-fw-semi);
  padding:0 var(--atlas-s16);
  border:var(--atlas-bw) solid transparent; border-radius:var(--atlas-r-md);
  background:none; cursor:pointer; white-space:nowrap;
  /* ⚠️ A BUTTON IS NOT A LINK, WHATEVER ELEMENT IT IS BUILT FROM. `.a-btn`
     never reset this, and the rebuild already had anchors wearing it —
     Call / Text / Email on the lead profile and the tasks card — all
     rendering UNDERLINED, so a button read as a link in the one place the
     distinction matters. Found by measuring `textDecorationLine`, not by
     eye: an underline under a bordered pill is easy to look straight past. */
  text-decoration:none;
  /* ⚠️ AND IT MUST SET ITS OWN COLOUR, for the same reason and by the same
     evidence. `<a>` carries `color:-webkit-link` from the UA sheet, which beats
     inheritance — so a bare `.a-btn` (no `-p`/`-s`/`-g`/`-d`, all of which do
     set one) rendered BLUE, and PURPLE once visited. Caught on "Back to the
     pipeline", the first internal-href button in the rebuild: a plum-coloured
     button in a system with one accent. The variants hid the gap because they
     each declare a colour and this base never did. */
  color:var(--atlas-ink);
  transition:background var(--atlas-dur-instant), border-color var(--atlas-dur-instant),
             filter var(--atlas-dur-instant), transform var(--atlas-dur-instant) var(--atlas-ease-out);
}
/* translateY, never scale — a scale shrinks the hit box on every side and the
   cursor flickers arrow-hand-arrow mid-press. Instant down, eased release. */
.a-btn:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press))); transition:var(--atlas-press-in, none) }
/* ⭐ P13's focus state, WHICH `.a-btn` NEVER HAD (added 2026-08-18). Seven
   other families in this file carry `:focus-visible{ outline:none; … }` and the
   button — the most-focused control in Atlas — was still wearing the browser's
   default ring. Invisible until something focuses a button programmatically,
   which is exactly what a dialog does when it opens (Brandon saw the blue
   outline on the confirm's commit). One rule here rather than a patch there:
   a kit class is a look, not a location (L32). */
/* ⚠️ NO FOCUS RING HERE, DELIBERATELY, AND THAT IS A GAP RATHER THAN A
   DECISION. I added one (a gap-then-accent ring borrowed from `.a-swatch`) to
   kill a browser-default outline on the confirm dialog, and Brandon killed it:
   *"NOWHERE in our kit do our accent buttons have a ring."* He is right — it
   was a KIT-WIDE change to every button in Atlas, made to fix one dialog, and
   a swatch is not a button: a 22px circle with no label has nothing but a ring
   to show focus with, while a button has a label, a fill and a press.

   The dialog stopped forcing focus onto its commit button instead, which is
   what was summoning the outline in the first place — it focuses the dialog.

   ⭐ ANSWERED 2026-08-19 — see "KEYBOARD FOCUS" at the foot of this file. It is
   one rule for every pressable in the kit, and it is a SELECT state rather than
   a ring, which is what Brandon asked for both times. */

/* ⚠️ THE KEYBOARD'S `:active` (2026-08-15). `:active` is a POINTER state, so a
   control committed with Enter never showed a press — the action ran and the
   button that represents it sat perfectly still. `.is-press` is that same state,
   applied by `K.press()` for one press-length, and it is deliberately UNIVERSAL
   rather than repeated per family: any control in Atlas depresses the same
   distance from the same token, so the rule that says so should be written once.
   Placed after `:active` so the two cannot disagree. */
.is-press{ transform:translateY(var(--atlas-press)) !important; transition:none !important }

/* ⭐ THE TAP FLASH (2026-09-13) — the press a fast tap could never show.
   `--atlas-press-in` holds the press back 150ms inside a scroller so a scroll
   never flashes it; a tap released before that therefore painted NOTHING.
   `K.haptic`'s neighbour in kit.js adds `.is-tap` only once a gesture has
   PROVEN itself a tap (under 150ms, under 8px of travel), so this can never
   fire during a scroll — and it carries no delay of its own, because by the
   time it lands the finger has already gone.
   ⚠️ TWO RULES, BECAUSE THERE ARE TWO PRESS SCALES. A row or card compresses
   less than a small control (`.985` vs `.97`) — the same split `:active`
   already makes — and a single generic rule would push cards too far and
   buttons not far enough. The tokens are the same ones each family's own
   `:active` reads, so the flash cannot drift from the press it stands in for.
   ⚠️ Coarse only: a pointer has `:hover` and a real `:active` with no delay to
   work around. */
@media (pointer: coarse){
  .tbl2-card.is-tap{
    transform:var(--atlas-press-t-row, scale(.985));
    transition:transform var(--atlas-dur-fast) var(--atlas-ease-out);
  }
  .a-btn.is-tap, .a-tb.is-tap, .a-x.is-tap, .pick-row.is-tap,
  .a-pill.is-tap, .crm2-check.is-tap{   /* .seg-b left this list 2026-10-26 — its press is the thumb's (A344) */
    transform:var(--atlas-press-t, scale(.97));
    transition:transform var(--atlas-dur-fast) var(--atlas-ease-out);
  }
}
.a-btn-p{ background:var(--atlas-accent); color:var(--atlas-on-accent) }
@media (hover: hover){ .a-btn-p:hover{ filter:brightness(var(--atlas-hover-k, 1.07)) } }   /* it had NO hover and read inert (A345) */
@media (pointer: fine){ .a-btn-p:active{filter:brightness(.93) } }
.a-btn-s{ background:var(--atlas-bg-1); border-color:var(--atlas-line-2); color:var(--atlas-ink) }
@media (hover: hover){ .a-btn-s:hover{ background:var(--atlas-bg-2) } }
.a-btn-g{ color:var(--atlas-ink-2) }
@media (hover: hover){ .a-btn-g:hover{ background:var(--atlas-bg-2); color:var(--atlas-ink) } }
@media (pointer: fine){ .a-btn-g:active, .a-btn-s:active{background:var(--atlas-bg-3) } }
/* Danger is TEXT, not a filled block, until it is the committed action — a
   drawer's reset is recoverable, so it must not shout like a delete. */
.a-btn-d{ color:var(--atlas-urgent) }
/* ⚠️ A FILLED DESTRUCTIVE PRIMARY, AND IT DID NOT EXIST (2026-08-27). `.a-btn-d`
   is the GHOST danger — right for a menu row, wrong for the commit in a confirm,
   where the action needs a primary's weight. Written as a modifier on `.a-btn-p`
   so the two cannot disagree about geometry: only the colour changes.
   ⚠️ IT IS OPT-IN. The legacy confirm painted EVERY confirm red, so "Save these
   changes?" looked exactly as dangerous as "Delete this deal" — which is how red
   stops meaning anything. */
.a-btn-p.is-danger{ background:var(--atlas-urgent); color:var(--atlas-on-accent); border-color:transparent }
@media (pointer: fine){ .a-btn-p.is-danger:active{filter:brightness(.93) } }
@media (hover: hover){ .a-btn-d:hover{ background:var(--atlas-bg-2) } }

/* ── SIZE AND SHAPE (2026-08-15) ───────────────────────────────────────────
   `.a-btn.is-icon` was written at three call sites and DEFINED AT NONE — the
   only rule in the codebase was `.tskc-top-a .a-btn.is-icon{width:34px}`, one
   surface's local patch. So everywhere else the "icon button" was a 44-tall,
   16-padded pill holding a single glyph, and in the one place it was patched it
   came out 34×44: a rectangle, not a square. `.a-tb` (the toolbar family) has
   had this rule since the shell; `.a-btn` simply never got it.
   The rule is `.a-tb.is-icon`'s, restated: `.is-icon` is a promise the button
   holds ONE glyph, and a one-glyph button is a SQUARE of the family's height —
   the width is not a number to pick per surface, it is the height. */
.a-btn.is-icon{ padding:0; width:var(--atlas-h-btn); justify-content:center }
/* The same button in a dense row, paired with `--atlas-h-btn-sm` (the height
   the composer footer already scopes by hand). 44 is right when the button is
   what you came to press; beside a checkbox it is furniture. */
.a-btn.is-sm{ height:var(--atlas-h-btn-sm); font-size:var(--atlas-fs-sm) }
.a-btn.is-sm.is-icon{ width:var(--atlas-h-btn-sm) }

/* ⚠️⚠️ A DISABLED BUTTON MUST NOT LOOK OR FEEL LIVE — AND THIS DID NOT EXIST
   (2026-08-20). There was no `[disabled]` rule anywhere in the kit, so a
   disabled primary was BYTE-IDENTICAL to a live one: same accent background,
   opacity 1, `cursor:pointer`, hover intact, press intact. Measured on 201Sign's
   Send button, which is deliberately off until there is a signing page — it
   rendered at full brightness and depressed under the pointer. The click was
   correctly refused by the element, so nothing broke; it just read as a dead
   feature instead of an unavailable one.

   ⚠️ THE POINTER IS THE HALF THAT LIES LOUDEST. The interaction rules bind both
   ways: a pointer on something unclickable is a promise the surface cannot keep.
   `pointer-events:none` retires the cursor, the hover and the press together —
   which matters because hover and press are declared PER VARIANT, and chasing
   each one with a disabled twin is how a state ends up half-applied.

   Opacity rather than a muted palette, deliberately: it holds for every variant
   including the AI button, and the kit already dims locked progress labels the
   same way. Not a tint — the hue is untouched. */
.a-btn[disabled], .a-btn:disabled,
.a-btn-ai[disabled], .a-btn-ai:disabled{
  opacity:.45;
  cursor:default;
  pointer-events:none;
}

/* ══ THE SEGMENTED CONTROL (A338, 2026-10-26 — supersedes the A19/A24 build) ══
   A recessed WELL with a travelling THUMB. The track is one step down the
   neutral ladder and carries NO border; the thumb sits 2px inside it with
   concentric corners and a crisp lift (`--atlas-lift-thumb`); both labels are
   ink and WEIGHT carries selection. Brandon, on the previous one: *"ugly and
   looks cheap — big and bulky."* Measured before it was replaced: a hairline
   framing a raised pill (a box in a box), a 4px dead ring (Apple: 1–2px), 7/5
   corners that were not concentric, three colours for one state, a 5px-blur
   shadow, a snap on select, and in dark a bg-1 thumb invisible on a bg-1 rail.
   At the 44 rung nothing scaled — same inset, same radius, bigger box — which
   is why the wizard was the worst case.

   THE MARK IS ONE ELEMENT THAT MOVES. kit.js mounts `.seg-thumb` into every
   `.seg-ctl` it finds — now and later, through a MutationObserver — positions
   it on `--seg-x` / `--seg-w` from the `.is-on` segment's rect, and animates
   it whenever `.is-on` moves, whoever moves it. Surfaces keep owning selection
   exactly as before; nothing is wired per surface (MB115). A seg that a
   surface REBUILDS on change still travels: the engine carries the in-flight
   position across to the replacement (keyed on the labels). Until the thumb
   mounts, `.seg-b.is-on` paints the thumb itself, so a late kit.js (trap 44)
   shows a correct control rather than an empty well.

   ⚠️ A COLUMN FLEXBOX STRETCHES AN INLINE-FLEX CHILD — `align-self:flex-start`
   lives on the asset now; wizard.css and the mock both paid for it.

   THE PRESS IS THE MARK'S (A344): holding the selected segment compresses the
   thumb to .96 and releases on the control spring; an unselected one only dims
   its label. The segment never translates — a track that jumps under a thumb
   that looks physical breaks the thumb. Drag the thumb to another segment and
   it commits on release through that segment's own click. */
/* ⚠️ `[hidden]` MUST OUTRANK EVERY `display` WE WRITE, AND ONLY `!important`
   DOES THAT. The browser's own `[hidden]{display:none}` lives in the UA
   stylesheet, which ANY author rule beats — so `.a-btn{display:inline-flex}`
   silently defeated it, and `el.hidden = true` did nothing at all. That is how
   the composer's 8-character Clean up gate was dead for a whole session: the JS
   was correct, the attribute was set, and the button stayed on screen.

   This is the one legitimate `!important` in the system. `hidden` is not a
   style, it is a statement that the element is not rendered, and a `display`
   that overrides it is always a bug. (normalize.css ships the same rule for the
   same reason.) Anything that needs to be visible must not carry the
   attribute. */
[hidden]{ display:none !important }

.seg-ctl{
  position:relative; display:inline-flex; align-items:stretch; align-self:flex-start;
  height:var(--atlas-h-control); box-sizing:border-box; max-width:100%;
  padding:2px; gap:0; border:0;
  border-radius:var(--atlas-seg-r, var(--atlas-r-md));
  background:var(--atlas-seg-track);
  --seg-x:2px; --seg-w:0px;
  touch-action:pan-y; -webkit-tap-highlight-color:transparent;
}
@property --seg-s{ syntax:'<number>'; inherits:false; initial-value:1 }
.seg-ctl .seg-thumb{
  position:absolute; top:2px; bottom:2px; left:0; width:var(--seg-w);
  transform:translateX(var(--seg-x)) scale(var(--seg-s, 1));
  border-radius:calc(var(--atlas-seg-r, var(--atlas-r-md)) - 2px);
  background:var(--atlas-seg-thumb); box-shadow:var(--atlas-lift-thumb);
  pointer-events:none;
  transition:--seg-s var(--atlas-dur-instant) var(--atlas-ease-out), opacity var(--atlas-dur-instant);
}
.seg-ctl .seg-thumb.is-none{ opacity:0 }                 /* nothing selected: parked nowhere (A49's cleared state) */
.seg-ctl.is-hold .seg-thumb{ --seg-s:.96; transition:--seg-s 90ms var(--atlas-ease-out) }
.seg-ctl.is-release .seg-thumb{ transition:--seg-s var(--atlas-spring-ctl-dur) var(--atlas-spring-ctl) }
.seg-ctl .seg-b{
  position:relative; z-index:1; box-sizing:border-box;
  font:inherit; font-size:var(--atlas-fs-sm); font-weight:var(--atlas-fw-medium);
  color:var(--atlas-ink-2); cursor:pointer; text-decoration:none;
  display:inline-flex; align-items:center; justify-content:center;
  padding:0 var(--atlas-s12); border:0; background:none;
  border-radius:calc(var(--atlas-seg-r, var(--atlas-r-md)) - 2px);
  white-space:nowrap; min-width:var(--seg-mw, auto);    /* pinned by kit.js at the selected weight, so selecting moves nothing */
  transition:color var(--atlas-dur-fast);
}
.seg-ctl.is-measure .seg-b{ font-weight:var(--atlas-fw-semi); min-width:0 }
/* a divider between two UNSELECTED segments, never beside the thumb — what makes four words read as four segments */
.seg-ctl .seg-b::before{
  content:""; position:absolute; left:-0.5px; top:25%; height:50%; width:1px;
  background:var(--atlas-line-2); transition:opacity var(--atlas-dur-fast);
}
.seg-ctl .seg-b:first-child::before,
.seg-ctl .seg-b.is-on::before,
.seg-ctl .seg-b.is-on + .seg-b::before{ opacity:0 }
@media (hover: hover){ .seg-ctl .seg-b:not(.is-on):hover{ color:var(--atlas-ink) } }
.seg-ctl .seg-b.is-on{ color:var(--atlas-ink); font-weight:var(--atlas-fw-semi) }
/* kit.js not arrived yet: the segment paints the thumb itself (trap 44 — the kit can be ten seconds into a cold boot) */
.seg-ctl:not(.has-thumb) .seg-b.is-on{ background:var(--atlas-seg-thumb); box-shadow:var(--atlas-lift-thumb) }
/* the press belongs to the mark (A344): an unselected segment only dims, and only for a pointer (P41c) */
@media (pointer: fine){ .seg-ctl .seg-b:not(.is-on):active{ color:var(--atlas-ink-3) } }
.seg-ctl .seg-b:focus-visible{ outline:none }
.seg-ctl:has(.seg-b:focus-visible){ box-shadow:inset 0 0 0 1.5px var(--atlas-accent) }   /* one zero-blur ring on the track */
@media (prefers-reduced-motion: reduce){ .seg-ctl .seg-thumb, .seg-ctl .seg-b, .seg-ctl .seg-b::before{ transition:none } }

/* ══ THE ICON BUTTON — DISMISS / REMOVE (A39b) ═════════════════════════════
   ONE close, everywhere. There were THREE: `.drw-x` in the drawer header,
   `.sl-fp-x` in the field picker and `.sl-rule-x` on a rule — same job, three
   sets of numbers, and they had already drifted to different sizes and hover
   colors. Brandon spotted the field picker's, which is exactly how this gets
   found: one of them looks wrong beside the others.

   Sizes come from the ladder, not from taste: `--atlas-h-add` (24px, the WCAG
   2.5.8 floor) inline, `-lg` (32px) for a panel header, where the control sits
   alone and can afford to be the size of a real target.

   NEUTRAL by default. `.a-x-danger` goes urgent on hover ONLY where the action
   destroys something — a red × on every removable row turns a six-filter list
   into six warnings, so urgency is opt-in and appears on approach, never at
   rest. */
.a-x{
  display:grid; place-items:center; flex:none;
  width:var(--atlas-h-add); height:var(--atlas-h-add);
  border:0; background:none; cursor:pointer;
  color:var(--atlas-ink-3); border-radius:var(--atlas-r-xs);
  transition:color var(--atlas-dur-instant), background var(--atlas-dur-instant);
}
@media (hover: hover){ .a-x:hover{ color:var(--atlas-ink); background:var(--atlas-bg-2) } }
.a-x:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press))) }
.a-x-lg{ width:32px; height:32px; border-radius:var(--atlas-r-md) }
@media (hover: hover){ .a-x-danger:hover{ color:var(--atlas-urgent) } }

/* ══ THE CONTACT ROW (`K.cxRow`, kit/contact-row.js — 2026-11-04) ═══════════
   Lifted from the CRM rail's `.lead2-cx` so the deal hub's People card draws
   the same row. The value leads; the label slot sits at the far end; the copy
   button lives in that slot. The lead profile layers its own extras on these
   rows by adding `lead2-cx` to them (hairlines, Best, edit mode). */
.a-cx{
  display:flex; align-items:center; gap:var(--atlas-s8);
  padding:var(--atlas-s6) 0;
  font-size:var(--atlas-fs-md);
}
.a-cx-v{
  flex:1; min-width:0; color:var(--atlas-ink); text-decoration:none;
  overflow:hidden; text-overflow:ellipsis; white-space:nowrap;
}
@media (hover: hover){ .a-cx-v:hover{ text-decoration:underline; text-underline-offset:2px } }
/* The link is as wide as its text, not the row (Brandon, 2026-10-08): the
   empty space after a short number must not dial. Desktop only — on a phone
   the full-row target is the point (MB133, tap to copy). */
.ash-shell:not(.is-phone) .a-cx:has(> .a-cx-ts) > .a-cx-v{ flex:0 1 auto }
.ash-shell:not(.is-phone) .a-cx > .a-cx-ts{ margin-left:auto }
/* The label is a fact ABOUT the value — quiet, lowercase categories; a
   person's name (`is-who`) keeps its case (L28). */
.a-cx-t{ flex:none; font-size:var(--atlas-fs-2xs); color:var(--atlas-ink-3); text-transform:lowercase }
.a-cx-t.is-who{ text-transform:none }
/* HOVER MODE (default): label and copy button share ONE grid cell, so the slot
   is the wider of the two and nothing in the row moves on hover. */
.a-cx-ts{ flex:none; display:grid; align-items:center; justify-items:end }
.a-cx-ts > *{ grid-area:1 / 1 }
.a-cx-cp{ margin-block:-4px; opacity:0; pointer-events:none }
@media (hover: hover){
  .a-cx:hover .a-cx-cp,
  .a-cx-cp:focus-visible,
  .a-cx-cp.is-done{ opacity:1; pointer-events:auto }
  .a-cx:hover .a-cx-ts > .a-cx-t,
  .a-cx-ts:focus-within > .a-cx-t,
  .a-cx-ts:has(.is-done) > .a-cx-t{ visibility:hidden }
}
/* ALWAYS MODE (`is-copy-on`): the info is already behind a press, so the copy
   is one more click — label and button side by side, the label never hides. */
.a-cx.is-copy-on .a-cx-ts{ display:flex; gap:var(--atlas-s4) }
.a-cx.is-copy-on .a-cx-ts > *{ grid-area:auto }
.a-cx.is-copy-on .a-cx-cp{ opacity:1; pointer-events:auto }
@media (hover: hover){ .a-cx.is-copy-on:hover .a-cx-ts > .a-cx-t{ visibility:visible } }
/* No button where there is no hover: a tap copies, a hold opens the menu. */
@media (hover: none){ .a-cx-cp{ display:none } }
.ash-shell.is-phone .a-cx-cp{ display:none }

/* ══ THE SELECT (A24) ══════════════════════════════════════════════════════
   Lifted from the lab. A15 — a native control is REPLACED WHOLESALE or LEFT
   NATIVE, never half-styled; this is the replacement's shell, and the caret is
   ours so it matches every other control's chevron rather than the OS's.
   Third asset out of the lab this session, which is now a pattern worth its own
   note: an asset that exists only in the lab is an asset the product cannot
   reach for, so the first real consumer either duplicates it or does without. */
.sel-ctl{ display:inline-flex; align-items:center; gap:9px; height:34px; padding:0 var(--atlas-s12);
  border:var(--atlas-bw) solid var(--atlas-line-2); border-radius:var(--atlas-r-md);
  font-size:var(--atlas-fs-md); font-weight:var(--atlas-fw-normal);
  color:var(--atlas-ink); cursor:pointer }
@media (hover: hover){ .sel-ctl:hover{ background:var(--atlas-bg-2) } }
/* ⚠️ THE ANCHOR FOR ITS OWN MENU, DECLARED WITH THE ASSET. This lived in
   `crm/table.css` — a SURFACE stylesheet — so the select shell only became a
   positioning context on pages that happened to load the table's CSS. Anywhere
   else its `.pop` would resolve against some far ancestor and open across the
   screen from the control that owns it. A kit asset that needs a containing
   block declares it here or it is not really a kit asset. (2026-08-14) */
.sel-ctl{ position:relative }
/* ⚠️ `> svg` HERE TOO — see the rotation note below. This rule was the
   descendant form, so it repainted every icon INSIDE the open menu as well as
   the caret: the selected row's check mark came out `ink-3` grey instead of the
   accent `.pick-tick` gives it. The same trap had already been found and fixed
   for `transform` twelve lines down and left in place for `color`, which is how
   a documented trap bites twice. */
.sel-ctl > svg{ color:var(--atlas-ink-3); margin-left:var(--atlas-s2);
  transition:transform var(--atlas-dur-fast) }
/* ⚠️ OPEN IS NOT SELECTED. This wore the ACCENT — a colored ring plus an inset
   second ring — which is the loudest treatment in the system spent on the least
   interesting fact: that a menu you are looking at is open. Accent means "this
   is the answer" (K7); a menu being open is not an answer, it is a moment.
   The chevron already points at it, so the chevron carries it, and the shell
   just deepens by one step the way hover does. */
.sel-ctl.is-open{ background:var(--atlas-bg-2) }
/* ⚠️ `> svg`, NOT `svg`. THE RULE FOR EVERY TRIGGER THAT ROTATES A CARET: the
   menu is a DESCENDANT of the trigger, so a descendant selector also rotates
   every icon inside the menu — the check marks come out upside down. Written
   here because the next consumer will copy this block. */
.sel-ctl.is-open > svg{ transform:rotate(180deg) }

/* ══ THE COLOR SWATCH (A43) ═══════════════════════════════════════════════
   For color that is a NAME — a smart list, a channel, a calendar — drawn from
   the IDENTITY HUES, which are generated at K1's own fixed lightness and
   chroma with hue as the only variable. So this is K1 APPLIED, not excepted:
   nothing here can clash with the roles or shout louder than its neighbours.

   ROUND, because a round swatch is a color and a square one is a surface —
   and the thing being chosen is a color, not a fill for anything.

   SELECTION IS A RING, NOT A TICK. A check mark inside a color has to be
   light-or-dark depending on the color it sits on, which is a contrast problem
   invented for no reason; a ring sits OUTSIDE the swatch and works on every
   hue. Drawn with two shadows — a background-colored gap then the ink ring —
   so the ring never touches the color it marks.

   The FIRST swatch is "no color": identity is opt-in, and a neutral dot is a
   real answer, not an empty state. */
/* ══ THE RAIL ROW (`.a-nav`) ═══════════════════════════════════════════════
   ONE row for every sub-rail in Atlas: a CRM stage, a smart list, a task
   filter, a Huddle channel. They are the same idea one tool apart — a labelled,
   selectable subset — and it moved here the moment Huddle became the second
   consumer, which is the rule.

   ⚠️ It was `.crm2-i`, and the rename IS the promotion (L32: a kit class is a
   LOOK, not a location). A shared asset still wearing one surface's prefix
   invites the next surface to hand-roll its own rather than reach for something
   that looks like it belongs to the CRM — which is exactly what Huddle did,
   copying all eleven declarations value-for-value into `.huddle2-i`.

   Height is `--atlas-h-nav`, shared with the global rail item and the tool tab,
   so moving between the three navigation levels is not also a change of scale.
   It is an ANCHOR (N9): a filtered list is a place, and only a real link
   answers a right-click. */
.a-nav{
  display:flex; align-items:center; gap:var(--atlas-s10);
  height:var(--atlas-h-nav); padding:0 var(--atlas-s8);
  border-radius:var(--atlas-r-md); position:relative; text-decoration:none;
  color:var(--atlas-ink-2); font-size:var(--atlas-fs-md); cursor:pointer;
  transition:background var(--atlas-dur-instant),color var(--atlas-dur-instant);
}
/* ⭐ ON A PHONE THE RAIL ROW IS CONTENT, NOT CHROME (MB139, Brandon 2026-09-12:
   *"size up the huddle main page so it matches the details page we just
   made… the channel name rows should be the same black text with the same
   size"*).

   On a desktop this row is a RAIL — a persistent index beside the thing you are
   reading — so `fs-md` in `ink-2` is right: present, subordinate to the content.
   On a phone the same markup IS the page. A channel list is the screen, and its
   names are the answer you came for, so they take the content size and the full
   ink, exactly like the lead profile's Details rows do one tap away.

   ⚠️ IN THE KIT, NOT IN HUDDLE. `.a-nav` is the row the CRM's three rails and
   Huddle's channel list both read from — that promotion is recorded in Huddle's
   own file ("the promotion is a MOVE when it happens"). Sizing it inside Huddle
   would give one consumer a private answer and leave the CRM's phone rails a
   rung behind for no reason anybody could state later. Phone-scoped, so the
   desktop rail is untouched (MB115). */
.a-phone .a-nav,
.ash-shell.is-phone .a-nav{ font-size:var(--atlas-fs-base); color:var(--atlas-ink) }
@media (hover: hover){ .a-nav:hover{ background:var(--atlas-bg-2); color:var(--atlas-ink) } }
/* A list item is a SURFACE, not a control: step down and move on the axis this
   list does NOT run in (P41). */
.a-nav:active{ transform:var(--atlas-press-t-row, translateX(1px)) }

@media (pointer: fine){ .a-nav:active{background:var(--atlas-bg-3); } }
.a-nav.is-on{ background:var(--atlas-bg-2); color:var(--atlas-ink); font-weight:var(--atlas-fw-semi) }
/* The spine is a separate SQUARE bar, never a border on the row — as a border
   it inherits the radius and bows into a crescent. Same fix as the global rail. */
/* the 2px accent bar that sat beside the selected row went 2026-10-26 (A343): fill + weight are the two signals that stay */
.a-nav-l{ white-space:nowrap; overflow:hidden; text-overflow:ellipsis; min-width:0 }
/* The count slot is always present so the row cannot reflow when counts arrive,
   and it is EMPTY at zero — "0" is a claim nobody asked for (A22/B16). */
/* C4 — THE RAIL'S COUNTS ARE FIGURES. Seventeen of them on the CRM's phone
   rail alone, stacked in a column, every one a number that changes when you
   filter — proportional digits make the column ragged and make a changing
   count jitter. ⚠️ This is the one the name-heuristic sweep MISSED (it looked
   for -n/-count/-total and this is -ct); it was found by reading
   `font-variant-numeric` off the live device instead. */
.a-nav-ct{ margin-left:auto; flex:none; min-width:0; font-variant-numeric:tabular-nums }

/* ══ THE PHOTO PREVIEW (K.preview) ═════════════════════════════════════════
   ⚠️ THE GROUND IS DARK AND THAT IS NOT A THEME DECISION. Every other overlay
   in Atlas sits on `--atlas-bg-1` because it holds UI you read. This one holds
   a PHOTOGRAPH, and a photo on white is judged against the white — its own
   whites look grey and its edges bleed into the page. Dark is what every image
   viewer worth using does, for a reason that is about the image and not about
   the app's palette, which is why it is a fixed value here rather than a token
   that flips with the theme.

   It is NOT `--atlas-scrim` at higher opacity: the scrim is a dim over content
   you can still see, and this deliberately hides everything. */
/* ⚠️ THIS COMPONENT DECLARES ITS OWN INK RAMP, AND THAT IS THE EXCEPTION THAT
   PROVES K1 RATHER THAN BREAKING IT. Every `--atlas-ink-*` token is defined
   AGAINST THE THEME'S GROUND — they are dark on light and light on dark. This
   panel is deliberately dark in BOTH themes (see the background note below), so
   reaching for `--atlas-ink-2` here would be legible in dark mode and invisible
   in light. Six values, declared once at the top of the component, so the rest
   of the block reads as tokens like everything else and there is one place to
   change if the viewer's chrome ever moves. */
.a-pv-wrap{
  position:fixed; inset:0; z-index:var(--atlas-z-modal);
  --pv-ink:      #fff;
  --pv-ink-2:    rgba(255,255,255,.72);
  --pv-ink-3:    rgba(255,255,255,.62);
  --pv-line:     rgba(255,255,255,.18);
  --pv-line-2:   rgba(255,255,255,.32);
  --pv-ground:   rgba(255,255,255,.06);
  --pv-ground-2: rgba(255,255,255,.14);
}
/* ⚠️ THE DARK GROUND IS ON THE PANEL, NOT ON A SEPARATE SCRIM — and that is a
   correction, not a preference. The first cut used the kit's `.scrim` beneath a
   transparent panel, which is right for a DRAWER (you are meant to still see
   the thing you are acting on). Here the panel covers the viewport anyway, so
   the scrim was a second full-screen layer whose only job was a colour — and
   in the browser it would not paint that colour at all: `rgba(255,0,0,.88)`
   rendered, `rgba(11,13,16,.88)` did not, at the same alpha on the same
   element. Rather than keep bisecting a layer that should not exist, the ground
   moved onto the one element that was always going to cover everything.

   The scrim element stays ONLY as the click-to-dismiss target, transparent —
   which is also what makes "click anywhere outside the photo to close" true. */
.a-pv-scrim{ --scrim-z:var(--atlas-z-modal); background:transparent }
.a-pv{
  position:fixed; inset:0; z-index:calc(var(--atlas-z-modal) + 1);
  /* ⚠️ OPAQUE, NOT A TRANSLUCENT WASH. Two attempts at `rgba(11,13,16,.88–.92)`
     rendered as a barely-there tint while `rgba(255,0,0,.88)` on the same
     element at the same alpha rendered fully — so alpha compositing was not
     doing what the value said, and no amount of bisecting a layer that should
     not exist was going to make a photo viewer's ground trustworthy.

     Opaque is also the better answer on its own terms: a preview exists to let
     you look at ONE thing, and a translucent ground leaves the conversation
     showing through the photo's dark regions, which is exactly the judgement it
     is meant to remove. Every image viewer worth using is opaque. */
  background:#0b0d10;
  /* ⚠️ THE BAR IS A GRID ROW, NOT AN ABSOLUTE OVERLAY — and that is what fixes
     the bottom being clipped. The bar used to be `position:absolute` with the
     panel faking room for it via a big top padding, so the image's
     `max-height:100%` resolved against a box TALLER than the space actually
     left. The overflow all landed at the bottom, because the content is
     centred: half of it went up under the bar (invisible) and half went off the
     bottom edge (visible, and the thing Brandon saw).
     Two real rows — `auto` for the bar, `1fr` for the content — mean 100% is
     100% of what is left, which is the only version that cannot drift when the
     bar's height changes. `min-height:0` because a grid item's default
     `min-height:auto` refuses to shrink below its content. */
  display:grid;
  grid-template-columns:auto 1fr auto;
  grid-template-rows:auto minmax(0, 1fr);
  align-items:center;
  padding:0 var(--atlas-s16) var(--atlas-s24);
  opacity:0; transition:opacity var(--atlas-dur-base) var(--atlas-ease-out);
  pointer-events:none;
}
.a-pv.is-open{ opacity:1; pointer-events:auto }
/* The image is the only thing that gets the space: it fills what is left after
   the bar and the arrows, and `contain` because cropping somebody's screenshot
   is exactly the thing a preview exists to stop. */
.a-pv-img{
  grid-column:2; grid-row:2; justify-self:center; align-self:center;
  max-width:100%; max-height:100%; min-height:0; object-fit:contain;
  border-radius:var(--atlas-r-md); background:var(--pv-ground);
}

/* ⚠️ A PDF IS SHOWN IN THE BROWSER'S OWN VIEWER, INSIDE OUR CHROME. Rendering
   PDF pages ourselves means PDF.js — a second renderer, its own worker, its own
   page controls — to arrive at something every browser already ships and every
   person already knows how to scroll. What Atlas owns is the FRAME: the same
   dark ground, the same title, the same download and close, the same Escape.
   The `<iframe>` fills its row rather than sizing to content, because a
   document has no intrinsic height to size to.

   It points at the attachment WITHOUT `?dl=1` — the same URL, minus the
   Content-Disposition, so it renders instead of downloading. */
.a-pv-doc{
  grid-column:2; grid-row:2; justify-self:stretch; align-self:stretch;
  width:100%; height:100%; min-height:0; border:0;
  border-radius:var(--atlas-r-md); background:var(--pv-ground);
}
.a-pv-bar{
  grid-column:1 / -1; grid-row:1;
  display:flex; align-items:center;
  gap:var(--atlas-s10); padding:var(--atlas-s12) 0;
  color:var(--pv-ink);
}
.a-pv-t{
  font-size:var(--atlas-fs-md); font-weight:var(--atlas-fw-semi);
  white-space:nowrap; overflow:hidden; text-overflow:ellipsis; max-width:50vw;
}
.a-pv-n{ font-size:var(--atlas-fs-xs); color:var(--pv-ink-3);
  font-variant-numeric:tabular-nums }
.a-pv-sp{ flex:1 }

/* ══ THE PREVIEWER, ON A PHONE ═════════════════════════════════════════════
   It had ZERO phone rules — measured, not assumed — so it rendered its desktop
   geometry on a phone: a 16px side gutter, a 24px bottom, and a bar with no
   top padding at all. Brandon saw it in devtools and wondered whether the
   emulator was lying; it was not. Nothing keyed on the frame, so a real device
   gets the same thing.

   ⚠️ MB18 IS THE RULE BEING PAID HERE — the ground crosses the inset, the
   CONTROLS never do. The panel's own background already runs to the physical
   edge (`inset:0`), so the safe area is added as PADDING: the bar moves out
   from under the island rather than the panel being positioned below it, which
   would leave a strip of the wrong colour above a black viewer.

   ⚠️ AND THE DOCUMENT GOES FULL-BLEED. A 16px gutter around a contract on a
   390px screen is 8% of the page width spent on nothing — the reason a gutter
   exists on a desktop (the image floats in a large dark field) does not apply
   when the document IS the screen. */
.a-phone .a-pv{
  padding:0;
}
/* ⭐ THE PHOTO IS THE SCREEN (A201, Brandon 2026-09-03: *"have it open full
   screen with clicking the image to present the options that overlay on top"*).
   The bar leaves the grid and OVERLAYS the top of the image in a dim band — a
   scrim DIMS, never blurs — hidden at open, toggled by a tap anywhere on the
   viewer: iOS Photos' own model. The image takes the whole panel either way. */
.a-phone .a-pv-bar{
  position:absolute; top:0; left:0; right:0; z-index:1;
  padding:calc(var(--atlas-safe-t) + var(--atlas-s8)) var(--atlas-s12) var(--atlas-s10);
  background:rgba(11,13,16,.72);
  transition:opacity var(--atlas-dur-fast, .15s) ease;
}
.a-phone .a-pv-wrap:not(.is-chrome) .a-pv-bar{ opacity:0; pointer-events:none }
/* ⭐ A DOCUMENT KEEPS ITS BAR, IN ITS OWN ROW (2026-10-10, Brandon: "always
   visible bar"). The tap that summons the bar over a photo can never land on a
   PDF — the document is an iframe, and its taps stay inside it — so on a phone
   a document's bar is always there: back in the grid's first row (the panel's
   own `auto` row), on the opaque ground, with the document in the row below.
   Over the document it would cover the top of page one; above it, nothing is
   hidden and Close is always one tap away. The safe-area padding stays. */
.a-phone .a-pv-wrap.is-doc .a-pv-bar{
  position:relative; opacity:1; pointer-events:auto;
  background:#0b0d10;
}
.a-phone .a-pv-wrap.is-doc .a-pv-doc{ grid-row:2 }
/* "1 of 3" names a set you cannot move through here: the arrows are a desktop
   affordance (hidden below) and a swipe inside a PDF stays in the PDF. On a
   phone a document stands alone, so its count goes — measured, it was also
   wrapping to two lines and doubling the bar's height. */
.a-phone .a-pv-wrap.is-doc .a-pv-n{ display:none }
.a-pv-n{ white-space:nowrap }
.a-phone .a-pv-img{
  grid-column:1 / -1; grid-row:1 / -1;
  width:100%; height:100%; max-width:none; max-height:none;
  object-fit:contain;
}
/* The title gives before the controls do: at 390 a long filename would
   otherwise push Download and Close off the row. */
.a-phone .a-pv-t{ max-width:none; min-width:0; flex:1 1 auto }
.a-phone .a-pv-sp{ display:none }
/* Full-bleed, and square — a radius on a document that reaches every edge
   just clips its own corners. */
.a-phone .a-pv-doc,
.a-phone .a-pv-img{ border-radius:0 }
.a-phone .a-pv-doc{ grid-column:1 / -1 }
/* ⚠️ `-webkit-overflow-scrolling` ON THE FRAME'S OWN BOX. iOS refuses to scroll
   a PDF inside an `<iframe>` that is exactly the height of its container — the
   document renders and then sits there, which reads as "it did not open". The
   frame is given the scroll behaviour explicitly rather than relying on the
   embedded viewer's, which is the part iOS does not provide. */
.a-phone .a-pv-doc{ -webkit-overflow-scrolling:touch }
/* ⭐ THE KIT'S PDF PAGES (`kit/pdfview.js`, 2026-10-10) — the touch-device body
   of a PDF in the previewer, because iOS shows only page one of a PDF in an
   iframe. The host IS the scroller (one finger scrolls natively); the pinch is
   the viewer's own, so `touch-action` hands it over instead of zooming the app.
   ⚠️ THE STACK IS `max-content` WIDE, NOT CENTRED BY FLEX OVERFLOW. Centring a
   child wider than its flex container pushes its left edge into negative space
   that a scroller can never reach — a 250% page would lose its left margin.
   Max-content makes the stack as wide as the page, so it scrolls from 0. */
.a-pv-pdf{
  overflow:auto; -webkit-overflow-scrolling:touch; overscroll-behavior:contain;
  touch-action:pan-x pan-y; background:var(--pv-ground);
}
.a-pdfv-stack{
  display:flex; flex-direction:column; align-items:center; gap:var(--atlas-s12);
  width:max-content; min-width:100%; box-sizing:border-box;
  padding:var(--atlas-s12) 12px calc(var(--atlas-s24) + var(--atlas-safe-b, 0px));
}
.a-pdfv-page{
  position:relative; flex:none; width:var(--pdfv-pw, 100%);
  background:#FFFFFF; border-radius:2px; overflow:hidden;
}
.a-pdfv-page > canvas{ position:absolute; inset:0; width:100%; height:100%; display:block }
.a-pdfv-msg{
  padding:var(--atlas-s32) var(--atlas-s24); text-align:center;
  font-size:var(--atlas-fs-sm); color:var(--pv-ink-2, rgba(255,255,255,.72));
}
/* The arrows are a desktop affordance — on a phone they are two targets sitting
   over a document you are trying to read, and there is only ever one item in
   the offer flow's preview anyway.
   ⚠️ The class here was written from memory the first time and named an
   element this component does not render — a rule that is a silent no-op and
   reads as correct (C43). Grep the set before writing a selector; the name is
   `.a-pv-arrow` and it is the only one. */
.a-phone .a-pv-arrow{ display:none }
/* ⚠️ THE CONTROLS ARE THE TOOLBAR BUTTON WITH ITS INK RE-POINTED, not a new
   kind of button. On a dark ground the ink ramp would vanish, so the two
   colours it uses are overridden and everything else — the size, the press, the
   focus ring, the tooltip — is inherited. */
/* ⚠️ `.a-tb.a-pv-b` — TWO CLASSES, and it is the same specificity trap that
   caught Huddle's reaction pop: `.a-tb` sets `color:var(--atlas-ink)` and is
   declared LATER in this very file, so a single-class override loses on source
   order and the controls rendered dark ink on a dark ground. Win by
   arithmetic, never by position. */
.a-tb.a-pv-b{ color:var(--pv-ink-2); border-color:var(--pv-line) }
.a-tb.a-pv-b svg{ color:currentColor }
@media (hover: hover){ .a-tb.a-pv-b:hover{ color:var(--pv-ink); background:var(--pv-ground-2); border-color:var(--pv-line-2) } }
.a-pv-arrow{
  display:grid; place-items:center; flex:none;
  width:var(--atlas-h-btn); height:var(--atlas-h-btn);
  border:var(--atlas-bw) solid var(--pv-line); border-radius:var(--atlas-r-full);
  background:var(--pv-ground); color:var(--pv-ink-2); cursor:pointer;
  transition:background var(--atlas-dur-instant), color var(--atlas-dur-instant);
}
@media (hover: hover){ .a-pv-arrow:hover{ background:var(--pv-ground-2); color:var(--pv-ink) } }
.a-pv-arrow:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press))); transition:var(--atlas-press-in, none) }
.a-pv-arrow.is-prev{ grid-column:1; grid-row:2 }
.a-pv-arrow.is-next{ grid-column:3; grid-row:2 }
@media (prefers-reduced-motion: reduce){ .a-pv{ transition:none } }

.a-swatches{ display:flex; flex-wrap:wrap; gap:var(--atlas-s8) }
.a-swatch{
  width:22px; height:22px; padding:0; flex:none;
  border:0; border-radius:var(--atlas-r-full, 999px); cursor:pointer;
  box-shadow:0 0 0 var(--atlas-bw) var(--atlas-line-2);
  transition:box-shadow var(--atlas-dur-instant), transform var(--atlas-dur-instant);
}
@media (hover: hover){ .a-swatch:hover{ transform:scale(1.08) } }
.a-swatch.is-on{
  box-shadow:0 0 0 2px var(--atlas-bg-1), 0 0 0 3.5px var(--atlas-ink-2);
}
.a-swatch:focus-visible{ outline:none;
  box-shadow:0 0 0 2px var(--atlas-bg-1), 0 0 0 3.5px var(--atlas-accent) }
/* "No color" reads as the neutral it will actually render as, not as a
   crossed-out hole. */
.a-swatch-none{ background:var(--atlas-line-2) }

/* ══ FIELD WITH AN INLINE ACTION (A42) ═════════════════════════════════════
   A text field that contains its own button — a composite, not a field and a
   button that happen to be adjacent. The whole thing is one control: it takes
   the border, it owns the focus ring, and the button rides inside it.

   ⚠️ THE ACTION RIDES THE BOTTOM (`align-items:flex-end`). A growing textarea
   is the point of putting a button inside one, and centering it means the button
   DRIFTS DOWN THE MIDDLE as the box expands — by the third line it is floating
   beside the text with nothing to align to. Anchored to the bottom edge it
   stays where the hand expects it and stays beside the END of what you typed,
   which is the line you just finished writing. (Brandon, 2026-08-13.)

   C20 — the WRAPPER owns focus, so the inner field suppresses its own ring;
   two rings for one control reads as broken. K6 — a crisp hairline, no glow. */
.a-field{
  display:flex; align-items:flex-end; gap:var(--atlas-s8);
  padding:var(--atlas-s6) var(--atlas-s6) var(--atlas-s6) var(--atlas-s12);
  border:var(--atlas-bw) solid var(--atlas-line-2); border-radius:var(--atlas-r-md);
  background:transparent;
  transition:border-color var(--atlas-dur-instant);
}
.a-field:focus-within{ border-color:var(--atlas-accent);
  box-shadow:inset 0 0 0 1px var(--atlas-accent) }
.a-field-in{
  flex:1; min-width:0; resize:none; border:0; background:none; outline:none;
  font:inherit; font-size:var(--atlas-fs-md); line-height:1.45; color:var(--atlas-ink);
  padding:var(--atlas-s6) 0;
}
.a-field-in::placeholder{ color:var(--atlas-ink-3) }
/* The action never stretches with the field — it is a control, not a column. */
.a-field > .a-btn{ flex:none }

/* ══ THE AI ACTION BUTTON (A41) ════════════════════════════════════════════
   PROMOTED FROM THE LAB, unchanged — `.lab-btn-ai` was proven there and never
   extracted, so the first real AI surface had no AI button to reach for and
   used a plain secondary one. Same story as the segmented control.

   The gradient is a 1.75px BORDER (padding-box solid over border-box gradient)
   plus the glyph. NOT a filled face — a gradient slab is the loudest AI-slop
   tell there is and makes every other button on the page look broken beside it.

   ✅ L13 WAS AMENDED FOR THIS (2026-08-13, Brandon): the law bans a gradient
   FILL — a face, a background, a slab — and its old enumeration also said
   "never a border", which contradicted its own headline. The gradient border is
   part of the DEFINITION of the AI control, not an exception to a rule.
   ⚠️ THE AI ACTION CONTROL ONLY. Never a card, a panel, an input, or a button
   that merely sits near AI: the moment a gradient outlines a REGION it is a
   slab with a hole in it. */
.a-btn-ai{
  color:var(--atlas-ink);
  border:var(--atlas-bw-em) solid transparent;
  border-radius:var(--atlas-r-md);
  background:
    linear-gradient(var(--atlas-bg-1),var(--atlas-bg-1)) padding-box,
    linear-gradient(105deg,var(--atlas-ai-a),var(--atlas-ai-b)) border-box;
}
@media (hover: hover){ .a-btn-ai:hover{
  background:
    linear-gradient(var(--atlas-bg-2),var(--atlas-bg-2)) padding-box,
    linear-gradient(105deg,var(--atlas-ai-a),var(--atlas-ai-b)) border-box;
} }
.a-btn-ai:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press))); transition:var(--atlas-press-in, none) }

/* A32 — THE BUTTON IS THE STATUS. The label narrates (idle → working → done)
   and the box must not resize while it does, so the widest state is measured
   and pinned at wire time (see `aiBtn` in the kit's JS).
   While working the glyph PULSES, and hovering swaps it for an × — the label
   keeps narrating, the box never changes size, and cancelling costs no chrome.
   Neutral ×, not urgent: cancelling is not destructive, it is just stop. */
.ai-l{ display:inline-block; text-align:center }
.ai-ic, .ai-x{ display:inline-flex; flex:none }
.ai-x{ display:none; color:var(--atlas-ink-2) }
@keyframes aiPulse{ 0%,100%{ opacity:1 } 50%{ opacity:.45 } }
[data-state="working"] .ai-ic svg{ animation:aiPulse 1.1s ease-in-out infinite }
@media (hover: hover){ [data-state="working"]:hover .ai-ic{ display:none } }
@media (hover: hover){ [data-state="working"]:hover .ai-x{ display:inline-flex } }
@media (prefers-reduced-motion:reduce){
  [data-state="working"] .ai-ic svg{ animation:none }
}

/* ══ THE INLINE ADD (A39) ══════════════════════════════════════════════════
   The small `+` that sits at the end of a section header — "Smart lists +",
   "Members +". It is its own asset because it is NOT a small toolbar button:
   a toolbar button sits in a row of peers and carries a label or a tooltip
   alone; this one is bound to the heading beside it, which is what names it.
   That is why it takes no label and needs no tooltip to be understood — the
   eyebrow is the label, and `aria-label` carries it for anyone who cannot see
   that pairing.

   24px = the WCAG 2.5.8 pointer-target floor, held in `--atlas-h-add`. It was
   20px as a CRM-local rule (`.crm2-eyebrow .crm2-add`), which is under the
   floor AND welded to one surface by a descendant selector — so a second
   section wanting the same control had to either re-declare it or borrow the
   CRM's eyebrow. Standalone class, tokenised size.

   Quiet by default and ink on hover: an add control that is loud in every
   section header turns a rail into a row of buttons (P2/P36 — restraint is
   about AREA). Press is a translate, never a scale (P39). */
/* ── THE TOOLBAR BUTTON (P35 · A23) ────────────────────────────────────────
   ⚠️ PROMOTED FROM `crm/crm.css` ON ITS SECOND CONSUMER. P35 says the toolbar
   is ONE component — New lead, Filters, Columns and search share a shell — and
   Huddle's SEND is that same control in icon-only form, so keeping the class in
   the CRM would have made "one component" true within one surface and false
   across two.

   ⚠️ THE ACCENT IS ON THE GLYPH, VIA `--atlas-accent`, WHICH IS WHAT LETS A
   CONSUMER RE-POINT IT. Huddle's send takes the CHANNEL's colour by setting
   that variable on the button itself (C6's dynamic-colour slot) — the asset
   does not learn about channels, and the channel does not reach into the asset.
*/
/* ONE shell for every member. A23: the accent lives on the glyph ITSELF, never
   on an optional wrapper span — a family trait that depends on the markup
   remembering a class will drift by omission, and it did, for a whole day. */
/* ⚠️ HEIGHT IS `--atlas-h-field`, NOT A LITERAL 36px (2026-08-22). The value is
   identical on a desktop — that is the point, it was ALREADY this token's value,
   typed out. On a phone the token re-points to 44px and the whole toolbar family
   clears the tap floor for free; as a literal, every toolbar in the app would
   have sat 8px under it and looked fine to anyone testing on a laptop. */
.a-tb{
  /* ⚠️⚠️ `appearance:none`, AND THE KIT SET IT NOWHERE UNTIL MB157. A `<button>`
     left at `appearance:auto` is a NATIVE CONTROL, and WebKit draws native
     controls itself — so `background-color` on one is silently ignored. Proven
     the hard way: an inline `background-color:#9c5500 !important` on the Huddle
     send button computed `rgba(0,0,0,0)`, which looks impossible until you
     remember the cascade never got a say. Adding `appearance:none` made the same
     declaration paint.
     ⚠️ IT WAS INVISIBLE BECAUSE NOTHING HAD ASKED. Every `.a-tb` in the app is
     transparent at rest and fills only on HOVER — and a hover background lands
     on a button that WebKit has already stopped theming, so the one state that
     would have caught it is the one state where it works. The first filled
     toolbar button in the app is what found it. */
  appearance:none; -webkit-appearance:none;
  display:inline-flex; align-items:center; gap:var(--atlas-s8); flex:none;
  height:var(--atlas-h-field); padding:0 var(--atlas-s14);
  border:var(--atlas-bw) solid var(--atlas-line-2); border-radius:var(--atlas-r-md);
  background:transparent; color:var(--atlas-ink); cursor:pointer;
  font:inherit; font-size:var(--atlas-fs-md); font-weight:var(--atlas-fw-semi);
  white-space:nowrap; text-decoration:none;
  transition:background var(--atlas-dur-instant),border-color var(--atlas-dur-instant);
}
/* THE GLYPH IS INK, NOT ACCENT (A343, 2026-10-26). An accent glyph inside an
   outlined ink button, with a hover that turned the border accent, spent the
   accent on chrome — and #007b9c on a 16px stroke reads NAVY (Brandon, on the
   pipeline toolbar: "do these buttons look navy"). The accent now means
   selected, status or AI, nothing else; hover is the surface step alone. */
.a-tb svg{ color:var(--atlas-ink-2); flex:none }
@media (hover: hover){ .a-tb:hover{ background:var(--atlas-bg-2) } }
/* A toolbar button is a CONTROL, so it depresses (P41/P39): instant down, eased
   back, translate never scale — a scale shrinks the hit box on every side and
   the cursor flickers arrow→hand→arrow mid-press. */
.a-tb:active{ transform:var(--atlas-press-t, translateY(1px)); transition:var(--atlas-press-in, none) }
.a-tb.is-icon{ padding:0; width:var(--atlas-h-field); justify-content:center }
/* ⚠️ THE COMPACT RUNG — for a toolbar button that sits INSIDE another control
   rather than in a header row. Huddle's send lives in the composer field, and
   at the standard 36px it set the field's resting height (58px) for a box you
   type one line into (Brandon: *"it also needs to be smaller… so the composer
   can rest smaller"*). `--atlas-h-pill` (28px) is the existing rung between the
   inline add and a container control.

   ⚠️ IT IS `--atlas-h-infield` (32px), NOT the pill rung, and the difference is
   the point: 32 is the FIELD'S OWN CONTENT ROW at rest, so the button fills it
   exactly and reads centred while staying bottom-anchored — without the field
   growing. At 28 it sat 4px low. (Brandon, 2026-08-15.) */
.a-tb.is-sm{ height:var(--atlas-h-infield) }
.a-tb.is-sm.is-icon{ width:var(--atlas-h-infield) }
/* THE FIGURE ON A TOOLBAR BUTTON — the rail's `.a-nav-ct` treatment, on a
   control. Same size as the label so it reads as part of the same sentence,
   one step quieter so the label still leads, and TABULAR so the figure does not
   jitter as the count changes under a live filter. `margin-left:auto` is what
   lets it sit at the far edge when the button is given the width. */
.a-tb-n{
  margin-left:auto; flex:none;
  color:var(--atlas-ink-2);
  font-weight:var(--atlas-fw-normal);
  font-variant-numeric:tabular-nums;
}
/* ⚠️ AN ICON BUTTON CARRYING A COUNT IS NOT ICON-ONLY ANY MORE — it holds two
   things. The fixed 36px square was sized for one, so the count chip had
   nowhere to go and spilled out of the border (Brandon's screenshot: the "1"
   sitting half outside a clipped box). It reverts to an auto-width control with
   real padding the moment a count is present, and returns to the square when
   the filters are cleared — which is also why the count is ADDED and REMOVED
   rather than shown at zero (A22). */
.a-tb.is-icon:has(.ash-count){
  width:auto; padding:0 var(--atlas-s8) 0 var(--atlas-s10); gap:var(--atlas-s6);
}
/* ⚠️ THE SAME ESCAPE HATCH, DECLARED RATHER THAN SNIFFED — and it exists
   because `:has()` LOST a specificity fight. `:has(.x)` weighs what its
   argument weighs, so `.a-tb.is-icon:has(.huddle2-faces)` is 0-2-0 and
   `.a-tb.is-sm.is-icon{ width:32px }` is 0-3-0: the square won, and Huddle's
   member button — three overlapped faces plus a count in a 32px box — spilled
   out over the search button beside it (Brandon's screenshot). Widening the
   `:has()` list would have re-lost the same fight the next time; `.is-auto` is
   0-3-0 on its own and 0-4-0 against the compact rung, so it wins by
   arithmetic instead of by source order.

   The rule underneath: `.is-icon` is a promise that the button holds ONE glyph
   and can therefore be square. A button holding more than that is not icon-only
   any more and has to say so. */
.a-tb.is-icon.is-auto,
.a-tb.is-sm.is-icon.is-auto{
  width:auto; padding:0 var(--atlas-s8) 0 var(--atlas-s6); gap:var(--atlas-s6);
}

/* SEARCH is a toolbar member (A23) — same shell, same height, same radius, same
   accent glyph. Only its BEHAVIOUR differs, which is the one thing that should. */
/* Sized to its JOB, not to the space available. A search box does not need to be
   the widest thing on the bar — a lead name is ~20 characters, and a field wider
   than its content reads as an empty trough. */
/* ── THE TOOLBAR ROW (`.a-bar`) + ITS SPACER (`.a-sp`) ─────────────────────
   ⚠️ PROMOTED FROM `crm/crm.css` ON ITS THIRD CONSUMER (2026-08-17). It was
   `.crm2-bar`, worn by the CRM pipeline, then by Tasks, and now by Transactions
   — and the tell that it was overdue is four lines below where this comment used
   to sit: **the kit already carried `.crm2-bar .a-search`**, i.e. the kit knew
   about a SURFACE's class name, which is backwards. An asset the kit has to
   reach into is an asset the kit should own.

   It holds the toolbar family (A23/P35): search, and the buttons that OPEN
   rather than commit. The row supplies display, gap, padding and the hairline;
   a surface supplies only what goes in it.

   ⚠️ NO TOP BORDER — it sits flush under the shell's bar, which drops its own
   hairline for a surface with its own chrome. One line under the whole block,
   never two 44px apart.

   ⚠️ A CONSUMER MUST SCOPE ITS OWN QUERIES (L32). `.a-bar` is a LOOK, not a
   location: the CRM already learned this the hard way when Tasks wore
   `.crm2-bar` and a bare `querySelector` replaced the tasks toolbar with the
   pipeline's. Query `.<surface> > .a-bar`, never `.a-bar`. */
.a-bar{
  display:flex; align-items:center; gap:var(--atlas-s8);
  padding:var(--atlas-s10) var(--atlas-s16);
  border-bottom:var(--atlas-bw) solid var(--atlas-line);
  min-width:0;
}
.a-sp{ flex:1 1 auto }   /* the gap that pushes actions right */

/* THE SEARCH FIELD MOVED TO THE KIT as `.a-search` (A23) — it was the toolbar
   family's one member declared inside a surface, and Huddle needed the same
   field. Two consumers means one asset; the width still belongs to the caller,
   which is why the flex basis stayed here. Sized to its JOB, not to the space
   available: a lead name is ~20 characters, and a field wider than its content
   reads as an empty trough. */
.a-bar .a-search{ flex:0 1 240px }

/* ── SELECTION MODE ────────────────────────────────────────────────────────
   ⚠️ THE SAME SLOT, NOT A LAYER. The bulk bar REPLACES the toolbar where it
   stands. A floating bar covers rows, which means it hides the very things you
   just selected and you cannot check what you are about to act on — the one
   review a destructive action depends on.

   The only visual difference is the rule beneath it turning accent, so the
   surface states the mode without anything moving. Nothing shifts, nothing
   reflows, and the rows keep their position under the pointer. */
.a-bar.is-sel{ border-bottom-color:var(--atlas-accent) }
.a-sel-n{
  /* C4 — a FIGURE gets fixed-width digits so it cannot jitter when it
     changes (the bulk bar's "N selected"). Scoped to the figure, never the row: tabular
     digits in prose make the words gappy. */
  font-variant-numeric:tabular-nums; font-weight:var(--atlas-fw-semi); color:var(--atlas-ink); white-space:nowrap }
/* What is selected but NOT on screen. Quiet, because it is context rather than
   a warning — but present, because a count that ignores it is a half-truth. */
/* ⚠️ THE NOTE IS THE ONE PIECE THAT YIELDS (Brandon 2026-09-22 — "Send to
   Brandon runs off the screen when it gets too long"). Everything else in this
   row is `flex:none` on purpose: the count is a FIGURE and an action must stay
   whole and readable. So in a narrow bar — Market with the lead outline open,
   where the panel loses ~360px — there was nothing left to give and the action
   was pushed off the edge. The note is CONTEXT ("6 selected are off screen"),
   which is the only member that still says something useful truncated, so it
   shrinks and ellipses rather than shoving the button out. `min-width:0` is
   what makes a nowrap flex child shrinkable at all. */
.a-sel-note{
  color:var(--atlas-ink-3); font-size:var(--atlas-fs-sm);
  white-space:nowrap; flex:0 1 auto; min-width:0;
  overflow:hidden; text-overflow:ellipsis;
}
/* ⭐ THE TEXT LINK. A LINK, not a button: it is an OFFER, and giving it a
   button's weight would make it compete with the actions beside it. Accent +
   underline, no chrome — the one shape in the kit that says "there is more
   behind this word" without borrowing a control's box.

   ⚠️ IT WAS `.a-sel-all` AND ONLY THAT. The selection bar's second click was
   the first consumer, so the rule wore its name; Market's buyer-fit count is
   the second, and a `.a-sel-all` on a listing overlay would be a class that
   lies about what it is. A231 one level down: a rule with more than one
   consumer belongs to the shared owner. ONE declaration, two selectors — a
   copy under a new name would be a second link style with nothing holding the
   two honest. */
.a-tlink, .a-sel-all{
  font:inherit; font-size:var(--atlas-fs-sm); font-weight:var(--atlas-fw-semi);
  color:var(--atlas-accent); background:transparent; border:0; padding:0;
  cursor:pointer; text-decoration:underline; text-underline-offset:2px; white-space:nowrap;
}
@media (hover: hover){ .a-tlink:hover, .a-sel-all:hover{ text-decoration-thickness:2px } }
.a-tlink:active, .a-sel-all:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press))); transition:var(--atlas-press-in, none) }
/* DESTRUCTIVE IS A HOVER STATE, NOT A RESTING COLOUR. A permanently red button
   in a toolbar is a warning you stop seeing; it earns its colour at the moment
   the pointer is on it and a click is one press away. */
@media (hover: hover){ .a-tb.is-danger:hover{ color:var(--atlas-urgent); border-color:var(--atlas-urgent) } }
@media (hover: hover){ .a-tb.is-danger:hover svg{ color:var(--atlas-urgent) } }


/* ── THE COMPOSER SHELL ────────────────────────────────────────────────────
   ⚠️ PROMOTED FROM `crm/lead.css` ON ITS SECOND CONSUMER, which is the rule.
   Huddle's message box is not the CRM's composer — that one writes an ACTIVITY
   on a LEAD, with modes and a coloured commit (A67) — but the SHELL is the same
   object in both places: the box, the hairline, the header row, the growing
   body, the footer whose commit sits right. Brandon, on the first version of
   Huddle's: *"that composer is horribly done and doesn't resemble the original
   one at all."* It did not, because it was a fresh box rather than this one.

   WHAT STAYED IN THE CRM: everything about MODES — the pills, their four hues,
   the commit button taking the mode's colour, the scheduling row. Those are
   that surface's meaning, not this shell's.
*/

.cmp{
  border:var(--atlas-bw) solid var(--atlas-line-2); border-radius:var(--atlas-r-lg);
  background:var(--atlas-bg-1);
}
.cmp.is-collapsed{
  display:flex; align-items:center; gap:var(--atlas-s12);
  padding:0 var(--atlas-s16); height:46px; cursor:text;
}
.cmp-ph{ flex:1; min-width:0; font-size:var(--atlas-fs-md); color:var(--atlas-ink-3);
  white-space:nowrap; overflow:hidden; text-overflow:ellipsis }
.cmp-hd{
  display:flex; align-items:center; gap:var(--atlas-s8);
  padding:10px var(--atlas-s16);
  border-bottom:var(--atlas-bw) solid var(--atlas-line);
}
/* `.cmp-body` is GONE — the composer's field is the kit's `.a-ment` now, and a
   stale rule for a class nothing emits is exactly the ghost C43 is about. Its
   numbers moved into `.a-ment` (86px min, 40vh max, s16 padding). */
.cmp-ft{
  display:flex; align-items:center; gap:var(--atlas-s8);
  padding:var(--atlas-s8) var(--atlas-s16);
  border-top:var(--atlas-bw) solid var(--atlas-line);
}
.cmp-ft .a-btn{ height:var(--atlas-h-btn-sm); font-size:var(--atlas-fs-sm) }
.cmp-ft-btns{ display:flex; align-items:center; gap:var(--atlas-s8); margin-left:auto }
/* ══ THE OPEN COMPOSER NEVER OUTGROWS THE SCREEN (A197) ═════════════════════
   Email mode stacks To/Cc/Bcc/Subject + tools + attachments over the body, and
   on a short window that sum can push the commit footer below the fold — the
   one control the whole flow exists to reach. So the open composer takes the
   `.pop` discipline: clamp to the viewport and scroll INSIDE. Flex column;
   the chrome rows keep their size, the FIELD is what gives (to its 86px
   floor) and the findings list already caps itself — both scroll internally.
   ⚠️ NOT the phone stack: there the keyboard primitive owns the geometry
   (data-kb-grow / data-kb-floor), and a second owner is the two-restorers
   trap. 140px ≈ the header + the profile's tab row + breathing room.
   `dvh`, because an iPad is a desktop-width viewport whose toolbar retracts
   (the 100vh lesson); the vh line above it is the fallback. */
.cmp:not(.is-collapsed):not(.is-stack){
  display:flex; flex-direction:column;
  max-height:calc(100vh - 140px);
  max-height:calc(100dvh - 140px);
}
.cmp:not(.is-collapsed):not(.is-stack) > :is(.cmp-hd, .cmp-tools, [data-cmp-em], .cmp-attl, .cmp-ft){ flex:none }
.cmp:not(.is-collapsed):not(.is-stack) > .a-ment{
  flex:1 1 auto; min-height:0; display:flex; flex-direction:column;
}
.cmp:not(.is-collapsed):not(.is-stack) > .a-ment > .a-ment-in{
  flex:1 1 auto; min-height:86px;
}

/* ── THE SEARCH FIELD (A23) ────────────────────────────────────────────────
   A toolbar-family member: the same 36px shell, the same `line-2` hairline, the
   same radius, the same 38px glyph inset and the same ACCENT glyph as every
   button beside it. Only its behaviour differs, which is the one thing that
   should.

   ⚠️ PROMOTED TO THE KIT ON ITS SECOND CONSUMER, which is the rule and was
   overdue. It existed twice — `.tb-search` in the lab and `.crm2-search` in the
   CRM — so Huddle asking for "the same search bar the rest of the app uses"
   would have made a third copy of one asset. `.crm2-search` is gone and the CRM
   wears this; the lab keeps its own, because the lab's job is to DOCUMENT the
   asset rather than to consume it.

   ⚠️ THE KIT OWNS THE LOOK, THE CONSUMER OWNS THE WIDTH. A toolbar wants
   `flex:0 1 240px`; a rail wants the full column. Baking either in would make
   the asset unusable in the other place, which is how a shared component
   acquires a `--variant` for something that was never about the component.

   The GLYPH IS PAINTED ON THE ELEMENT, never through a wrapper class (C35) —
   a family trait the markup has to remember is a coin flip per call site. */
.a-search{ position:relative; min-width:150px }
.a-search svg{
  position:absolute; left:var(--atlas-s12); top:50%; transform:translateY(-50%);
  color:var(--atlas-accent); pointer-events:none;
}
.a-search input{
  width:100%; height:var(--atlas-h-field); box-sizing:border-box;
  padding:0 var(--atlas-s12) 0 38px;
  border:var(--atlas-bw) solid var(--atlas-line-2); border-radius:var(--atlas-r-md);
  background:transparent; color:var(--atlas-ink);
  font:inherit; font-size:var(--atlas-fs-md);
  transition:border-color var(--atlas-dur-instant);
}
.a-search input::placeholder{ color:var(--atlas-ink-3) }
/* C20 — the input IS the control here, so it draws the focus treatment and
   nothing else does. Crisp, zero blur: a ring is geometry, not light (K6/K7). */
.a-search input:focus-visible{
  outline:none; border-color:var(--atlas-accent);
  box-shadow:inset 0 0 0 1px var(--atlas-accent);
}

.a-add{
  margin-left:auto; flex:none;
  display:grid; place-items:center;
  width:var(--atlas-h-add); height:var(--atlas-h-add);
  border:0; background:none; cursor:pointer;
  color:var(--atlas-ink-3); border-radius:var(--atlas-r-xs);
  transition:color var(--atlas-dur-instant), background var(--atlas-dur-instant);
}
@media (hover: hover){ .a-add:hover{ color:var(--atlas-ink); background:var(--atlas-bg-2) } }
.a-add:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press))) }

/* ══ TOOLTIP (P37) ══════════════════════════════════════════════════════════
   400ms, because a mouse crossing a toolbar must not fire a row of them. Shows
   on :focus-visible too, and aria-label is ALWAYS required — a tooltip is not
   an accessible name.

   ⚠️ IT IS A PLACED, BODY-MOUNTED ELEMENT — NOT `::after` ON THE TARGET.
   It was a pseudo-element, which is smaller code and cannot work: a pseudo is a
   CHILD, so it is clipped by every ancestor that scrolls. The first real
   truncation tooltip proved it twice in one pass — the CRM rail scrolls
   vertically, so a name tooltip came out cut off at BOTH ends and pushed a
   horizontal scrollbar into the rail; the table body scrolls too, so a cell
   tooltip near the bottom edge would be sliced in half.

   That is C37 for the third time (overflow clips descendants, including the
   ones you put outside on purpose) and it is why EVERY other floating thing in
   Atlas — picker, menu, date popover — is already mounted out and placed by
   A37. A tooltip is a floating thing. One mechanism, no exceptions: the
   `data-tip` API is unchanged, so no call site moves. */
/* ⚠️ THESE ARE THE GLOBAL RAIL'S TOOLTIP VALUES, because there is only one
   tooltip. NO OUTLINE — the lift alone separates it, the same way the v5 card
   does; a hairline plus a shadow plus a fill is three separators for one edge,
   and at this size the border was the loudest thing about it. TEXT ONLY:
   `fs-xs` at normal weight, one status-height line, nowrap. */
.tip-pop{
  position:fixed; z-index:var(--atlas-z-tooltip);
  max-width:calc(100vw - 16px);
  height:var(--atlas-h-status); padding:0 var(--atlas-s8);
  display:grid; place-items:center;
  background:var(--atlas-bg-1); color:var(--atlas-ink);
  box-shadow:var(--atlas-lift); border-radius:var(--atlas-r-sm);
  font-size:var(--atlas-fs-xs); font-weight:var(--atlas-fw-normal);
  white-space:nowrap; overflow:hidden; text-overflow:ellipsis;
  pointer-events:none; opacity:0; transform:translateY(-2px);
  transition:opacity var(--atlas-dur-instant), transform var(--atlas-dur-instant);
}
.tip-pop.is-open{ opacity:1; transform:none }
@media (prefers-reduced-motion:reduce){ .tip-pop{ transition:opacity 1ms } }

/* ══ THE PICKER (C3/C4) ═════════════════════════════════════════════════════
   ONE base, typed variants. `--user` is the universal people picker: photo +
   title, no icons. A LEAD gets no leading slot at all, because a lead has no
   photo and inventing initials fabricates an identity.
   Class vocabulary is V3's, verbatim — Atlas and V3 never share a DOM, so one
   mental model costs nothing. KIT-BOUND. */
.pick{ position:relative }
/* The non-person mark in a people picker (L2): the avatar slot, no circle
   ground, a quiet stroke glyph — a pond is a place, not a face. */
.pick-av.is-mark{
  display:flex; align-items:center; justify-content:center;
  background:none; color:var(--atlas-ink-3);
}
.pick-field{
  display:flex; align-items:center; gap:var(--atlas-s6); width:100%;
  min-height:36px; padding:var(--atlas-s6) var(--atlas-s10); box-sizing:border-box;
  border:var(--atlas-bw) solid var(--atlas-line-2); border-radius:var(--atlas-r-md);
  background:transparent; color:var(--atlas-ink); cursor:pointer;
  font:inherit; font-size:var(--atlas-fs-md); text-align:left; flex-wrap:wrap;
  transition:border-color var(--atlas-dur-instant);
}
@media (hover: hover){ .pick-field:hover{ border-color:var(--atlas-accent) } }
/* A CONTROL DEPRESSES (P39/P41) — this class had a hover and NO press at
   all, found on the campaigns drawer's Type picker (Brandon, 2026-09-01),
   which means every picker trigger in the app had been press-less since the
   class was born. The `.a-tb` family's press exactly: instant translate on
   the way down, never a scale, no colour (the bordered-transparent controls
   carry motion alone). */
.pick-field:active{ transform:var(--atlas-press-t, translateY(1px)); transition:var(--atlas-press-in, none) }
.pick-ph{ color:var(--atlas-ink-3) }
.pick-caret{ margin-left:auto; color:var(--atlas-ink-3); display:flex; flex:none }

/* ── A TRIGGER SHOWING ONE VALUE ───────────────────────────────────────────
   ⚠️ `flex-wrap:wrap` above is for the MULTI-SELECT field, which holds chips
   and genuinely has to wrap them. A trigger showing a single value must not:
   "Attempting Contact" pushed the chevron onto a second line and grew the
   control taller than its neighbour, so two pickers side by side stopped
   agreeing about how tall a picker is (Brandon, 2026-08-14).

   Truncate, never wrap and never grow — with the value carrying `data-tip-clip`
   so the full text is one hover away and ONLY when it is actually cut off
   (A45 measures; a tooltip repeating text you can already read is noise).

   Scoped by `:has()` so the chip field is untouched — the same mechanism
   `OPEN_MENU` already uses. */
.pick-field:has(.pick-val){ flex-wrap:nowrap }
.pick-val{
  flex:1 1 auto; min-width:0;
  white-space:nowrap; overflow:hidden; text-overflow:ellipsis;
}
.pick-val.is-empty{ color:var(--atlas-ink-3) }
.pick-field:has(.pick-val) > svg{ flex:none }

/* ══ THE POPOVER (A37 / L19) ════════════════════════════════════════════════
   ONE floating-panel primitive. Every popover in Atlas — picker menu, date
   picker, and whatever comes next — is this class plus its own contents. The
   rule it exists to enforce is absolute: A POPOVER NEVER LEAVES THE VISIBLE
   BAND. Not the viewport naively — the band, which is the viewport intersected
   with every clipping ancestor, so inside a drawer the band is the drawer's
   scrolling BODY and the panel stops at the header and the footer.

   The chrome lives here rather than on each panel so that "make popovers
   quieter" is one edit, not a hunt. Three structural pieces do the work:

   • FLEX COLUMN + `overflow:hidden`. The primitive writes `max-height`; flex
     decides which CHILD gives. That is what lets a panel have a part that must
     never be clipped (the picker's search) and a part that may scroll (its
     rows) — see A38.
   • ANCHORED ON THE EDGE IT GROWS AWAY FROM. Down → `top`; up → `bottom`.
     Clamping the height can then only ever pull the FAR edge in, never push
     the near edge out of the band. Anchoring both would make the clamp fight
     the flip.
   • `--pop-dx` FOR HORIZONTAL. A fixed-width panel near the right edge is
     SLID back in, never flipped to the other side: sliding keeps it under the
     control that opened it, flipping breaks the relationship that makes it
     legible. Written as a transform so it works whether the panel is stretched
     (`left:0;right:0`) or fixed-width, without the primitive having to know. */
/* ⚠️⚠️ THE LAW THAT NO STYLESHEET CAN ENFORCE: A PANEL'S Z-INDEX ONLY RANKS
   INSIDE THE NEAREST ANCESTOR STACKING CONTEXT. `--atlas-z-popover` is 500 and
   it has painted UNDER a timeline four times in four days — never because 500
   was too small, always because an ancestor between the panel and the surface
   was a context sitting below the content: a press transform (MB45), a held
   keyframe (MB86), a sticky composer with a z-index (MB93). The trapping
   property lives on an element this file never names, so it is measured, not
   linted: `AtlasKit.auditPopContexts()` walks every popover host to its
   surface root and reports each context-creating ancestor with the property
   that creates it. Run it on every new phone surface. The structural rule it
   enforces: a popover host may sit inside a context only if that context is
   ABOVE everything the panel must clear (the lead head's z1 over its pane is
   the sanctioned shape); a context that merely holds the host — a sticky, a
   transform, an `isolation` — must go, not be out-numbered. */
.pop{
  position:absolute; z-index:var(--atlas-z-popover);
  display:none; flex-direction:column;
  /* ⚠️ AUTO, NOT HIDDEN — ON BOTH AXES. `overflow:hidden` was here to clip
     children to the rounded corners, which `auto` does just as well, and it had
     a consequence nobody had hit yet: `placePop` CLAMPS this panel's
     max-height to the room available, so a menu with more rows than fit had the
     rest simply UNREACHABLE — no scroll, no indication, the options just were
     not there. (A picker escapes it only because `.pop-scroll` inside does the
     scrolling; a menu built without one does not.) Horizontally the same: a
     long option was clipped with no way to read it.

     The scrollbars are invisible until used (L26), so this costs nothing at
     rest. An inner `.pop-scroll` still takes the vertical first, being
     `flex:1; min-height:0`. */
  overflow:auto;
  background:var(--atlas-bg-1);
  border:var(--atlas-bw) solid var(--atlas-line); border-radius:var(--atlas-r-lg);
  box-shadow:var(--atlas-lift);
  top:calc(100% + var(--atlas-pop-gap));
  transform:translateX(var(--pop-dx, 0));
  overscroll-behavior:contain;
}
.is-open > .pop{ display:flex }
/* C4 — FLIP UP WHEN THERE IS MORE ROOM ABOVE. Baked into the base because it
   is a recurring Atlas bug source: a menu anchored below a field near the
   bottom of a scrolling drawer is clipped by the drawer, and z-index cannot
   save it. Measured at OPEN, so it answers the space that exists now. */
.is-up > .pop{ top:auto; bottom:calc(100% + var(--atlas-pop-gap)) }

/* Anything that scrolls INSIDE a popover shares one scrollbar treatment —
   otherwise each panel invents its own and they drift. */
.pop-scroll{
  overflow-y:auto; min-height:0; flex:1;
  /* Touch: momentum + no scroll-chaining to the page behind — a picker list
     on a phone sheet must scroll like a native list (Brandon, 2026-08-30:
     "the crm picker should be scrollable"). */
  -webkit-overflow-scrolling:touch;
  overscroll-behavior:contain;
}

.pick-menu{ left:0; right:0 }
/* ══ PLACES (`data-places`, K — 2026-10-08) — the address suggestions panel
   hangs from the field's own wrapper, as wide as the field at least: an
   address is read whole, and a panel narrower than what you typed reads as
   clipped. No glyph on the rows, like the composer's recipient list. */
.a-places-host{ position:relative }
.a-places-pop{ left:0; min-width:100%; max-width:min(480px, 92vw) }
/* the kit lead picker (K.leadPick): a real width on desktop; the phone sheet
   conversion overrides it like every other picker. Accent trigger when set. */
.a-leadpick-pop{ width:260px }
.a-leadpick .a-capture-ic.is-on{ color:var(--atlas-accent) }
/* A38 — THE SEARCH IS THE HEAD OF THE PICKER, AND THE HEAD IS NEVER CLIPPED.
   It sits OUTSIDE the scrolling region (`flex:none`), so a clamped picker
   shrinks its LIST and keeps its search. A sticky header would have been the
   easy version and it is not equivalent: sticky still lives inside the box the
   clamp is shrinking, so a short enough band clips it anyway. */
.pick-search{
  display:flex; align-items:center; gap:9px; flex:none;
  padding:7px var(--atlas-s10) 9px;
  border-bottom:var(--atlas-bw) solid var(--atlas-line);
}
.pick-list{ padding:var(--atlas-s6) }
/* The wrapper owns focus, so the inner input suppresses its own ring (C20) —
   three rings stacking reads as broken. Inside a menu the panel is already the
   focus context, so the treatment is the hairline going accent. */
.pick-search:focus-within{ border-bottom-color:var(--atlas-accent) }
/* ⭐ ON A SHEET THE SEARCH IS A REAL FIELD (MB118a, Phase-2 2-A, 2026-09-12).
   The desktop's anchored menu keeps the quiet hairline row above — a popover
   is small and the affordance is obvious. A phone SHEET is a different claim:
   MB94's keyboard-on-demand only works if there is something that visibly
   ASKS to be tapped, and a borderless input over a hairline reads as a
   header, not a field (the audit's "invisible search affordance", complaint
   #5). Sheet presentation only — `:not(.a-pop-anchored)` — so the anchored
   short menus the builder now emits stay untouched. The input's 16px anti-
   zoom pin already rides `.a-phone .pop input`. */
.a-phone .pop:not(.a-pop-anchored) .pick-search{
  margin:var(--atlas-s6) var(--atlas-s10) var(--atlas-s8);
  padding:var(--atlas-s8) var(--atlas-s10);
  border:var(--atlas-bw) solid var(--atlas-line);
  border-radius:var(--atlas-r-md);
  background:var(--atlas-bg-1);
}
.a-phone .pop:not(.a-pop-anchored) .pick-search:focus-within{
  border-color:var(--atlas-accent);
}
.pick-search-in{
  flex:1; min-width:0; border:0; background:none; font:inherit;
  font-size:var(--atlas-fs-md); color:var(--atlas-ink);
}
.pick-search-in:focus, .pick-search-in:focus-visible{ outline:none; box-shadow:none }
.pick-search-in::placeholder{ color:var(--atlas-ink-3) }
/* ⚠️ THE RESET IS PART OF THE ASSET. Every picker in the kit renders this as a
   <div>, so the missing UA reset never showed — until the table's per-page menu
   rendered it as a <button> and got the browser's grey pill, centre-aligned
   text and its own font. An asset that only looks right on one element type is
   an asset with a trap in it: it must be defined for the ELEMENT THE JOB WANTS,
   and a menu row that is genuinely actioned should be able to be a button. */
.pick-row{
  display:flex; align-items:center; gap:11px; padding:9px var(--atlas-s10);
  border-radius:var(--atlas-r-sm); cursor:pointer;
  width:100%; text-align:left; border:0; background:none;
  font:inherit; font-weight:var(--atlas-fw-normal); color:var(--atlas-ink);
  transition:background var(--atlas-dur-instant);
}
/* ⚠️ THE ANCHOR VARIANT. `.pick-row` was authored as a `<button>`, so it never
   had to say this — and the moment a consumer needed the row to be a real place
   with a slug (N9: the CRM's scope sheet, where every row IS a URL), every row
   in the sheet came out underlined in link blue. A kit asset that only works on
   one tag is not finished; the reset belongs here, not in the surface. */
a.pick-row{ text-decoration:none; color:var(--atlas-ink) }
.pick-row.is-active{ background:var(--atlas-bg-2) }
@media (hover: hover){ .pick-row:hover{ background:var(--atlas-bg-2) } }
.pick-row:active{ transform:var(--atlas-press-t-row, translateX(1px)) }

@media (pointer: fine){ .pick-row:active{background:var(--atlas-bg-3); } }
/* A20 — SELECTED IS A CHECK ON THE RIGHT, never a background highlight: the
   highlight is the KEYBOARD CURSOR, and using one treatment for both makes the
   active row impossible to find. */
/* THE FIGURE ON A PICKER ROW — `.a-tb-n`'s sibling, and the same distinction:
   a plain COUNT of what is in the thing named beside it, never a badge. It
   takes the `margin-left:auto` so the tick can sit outside it, which keeps the
   check hard against the edge whether or not a row has a number. */
.pick-n{
  margin-left:auto; flex:none;
  color:var(--atlas-ink-3);
  font-variant-numeric:tabular-nums;
}
.pick-row:has(.pick-n) .pick-tick{ margin-left:var(--atlas-s10) }
.pick-tick{ margin-left:auto; color:var(--atlas-accent); display:none; flex:none }
.pick-row.is-on .pick-tick{ display:flex }
/* MB118 (2-B) — the status dot a stage-style picker carries per row and
   mirrors beside its field value. Neutral grey until a row's own colour
   overrides inline; geometry only, never a tint on the row itself. */
.pick-dot{
  width:8px; height:8px; border-radius:50%; flex:none;
  background:var(--atlas-ink-3);
}

.pick-av{
  width:34px; height:34px; border-radius:var(--atlas-r-sm); flex:none;
  display:grid; place-items:center;
  background:var(--atlas-bg-3); color:var(--atlas-ink-2);
  font-size:var(--atlas-fs-2xs); font-weight:var(--atlas-fw-bold);
}
/* ⚠️ A GLYPH IN THIS SLOT GETS NO PLATE — L3, and Brandon's call on the
   notification card the same day: *"no tint - just the icon and make it accent
   color. That is what fits our family."* The plate is right behind a PHOTO
   (it is the placeholder the image covers) and wrong behind a MARK: a face is a
   real object and needs its edges, a glyph is punctuation and does not. Scoped
   with `:has(svg)` so the image and initials cases are untouched — the slot
   keeps its 34px either way, so a row never shifts depending on what is in it.
   ⚠️ THIS IS A KIT-WIDE RULE, not a palette one. Every picker that falls back
   to a glyph gets it, which is the point: the notification card and the picker
   were treating the same thing two different ways. */
.pick-av:has(svg){ background:none; color:var(--atlas-accent) }
.pick-main{ flex:1; min-width:0 }
/* ⚠️ WEIGHT IS HIERARCHY, AND HIERARCHY NEEDS SOMETHING TO OUTRANK (Y1).
   This was semibold unconditionally, which is right for a PERSON row — the name
   has an email under it and has to win. It is wrong for a plain option, where
   there is nothing beneath it: "25 / page" in semibold is just bold text in a
   menu, and three of them stacked read as three buttons rather than a list.
   So the label is NORMAL, and earns its weight only when it is the top line of
   a two-line row. */
.pick-label{ display:block; font-size:var(--atlas-fs-md); font-weight:var(--atlas-fw-normal);
  white-space:nowrap; overflow:hidden; text-overflow:ellipsis }
.pick-row:has(.pick-sub) .pick-label,
.pick-row:has(.pick-av)  .pick-label{ font-weight:var(--atlas-fw-semi) }
.pick-sub{ display:block; font-size:var(--atlas-fs-xs); color:var(--atlas-ink-3); margin-top:1px }
.pick-empty{ padding:var(--atlas-s20) var(--atlas-s12); text-align:center;
  font-size:var(--atlas-fs-md); color:var(--atlas-ink-3) }

/* ══ THE EMPTY STATE (A34) ═════════════════════════════════════════════════
   "Empty" is FIVE situations and the difference that matters is *nothing
   exists* vs *nothing matches*. The test is mechanical: WOULD CLEARING THE
   FILTER FIX IT? Yes → the state is about the FILTER, name what is excluded
   and offer to clear it. No → it is about the DATA, and the action is to make
   some. Showing "Add your first lead" to somebody with 4,182 leads and a bad
   filter tells them the app lost their data and offers the one action that
   cannot help.

   ⭐ PROMOTED 2026-08-21, and the duplication was literal: `.crm2-empty`,
   `.sgn2-empty` and `.txn2-empty` were the SAME SEVEN DECLARATIONS in three
   stylesheets, and `sign/sign.js` and `transactions/transactions.js` held the
   same `viewsEmptyHtml()` — same string, same glyph, same comment. Not similar.
   Copied.

   TWO SIZES, ONE COMPONENT. A rail card that has never been used and a table
   with no rows are the same idea at different scales, and the scale is the only
   thing that differs:
     · default  — PANEL: left-aligned, glyph above text, sits inside a card or
                  a rail where it is one element among several.
     · .is-page — the REGION is empty: centred, a title that leads, and room for
                  one action. `--atlas-s32` of air, because a table body that
                  goes quiet needs to read as deliberate rather than as failed.

   ⚠️ AT MOST ONE ACTION (A34). Two is a menu; zero is correct whenever there is
   nothing to do — the "done" state (an empty task list at 5pm) is an
   achievement and gets no button at all.
   ⚠️ A STROKE GLYPH, NEVER AN ILLUSTRATION OR A MASCOT (L2), and it recedes to
   `--atlas-line-2`: it is punctuation for the sentence, not the subject.
   ⚠️ AND THE CHROME STAYS. A11 — an empty table keeps its header; a page
   stripped back to a lone message reads as broken rather than as empty. */
.a-empty{
  display:flex; flex-direction:column; align-items:flex-start; gap:var(--atlas-s8);
  padding:var(--atlas-s16) var(--atlas-s12);
  color:var(--atlas-ink-3);
}
.a-empty > svg{ flex:none; color:var(--atlas-line-2) }
.a-empty-t{
  margin:0; font-size:var(--atlas-fs-md); font-weight:var(--atlas-fw-semi);
  color:var(--atlas-ink-2);
}
.a-empty-b{ margin:0; font-size:var(--atlas-fs-xs); line-height:1.45 }
/* The action sits apart from the sentence — it is the answer, not part of it. */
.a-empty-a{ margin-top:var(--atlas-s4) }

/* THE REGION IS EMPTY, not one card inside it. */
.a-empty.is-page{
  align-items:center; text-align:center;
  padding:var(--atlas-s32) var(--atlas-s16);
}
.a-empty.is-page .a-empty-b{ font-size:var(--atlas-fs-sm); max-width:46ch }

/* A selected value, shown in the field. Removable chips use the ACCENT label —
   the value is committed — with a recessive close (A3). */
.pick-chip{
  display:inline-flex; align-items:center; gap:var(--atlas-s6);
  height:var(--atlas-h-tag); padding:0 var(--atlas-s8); line-height:1;
  border:var(--atlas-bw) solid var(--atlas-accent); border-radius:var(--atlas-r-sm);
  color:var(--atlas-accent); font-size:var(--atlas-fs-xs);
}
.pick-chip button{ border:0; background:none; cursor:pointer; color:var(--atlas-ink-3);
  display:flex; padding:0 }
@media (hover: hover){ .pick-chip button:hover{ color:var(--atlas-ink) } }

/* ══ NUMBER + RANGE FIELDS ══════════════════════════════════════════════════ */
.drw-row{ display:flex; align-items:center; gap:var(--atlas-s8) }
/* ══ INVALID FIELD (K.invalid) ═════════════════════════════════════════════
   The error goes AT the thing, because a message you must act on cannot time
   out (A99 step 3). Two marks, both geometry: the border takes the urgent hue
   and a message sits under the field.

   ⚠️ NO TINT AND NO GLOW. A red-washed field is the tinted background the
   system bans everywhere, and a red `box-shadow` with blur is the glow ban —
   so the state is carried by a BORDER COLOR and a line of text, which is what
   a colourblind reader can also use.

   ⚠️ (0,1,1) BY ELEMENT+CLASS so it beats the plain class without !important,
   and `:focus-visible` still wins after it because that rule comes later. */
input.drw-in[aria-invalid="true"],
textarea.drw-in[aria-invalid="true"],
input.a-field-in[aria-invalid="true"]{ border-color:var(--atlas-urgent) }

/* ⚠️ THE FOCUS RING TAKES THE URGENT HUE TOO, and this is not a detail —
   K.invalid FOCUSES the field, so invalid and focused are the NORMAL pairing,
   not an edge case. Left alone, the accent ring paints inside the urgent
   border and the field wears a teal ring inside a red box: two states arguing
   on one control, which reads as a rendering fault rather than an error.
   Caught in a screenshot; every numeric check had passed. */
input.drw-in[aria-invalid="true"]:focus-visible,
textarea.drw-in[aria-invalid="true"]:focus-visible,
input.a-field-in[aria-invalid="true"]:focus-visible{
  border-color:var(--atlas-urgent);
  box-shadow:inset 0 0 0 1px var(--atlas-urgent);
}

.a-fe{
  display:block; margin-top:var(--atlas-s4);
  font-size:var(--atlas-fs-xs); font-weight:var(--atlas-fw-semi);
  color:var(--atlas-urgent);
}

.drw-in{
  width:100%; min-width:0; height:36px; box-sizing:border-box;
  padding:0 var(--atlas-s12);
  border:var(--atlas-bw) solid var(--atlas-line-2); border-radius:var(--atlas-r-md);
  background:transparent; color:var(--atlas-ink); font:inherit; font-size:var(--atlas-fs-md);
  /* Y13 — tabular figures on anything that aligns vertically. A money field
     sits above another money field. */
  font-variant-numeric:tabular-nums;
  transition:border-color var(--atlas-dur-instant);
}
.drw-in:focus-visible{ outline:none; border-color:var(--atlas-accent);
  box-shadow:inset 0 0 0 1px var(--atlas-accent) }
.drw-in::placeholder{ color:var(--atlas-ink-3) }
/* ⚠️ A DISABLED FIELD HAS TO LOOK DISABLED, or the sentence under it is
   arguing with the control above it. The member editor's email is `disabled`
   for a Google account and read as fully editable — a person types into it,
   nothing happens, and the app has said nothing. C4's other half: when a
   control genuinely cannot be used, say why AND show it.
   ⚠️ (0,1,1) by element+class, so it beats the plain `.drw-in` background
   without `!important` — trap 1's shape, used deliberately. */
input.drw-in:disabled, textarea.drw-in:disabled, select.drw-in:disabled{
  background:var(--atlas-bg-2); color:var(--atlas-ink-2); cursor:not-allowed;
}
/* ⚠️ A TEXTAREA IS NOT A TALL INPUT (Brandon, 2026-08-15: the announcement box
   "rides too high"). The rule above is written for ONE LINE — `height:36px` with
   `padding:0`, where the line box centres itself in the fixed height. A textarea
   inherits that zero vertical padding and has no single line to centre, so its
   first row sits flush against the top border and the text looks stuck to the
   edge. Height has to become automatic and the padding real.
   In the KIT, not on the one field that showed it: `.dash2-ann-ta` set a
   `min-height` and a `line-height` and still rode high, because the missing
   thing was never surface-specific — the next drawer with a textarea would have
   arrived at the same bug. `textarea.drw-in` is (0,1,1) and beats `.drw-in`'s
   (0,1,0), so it wins by arithmetic rather than by source order. */
textarea.drw-in{
  height:auto;
  padding:var(--atlas-s10) var(--atlas-s12);
  line-height:1.55;
  resize:vertical;
}
.drw-dash{ color:var(--atlas-ink-3); flex:none }

/* ══ a-fld — A FIELD THAT CAN BE LOCKED (2026-10-06, Integrations) ══════════
   One field, three states, ONE geometry — nothing moves between them (C8):
     .a-fld            editable — the .drw-in inside is the kit's field, unchanged
     .a-fld.is-locked  VIEW ONLY. A recessed well on the surface ladder (bg-2,
                       never a tint), no border emphasis, ink-2 value, and a lock
                       glyph that SAYS why it cannot be typed in. No hover, no
                       pointer, no focus, out of the tab order (the markup sets
                       readonly + tabindex=-1; `K.fieldLock` keeps them in step).
     .a-fld.is-secret  a saved credential. Locked it shows bullets + the last four
                       — the only part the server ever returns. Unlocked it starts
                       EMPTY, and the eye reveals ONLY what was just typed: a saved
                       key is never read back to the screen (settings §S10).
   ⚠️ C4 SAYS A DEAD CONTROL WITH NO EXPLANATION IS A BUG — and this is not one:
   the lock glyph is the explanation, and its unlock (the card's Edit) sits on
   the same card. A field that can NEVER be edited is still TEXT (`.set2-val`). */
.a-fld-w{ min-width:0 }
.a-fld-w > .drw-l{ display:block; margin-bottom:var(--atlas-s6) }
.a-fld{ position:relative; display:flex; align-items:center; min-width:0 }
.a-fld-hint{ margin:var(--atlas-s6) 0 0; font-size:var(--atlas-fs-xs); color:var(--atlas-ink-3); line-height:var(--atlas-lh) }
.a-fld-hint.is-bad{ color:var(--atlas-urgent) }
.a-fld > .drw-in{ padding-right:var(--atlas-s40) }
.a-fld.is-locked > .drw-in{
  background:var(--atlas-bg-2); border-color:transparent; color:var(--atlas-ink-2);
  cursor:default; pointer-events:none; user-select:none;
}
.a-fld-ic{ position:absolute; right:var(--atlas-s12); display:flex; color:var(--atlas-ink-3); pointer-events:none }
.a-fld:not(.is-locked) > .a-fld-lock{ display:none }
.a-fld.is-locked > .a-fld-eye{ display:none }
.a-fld-eye{
  position:absolute; right:var(--atlas-s6); width:28px; height:28px;
  display:grid; place-items:center; padding:0; border:0; background:transparent;
  color:var(--atlas-ink-3); border-radius:var(--atlas-r-sm); cursor:pointer !important;
}
@media (hover: hover){ .a-fld-eye:hover{ background:var(--atlas-bg-2); color:var(--atlas-ink-2) } }
/* A finger needs more than 28px; the glyph stays small, the target does not. */
@media (pointer: coarse){ .a-fld-eye{ width:44px; height:44px; right:0 } }

/* ══ a-card — A FLAT, BORDERED BLOCK (2026-10-06) ═══════════════════════════
   NOT LIFTED, on purpose (F12): elevation is earned by a unit you can act on,
   dismiss OR rearrange on its own — a dashboard widget. A settings block is acted
   on but never dismissed or moved, so it is a hairline and a radius, and the lift
   stays the signal for things that genuinely float (drawer, popover, confirm).
   Padding is the density token so it follows compact/comfortable (F7). */
.a-card{
  border:var(--atlas-bw) solid var(--atlas-line); border-radius:var(--atlas-r-lg);
  background:var(--atlas-bg-1); padding:var(--atlas-pad);
}

/* ── `.a-ini` — INITIALS WHERE A PERSON HAS NO PHOTO (A355, 2026-11-08) ─────────────
   `K.avatar()` paints these into the consumer's own avatar box, so the size is the box's;
   this sets only the letters: the surface ladder's ground, ink-2, bold, small caps-height
   tracking. `.is-lg` for the 72px identity box, `.is-xs` for a 22px receipt. */
.a-ini{ display:inline-grid !important; place-items:center; background:var(--atlas-bg-3); color:var(--atlas-ink-2);
  font-size:var(--atlas-fs-2xs); font-weight:var(--atlas-fw-bold); letter-spacing:.04em; line-height:1; user-select:none; overflow:hidden }
.a-ini.set2-av-lg, .a-ini.is-lg{ font-size:var(--atlas-fs-lg) }
.a-ini.set2-av-bio{ font-size:var(--atlas-fs-lg) }
.a-ini.is-xs{ font-size:calc(var(--atlas-fs-2xs) * .78) }
.a-ini > svg{ display:none }

/* ══ a-brand — A THIRD-PARTY LOGO TILE (2026-10-06) ═════════════════════════
   P34: brand marks are trademarks, sourced from the company, never Phosphor and
   never redrawn. One tile size for every brand so a list of them aligns; a
   neutral hairline, never a tint. A full-bleed square APP ICON takes our radius
   (`is-square`); a mark with its own silhouette is shown exactly as published. */
.a-brand{
  flex:none; width:44px; height:44px; border-radius:var(--atlas-r-lg);
  border:var(--atlas-bw) solid var(--atlas-line); background:var(--atlas-bg-1);
  display:grid; place-items:center;
}
.a-brand > img{ width:28px; height:28px; object-fit:contain; display:block }
.a-brand > img.is-square{ border-radius:var(--atlas-r-md) }
/* The unit that trails a numeric range ("stars", "days"). Muted, and it never
   takes a share of the row — the figures are the content. Mirrors `.sl-unit`,
   which smart lists already had; this is the drawer's copy of the same idea and
   lives in the kit because the drawer is the kit's. */
.drw-unit{ font-size:var(--atlas-fs-xs); color:var(--atlas-ink-3); flex:none }

/* ══ DATE PICKER (A15/A16) ══════════════════════════════════════════════════
   A15 — native controls are REPLACED WHOLESALE or LEFT NATIVE, never
   half-styled. `<input type="date">` is on the REPLACE list for one reason:
   its popover is unstyleable, so it renders as OS chrome in the middle of a
   surface that is otherwise ours. That is exactly what shipped in the filters,
   and a half-styled native control looks broken in a way a fully native one
   does not.

   A16 — TYPING STILL WORKS. The field is a real text input; the picker ASSISTS,
   it never blocks. Today is a RING, not a fill, because fill means SELECTED and
   one treatment cannot mean two things. Adjacent months render dimmed so the
   grid never reflows between a 4-row and a 6-row month. KIT-BOUND. */
.dp{ position:relative; flex:1; min-width:0 }
.dp-btn{
  position:absolute; right:var(--atlas-s6); top:50%; transform:translateY(-50%);
  width:26px; height:26px; display:grid; place-items:center;
  border:0; background:none; cursor:pointer; color:var(--atlas-ink-3);
  border-radius:var(--atlas-r-xs);
  transition:color var(--atlas-dur-instant),background var(--atlas-dur-instant);
}
@media (hover: hover){ .dp-btn:hover{ color:var(--atlas-accent); background:var(--atlas-bg-2) } }
.dp .drw-in{ padding-right:34px }

/* Inherits every placement rule from `.pop`. The only thing it adds is a fixed
   width — a calendar has a natural size and stretching it to the field would
   make the day cells rectangles. Fixed width is exactly the case `--pop-dx`
   exists for: near the right edge of the band it slides, it does not flip. */
.dp-pop{ left:0; width:260px }
/* The month is the head and the actions are the foot; only the GRID gives.
   Same argument as the picker's search: if a clamp has to take something, it
   must take the part you can scroll to get back, not the part you navigate
   with. Padding moves off the panel and onto the parts so the scrolling grid
   does not carry the panel's padding into its scroll area. */
.dp-hd{ display:flex; align-items:center; gap:var(--atlas-s4); flex:none;
  padding:var(--atlas-s10) var(--atlas-s10) var(--atlas-s8) }
.dp-mo{ font-size:var(--atlas-fs-md); font-weight:var(--atlas-fw-bold); color:var(--atlas-ink) }
.dp-nav{
  margin-left:auto; display:flex; gap:2px;
}
.dp-nav button{
  width:26px; height:26px; display:grid; place-items:center;
  border:0; background:none; cursor:pointer; color:var(--atlas-ink-2);
  border-radius:var(--atlas-r-xs);
  transition:background var(--atlas-dur-instant),color var(--atlas-dur-instant);
}
@media (hover: hover){ .dp-nav button:hover{ background:var(--atlas-bg-2); color:var(--atlas-ink) } }
.dp-nav button:active{ transform:var(--atlas-press-t, translateY(1px)) }

.dp-grid{ display:grid; grid-template-columns:repeat(7,1fr); gap:1px;
  padding:0 var(--atlas-s10) }
.dp-dow{
  font-size:var(--atlas-fs-2xs); font-weight:var(--atlas-fw-bold); color:var(--atlas-ink-3);
  text-align:center; padding:var(--atlas-s4) 0;
}
.dp-d{
  height:30px; display:grid; place-items:center;
  border:var(--atlas-bw) solid transparent; border-radius:var(--atlas-r-sm);
  font-size:var(--atlas-fs-xs); color:var(--atlas-ink); cursor:pointer;
  background:none; font:inherit; font-size:var(--atlas-fs-xs);
  /* Y13 — a calendar is a grid of figures that align vertically. */
  font-variant-numeric:tabular-nums;
  transition:background var(--atlas-dur-instant),color var(--atlas-dur-instant);
}
@media (hover: hover){ .dp-d:hover{ background:var(--atlas-bg-2) } }
.dp-d:active{ transform:var(--atlas-press-t, translateY(1px)) }

@media (pointer: fine){ .dp-d:active{background:var(--atlas-bg-3); } }
/* Adjacent months stay IN the grid, dimmed — removing them would reflow the
   grid between months and make the popover jump height as you page. */
.dp-d.is-out{ color:var(--atlas-ink-3); opacity:.55 }
/* TODAY IS A RING. Fill means selected, and one treatment cannot mean two
   things — this is the same argument as the picker's check-vs-highlight. */
.dp-d.is-today{ border-color:var(--atlas-accent) }
.dp-d.is-on{ background:var(--atlas-accent); color:var(--atlas-on-accent); border-color:var(--atlas-accent) }

.dp-ft{
  display:flex; align-items:center; flex:none; margin-top:var(--atlas-s8);
  padding:var(--atlas-s8) var(--atlas-s10) var(--atlas-s10);
  border-top:var(--atlas-bw) solid var(--atlas-line);
}
.dp-ft .drw-sp{ flex:1 }

/* ── TIME PICKER ────────────────────────────────────────────────────────────
   LIFTED FROM THE LAB (`.tp` / `.tp-col` / `.tp-o`), with one deliberate
   change: the lab drew the PANEL bare, and a real consumer needs the FIELD too.
   So `.tp` is now the wrapper (matching `.dp` exactly — relative, flex:1) and
   the panel is `.tp-pop`, which inherits every placement rule from `.pop`. The
   lab's `.tp` block was the panel; those rules are on `.tp-pop` here.

   THREE COLUMNS, 5-MINUTE STEPS — the lab's argument, unchanged: a free-text
   time field invites "3ish", and a 1-minute wheel is 60 rows of nothing.

   ⚠️ IT DOES NOT CLOSE ON A PICK, unlike the date picker. A date is ONE choice;
   a time is three, and closing after the first would mean re-opening twice to
   answer one question. Outside-click closes it, like every other menu (A16 —
   the picker assists, it never blocks; the field stays typeable throughout). */
.tp{ position:relative; flex:1; min-width:0 }
.tp-btn{
  position:absolute; right:var(--atlas-s6); top:50%; transform:translateY(-50%);
  width:26px; height:26px; display:grid; place-items:center;
  border:0; background:none; cursor:pointer; color:var(--atlas-ink-3);
  border-radius:var(--atlas-r-xs);
  transition:color var(--atlas-dur-instant),background var(--atlas-dur-instant);
}
@media (hover: hover){ .tp-btn:hover{ color:var(--atlas-accent); background:var(--atlas-bg-2) } }
.tp .drw-in{ padding-right:34px }

/* ── FIT ────────────────────────────────────────────────────────────────────
   The default is `flex:1` because a drawer row wants both fields to share the
   line. `.is-fit` is the other honest answer: the field holds a date or a time
   and nothing else, so it is exactly that wide — never more, never less. See
   `FIT_CH` in kit.js for why this is the `size` attribute and not a pixel
   width. `field-sizing` is the Chromium refinement; WebKit keeps the `size`
   width, and both fit. */
.dp.is-fit, .tp.is-fit{ flex:0 0 auto; width:auto }
.dp.is-fit .drw-in, .tp.is-fit .drw-in{
  width:auto; min-width:0; field-sizing:content;
  /* The trigger sits inside the field, so the text needs to stop before it. */
  padding-right:26px;
}
.dp.is-fit .dp-btn, .tp.is-fit .tp-btn{ width:22px; height:22px; right:var(--atlas-s4) }

.tp-pop{ left:0; width:206px; padding:var(--atlas-s6) }
.tp-cols{ display:flex; gap:var(--atlas-s6); min-height:0 }
/* Each column scrolls independently — the hour you want and the minute you want
   are never the same distance down. L26 keeps all three scrollbars invisible
   until they are used, so three tracks side by side cost nothing at rest. */
.tp-col{
  flex:1; max-height:190px; overflow-y:auto; overscroll-behavior:contain;
  display:flex; flex-direction:column; gap:var(--atlas-s2);
}
.tp-o{
  height:30px; display:grid; place-items:center;
  border:var(--atlas-bw) solid transparent; border-radius:var(--atlas-r-sm);
  font:inherit; font-size:var(--atlas-fs-xs); color:var(--atlas-ink); cursor:pointer;
  background:none;
  /* Y13 — a column of figures aligns vertically or it is not a column. */
  font-variant-numeric:tabular-nums;
  transition:background var(--atlas-dur-instant),color var(--atlas-dur-instant);
}
@media (hover: hover){ .tp-o:hover{ background:var(--atlas-bg-2) } }
.tp-o:active{ transform:var(--atlas-press-t, translateY(1px)) }

@media (pointer: fine){ .tp-o:active{background:var(--atlas-bg-3); } }
.tp-o.is-on{ background:var(--atlas-accent); color:var(--atlas-on-accent); border-color:var(--atlas-accent) }

/* ══ THE CAPTURE FIELD (`.a-capture`) ══════════════════════════════════════
   A ONE-LINE CREATE BOX with its own inline controls — write the thing, date
   it, time it, attach it, all without leaving the row.

   ⚠️ IT IS `.a-field`'s TREATMENT, NOT A NEW LOOK (Brandon, 2026-08-15: "make
   sure the capture box is our tokened field too, just with the capture elements
   added… add a new token for capture box that is styled the same"). Same
   `line-2` hairline, same `r-md`, same transparent ground, same `:focus-within`
   accent ring. What differs is the AXIS: `.a-field` is `align-items:flex-end`
   because it holds a GROWING textarea and its action must ride the bottom
   (A42); a capture box is one line that does not grow, so it centres.

   ⚠️ THE WRAPPER OWNS THE BORDER AND THE FOCUS RING, SO EVERY CONTROL INSIDE
   SUPPRESSES ITS OWN (C20). Without that the date and time fields draw their
   own `.drw-in` box and you get three nested rectangles — and three focus rings
   stacking, which reads as broken rather than as focused. This is the same
   bargain `.a-field` already makes with its button.

   ⚠️ AND THE SUPPRESSION MUST OUT-SPECIFY THE GLOBAL FOCUS RULE, which is
   (0,2,0) — a bare class silently loses to it (C20 again, third time). */
.a-capture{
  display:flex; align-items:center; gap:var(--atlas-s6);
  width:100%; box-sizing:border-box;
  padding:var(--atlas-s4) var(--atlas-s4) var(--atlas-s4) var(--atlas-s12);
  border:var(--atlas-bw) solid var(--atlas-line-2);
  border-radius:var(--atlas-r-md);
  background:transparent;
  transition:border-color var(--atlas-dur-instant);
}
.a-capture:focus-within{ border-color:var(--atlas-accent);
  box-shadow:inset 0 0 0 1px var(--atlas-accent) }
.a-capture-in{
  flex:1 1 auto; min-width:0;
  border:0; background:none; outline:none;
  font:inherit; font-size:var(--atlas-fs-sm); color:var(--atlas-ink);
  padding:var(--atlas-s6) 0;
}
.a-capture-in::placeholder{ color:var(--atlas-ink-3) }
/* The tools never stretch and never wrap — they are controls, not columns (A42),
   and four glyphs is a fixed ~120px whatever the box does. */
.a-capture-tools{ display:flex; align-items:center; gap:var(--atlas-s2); flex:none }

/* ── THE ICON TOOLS ────────────────────────────────────────────────────────
   MUTED when empty, ACCENT when set. That is the entire state, and it is why
   the value does not need to be printed inline: presence is the signal (A22),
   and you read a date back at the moment you re-open the picker to change it.

   ⚠️ THE "SET" TEST IS `:has(.drw-in:not(:placeholder-shown))` — CSS, not a
   class somebody has to remember to toggle. The picker already writes the value
   into that input, so the styling reads the SAME fact the save path reads; a
   parallel `.is-on` class would be a second source of truth and would go stale
   the first time a value arrived by any path nobody thought of. */
/* ⚠️ `flex:none` AND `height`, because `.dp` ships `flex:1` for a drawer row —
   inherited here it made the date wrapper eat all the free space and shoved the
   commit button to the edge. An icon is a fixed 24px, not a column. */
.a-capture .dp.is-iconly, .a-capture .tp.is-iconly{
  display:flex; align-items:center; justify-content:center;
  flex:none; width:var(--atlas-h-add); height:var(--atlas-h-add);
  position:relative;
}
/* Visually hidden, NOT `display:none` — the input still holds the value and the
   popover still measures against its wrapper. */
.a-capture .dp.is-iconly .drw-in,
.a-capture .tp.is-iconly .drw-in{
  position:absolute; left:0; top:0; width:1px; height:1px; padding:0; margin:0;
  opacity:0; pointer-events:none; border:0;
}
/* ⚠️ `transform:none` IS LOAD-BEARING, NOT TIDINESS. `.dp-btn` is absolutely
   positioned in a drawer with `top:50%; transform:translateY(-50%)`, and
   resetting only `position` left the transform behind — so the calendar and
   clock glyphs rode 13px ABOVE the lead icon and the row read as three things
   at three heights (Brandon's screenshot: "they arent inline"). The press
   transform is re-declared in `:active` below, so the feedback survives. */
.a-capture .dp-btn, .a-capture .tp-btn, .a-capture .a-capture-ic{
  position:static; transform:none; top:auto; right:auto;
  display:grid; place-items:center; flex:none;
  width:var(--atlas-h-add); height:var(--atlas-h-add);
  border:0; background:none; cursor:pointer;
  color:var(--atlas-ink-3); border-radius:var(--atlas-r-xs);
  transition:color var(--atlas-dur-instant), background var(--atlas-dur-instant);
}
@media (hover: hover){ .a-capture .dp-btn:hover, .a-capture .tp-btn:hover, .a-capture .a-capture-ic:hover{
  color:var(--atlas-ink); background:var(--atlas-bg-2) } }
.a-capture .dp-btn:active, .a-capture .tp-btn:active, .a-capture .a-capture-ic:active{
  transform:var(--atlas-press-t, translateY(var(--atlas-press))) }
/* ACTIVATED. */
.a-capture .dp.is-iconly:has(.drw-in:not(:placeholder-shown)) .dp-btn,
.a-capture .tp.is-iconly:has(.drw-in:not(:placeholder-shown)) .tp-btn,
.a-capture .a-capture-ic.is-on{ color:var(--atlas-accent) }

/* ══ THE COMPLETION BURST (`.a-burst`) ═════════════════════════════════════
   Ticking something off should FEEL like something (Brandon, 2026-08-15). The
   press animation already answers the finger; this answers the ACHIEVEMENT, and
   it is the one place in Atlas that celebrates.

   ⚠️ IT IS GEOMETRY, NOT LIGHT — which is what keeps it legal and, more
   importantly, what keeps it from reading cheap. L4 bans `box-shadow` with any
   blur on an interactive state and L5 bans pulsing glowing dots; a burst built
   from a blurred halo would be both. This is a hairline RING that expands and
   fades, plus eight solid dots thrown outward — zero blur anywhere, and only
   `transform` and `opacity` animate (F9), so it runs on the compositor.

   ⚠️ IT IS PORTALLED AND `position:fixed`, BECAUSE ITS HOST CLIPS. A widget
   body is `overflow:hidden auto` and a dashboard is a grid of them, so a burst
   drawn inside the row would be cut off at the row's edge — and `z-index`
   cannot rescue it, because an ancestor that clips clips its descendants at any
   stacking level (C37, which has now cost four bugs). It mounts in
   `K.portalHost()` for the same reason the tooltip does: parked on `<body>` it
   would lose the entire `--atlas-*` vocabulary and paint in nothing (A45).

   ⚠️ ONE ACCENT, NO CONFETTI PALETTE. A multi-coloured burst borrows meaning
   from a system where green means money and red means overdue (A35's argument
   against six-hue charts). Completion is the accent, once.

   ⚠️ AND IT STOPS ENTIRELY UNDER `prefers-reduced-motion` — a celebration is
   the first thing that should go when somebody has asked for less motion. */
.a-burst{
  position:fixed; z-index:var(--atlas-z-toast);
  width:0; height:0; pointer-events:none;
}
.a-burst-ring{
  position:absolute; left:-13px; top:-13px; width:26px; height:26px;
  border:var(--atlas-bw-em) solid var(--atlas-accent);
  border-radius:var(--atlas-r-full);
  animation:aBurstRing 420ms var(--atlas-ease-out) forwards;
}
.a-burst-p{
  position:absolute; left:-2px; top:-2px; width:4px; height:4px;
  border-radius:var(--atlas-r-full); background:var(--atlas-accent);
  animation:aBurstP 420ms var(--atlas-ease-out) forwards;
}
@keyframes aBurstRing{
  from{ transform:scale(.35); opacity:.85 }
  to  { transform:scale(1.6);  opacity:0 }
}
/* `--a` is set per particle at spawn — the only way eight children can share one
   keyframe and still travel in eight directions. */
@keyframes aBurstP{
  from{ transform:rotate(var(--a)) translateX(3px)  scale(1); opacity:1 }
  to  { transform:rotate(var(--a)) translateX(19px) scale(0); opacity:0 }
}

/* ══ COMPLETION CHOREOGRAPHY (B3 / MB141) ══════════════════════════════════
   The check SPRINGS when it turns on, and the finished row LEAVES ITS PLACE so
   the list visibly closes up. Both are one-shot classes driven by
   `K.rowComplete`, never rules keyed on `.is-on`: these rows are repainted on
   toggle, so a state-keyed animation would replay on every unrelated repaint.

   ⚠️ The box overshoots and settles — it is a thing being SET, not a thing
   appearing. The tick inside rides the same beat so the mark does not arrive
   flat inside a moving box. */
.a-checked{ animation:aChecked 380ms var(--atlas-spring-open) }
@keyframes aChecked{
  0%   { transform:scale(1) }
  30%  { transform:scale(.88) }
  100% { transform:scale(1) }
}
.a-checked svg{ animation:aCheckedMark 380ms var(--atlas-spring-open) }
@keyframes aCheckedMark{
  0%   { transform:scale(.4); opacity:.4 }
  100% { transform:scale(1);  opacity:1 }
}
/* THE ROW LEAVING. Height is pinned by the JS before this runs — `height:auto`
   cannot transition, which is why a row that merely fades leaves its gap behind
   for a frame and the list appears to close up late. */
.a-rowgo{
  overflow:hidden;
  transition:height var(--atlas-dur-base) var(--atlas-ease-in),
             opacity var(--atlas-dur-fast) var(--atlas-ease-in),
             transform var(--atlas-dur-base) var(--atlas-ease-in);
  height:0 !important;
  opacity:0;
  transform:translateX(12px);
}
@media (prefers-reduced-motion: reduce){
  .a-checked, .a-checked svg{ animation:none }
  .a-rowgo{ transition:none }
}

/* ══ THE POP (`.a-pop`) — A ROW SETTLING TO THE BOTTOM ═════════════════════
   The half-beat between ticking a task and it moving to the end of the list.
   The BURST is the celebration; this is the row acknowledging it.

   ⚠️ PROMOTED OUT OF THE DASHBOARD (2026-08-25). It lived as `.dash2-row.is-pop`
   plus a local `popToBottom`, and the lead profile needed the same behaviour —
   which is the moment a surface-local treatment becomes a kit asset rather than
   the moment to copy it (L22). Two implementations of "the row you just ticked"
   is two answers to one question, and they drift on the first tweak.

   ⚠️ `transform` AND `opacity` ONLY (F9), so it composites — a row animating its
   height or margin would reflow everything under it on every frame, which is
   exactly the jank a pile of nineteen cannot afford.

   ⚠️ AND IT IS SHORT. 220ms against the burst's 420: the movement finishes well
   before the celebration does, so the row is settled by the time you look back
   at it. Motion runs WITH the result, never before it (P46). */
.a-pop{
  animation:aPop 220ms var(--atlas-ease-out);
  z-index:1; position:relative;
}
@keyframes aPop{
  0%   { transform:scale(1)     translateX(0) }
  40%  { transform:scale(1.015) translateX(2px) }
  100% { transform:scale(1)     translateX(0) }
}
@media (prefers-reduced-motion: reduce){
  .a-pop{ animation:none }
}
@media (prefers-reduced-motion: reduce){
  .a-burst{ display:none }
}

/* THE TOAST'S CSS IS ITS OWN SHEET — `kit/toast.css`.
   Not tidiness: the design lab is SELF-CONTAINED and re-declares kit classes
   (`.pick-row`, `.drw-*`, `.a-btn`) in its own stylesheet, so it cannot load
   this file to demo a component without re-ordering the cascade under every
   other chapter. A toast is the one asset the lab must run for REAL — timing,
   stacking, hover-hold and the Undo transform are the whole design and a static
   specimen shows none of them — so it gets a sheet the lab can load alone. */

/* ── THE PHOTO CROPPER ─────────────────────────────────────────────────────
   Confirm and size before upload. The frame IS the output shape, so what you
   approve is what lands. */
.a-crop-wrap{
  position:fixed; inset:0; z-index:var(--atlas-z-modal);
  display:grid; place-items:center;
  background:var(--atlas-scrim);
}
.a-crop{
  width:min(360px, calc(100vw - var(--atlas-s32)));
  background:var(--atlas-bg-1);
  border:var(--atlas-bw) solid var(--atlas-line);
  border-radius:var(--atlas-r-lg);
  box-shadow:var(--atlas-lift);
  overflow:hidden;
}
.a-crop-hd{
  display:flex; align-items:center; gap:var(--atlas-s8);
  padding:var(--atlas-s12) var(--atlas-s12) var(--atlas-s12) var(--atlas-s16);
  border-bottom:var(--atlas-bw) solid var(--atlas-line);
}
.a-crop-t{ flex:1 1 auto; margin:0; font-size:var(--atlas-fs-md); font-weight:var(--atlas-fw-bold); color:var(--atlas-ink) }
/* THE STAGE IS THE FRAME — square, because the avatar is square, and the canvas
   fills it exactly so there is no gap to mistake for part of the photo. */
.a-crop-stage{
  position:relative; width:100%; aspect-ratio:1 / 1;
  background:var(--atlas-bg-3);
  cursor:grab; touch-action:none; overflow:hidden;
}
.a-crop-stage:active{ cursor:grabbing }
.a-crop-cv{ display:block; width:100%; height:100% }
.a-crop-zoom{ padding:var(--atlas-s12) var(--atlas-s16) }
.a-crop-range{ width:100%; accent-color:var(--atlas-accent) }
.a-crop-ft{
  display:flex; align-items:center; gap:var(--atlas-s8);
  padding:var(--atlas-s12) var(--atlas-s16);
  border-top:var(--atlas-bw) solid var(--atlas-line);
}

/* ══ THE TAB STRIP ═════════════════════════════════════════════════════════
   PROMOTED OUT OF `shell/shell.css` on its second consumer (2026-08-17). It was
   the bar's alone until the record surfaces took their tabs into their own row
   (N14), and a strip that exists in two places is exactly L32's case: a kit
   class is a LOOK, not a location. The shell keeps `.ash-tabs` for WHERE the
   strip sits on the bar; everything about how a tab looks is here.

   ⚠️ A SCROLLBAR CHANGES THE TAB'S HEIGHT, which is an alignment bug, not a
   scrolling one. `align-items:stretch` sizes a tab to this box, and a
   horizontal scrollbar takes 11px off the bottom — so the moment a strip
   overflows every tab shrinks 47 → 36 and its active underline rides 11px above
   the hairline. Measured side by side: the deal hub's tabs sat visibly higher
   than the lead profile's with byte-identical markup, and the only difference
   was that one strip overflowed. Reserving scrollbar space inside a 48px row
   was never going to work; hiding it makes the height a constant.
   ⚠️ THE COST IS THAT OVERFLOW IS SILENT, so a long strip needs an overflow
   MENU, not a scroll. Keeping tab counts low is the real answer. */
/* ⭐ THE MARK TRAVELS HERE TOO (A340, 2026-10-26). kit.js mounts `.a-tabs-mark`
   into every `.a-tabs` it finds — the shell's header tabs, the lead profile's
   and the deal hub's rows all wear this class — positions it under the `.is-on`
   tab and runs it on `markTravel` when `.is-on` moves. The underline no longer
   snaps and the labels no longer shift: the selected weight is 600 over a 400
   rest, and kit.js pins every tab's `min-width` at the selected weight. The
   selected label is the ACCENT — MB121's ruling, kept by Brandon for desktop
   where the seg moved to ink. A tab is not a mark, so its press stays P41's. */
.a-tabs{
  position:relative;
  display:flex; align-items:stretch; gap:var(--atlas-s2); min-width:0;
  overflow-x:auto; overflow-y:hidden;
  scrollbar-width:none;
  --seg-x:0px; --seg-w:0px;
}
.a-tabs::-webkit-scrollbar{ display:none }
.a-tabs-mark{
  position:absolute; left:0; bottom:0; height:2px; width:var(--seg-w);
  transform:translateX(var(--seg-x)); background:var(--atlas-accent); border-radius:1px;
  pointer-events:none; z-index:1;
}
.a-tabs-mark.is-none{ opacity:0 }
.a-tab{
  display:flex; align-items:center; gap:var(--atlas-s6); box-sizing:border-box;
  padding:0 var(--atlas-s12); font-size:var(--atlas-fs-md); font-weight:var(--atlas-fw-normal);
  color:var(--atlas-ink-2); cursor:pointer; white-space:nowrap;
  text-decoration:none; background:none; border:0;
  border-bottom:2px solid transparent;   /* reserved, so activating moves nothing; the mark paints the colour */
  min-width:var(--seg-mw, auto);         /* pinned by kit.js at the selected weight */
  transition:color var(--atlas-dur-fast),
             transform var(--atlas-dur-fast) var(--atlas-ease-out);
}
.a-tabs.is-measure .a-tab{ font-weight:var(--atlas-fw-semi); min-width:0 }
@media (hover: hover){ .a-tab:not(.is-on):hover{ color:var(--atlas-ink) } }
/* Move along the axis the container does NOT run in (P41): a tab strip is
   horizontal, so a tab presses on Y. Instant down, eased back (P39). */
.a-tab:active{ transform:var(--atlas-press-t, translateY(1px)); transition:var(--atlas-press-in, none) }
.a-tab.is-on{ color:var(--atlas-accent); font-weight:var(--atlas-fw-semi) }
/* kit.js not arrived yet: the tab paints its own underline (trap 44) */
.a-tabs:not(.has-thumb) .a-tab.is-on{ border-bottom-color:var(--atlas-accent) }
.a-tab:focus-visible{ outline:none; box-shadow:inset 0 0 0 1.5px var(--atlas-accent); border-radius:var(--atlas-r-sm) }
@media (prefers-reduced-motion: reduce){ .a-tab{ transition:none } }
.a-tab .a-count{ margin-left:var(--atlas-s2) }   /* the well, as everywhere (A346) */

/* ── THE COUNT — `.a-count` (A22 → A346, 2026-10-26) ──────────────────────
   A NEUTRAL WELL: `bg-2` ground, `ink-2` numeral at 600, tabular, 20px soft
   square (never `r-full` — the shape must not change with the digit count,
   A22's finding that still holds). It was an outlined soft square with the
   accent numeral in bold — the same outlined-box-with-accent anatomy the pills
   and the status pill left today, and in a widget head beside a 600 title the
   accent numeral was the loudest thing in the row. Brandon chose the well over
   a bare numeral (Apple's sidebar) and today's outline, from a live mock.
   ONE rule: the shell's header-tab count and the dashboard's widget-head count
   both wore their own copies (`.ash-count`, `.dash2-ct`); they print this
   class now. The unread BADGE (`.a-badge`, below) is a different thing and
   stays red — a count is how many, a badge is how many you have not seen. */
.a-count{
  flex:none; display:inline-flex; align-items:center; justify-content:center;
  height:var(--atlas-h-count); min-width:var(--atlas-h-count); padding:0 var(--atlas-s6);
  border:0; border-radius:var(--atlas-r-sm); background:var(--atlas-bg-2);
  color:var(--atlas-ink-2); font-size:var(--atlas-fs-2xs); font-weight:var(--atlas-fw-semi);
  font-variant-numeric:tabular-nums; line-height:1;
}

/* ── THE NOTIFICATION BADGE (A331, 2026-09-27) ─────────────────────────────
   iOS's badge, in the kit's red: a filled capsule with the count in it. Apple's rules, which are
   the reason it is its OWN class and not a restyle of `.ash-count` / `.a-count` (those count
   filters, tabs, rows — plain numbers that must not look like this):
     · a badge is the number of unread NOTIFICATIONS, nothing else (HIG · Notifications)
     · keep it true — it follows the snapshot, gone at zero
     · reserve it; one per destination (HIG · Tab bars)
   Apple publishes no dimensions; this is the tab-bar badge's shape — 18 tall, never narrower
   than tall, so 1 digit is a circle and more stretch it into a capsule. The type is rem (it
   scales with the text-size setting); the box is px.
   ⚠️ THE INK IS `--atlas-on-accent`, NOT WHITE: the kit's red is a light coral in dark mode
   (#ff9488), where white text fails contrast; on-accent is white on the light theme's red and
   near-black on the dark theme's.
   A zero-blur ring of the ground it sits on separates it from the glyph it overlaps — geometry,
   not a glow (L4); a consumer sets `--a-badge-ring` to its own ground. */
.a-badge{
  display:inline-flex; align-items:center; justify-content:center; box-sizing:border-box;
  min-width:18px; height:18px; padding:0 5px;
  border-radius:var(--atlas-r-full);
  background:var(--atlas-urgent); color:var(--atlas-on-accent);
  font-size:var(--atlas-fs-2xs); font-weight:var(--atlas-fw-semi); line-height:1;
  font-variant-numeric:tabular-nums; letter-spacing:0; white-space:nowrap;
  box-shadow:0 0 0 2px var(--a-badge-ring, transparent);
}
/* the ROW size — inside a list row (Huddle's channel list) beside a 14px label the nav's 18px badge
   reads as shouting (Brandon, 2026-09-27: "make them smaller in the row"). Same shape, one step
   down: 16 tall, the smallest type step. */
.a-badge.is-sm{ min-width:16px; height:16px; padding:0 4px; font-size:calc(var(--atlas-fs-2xs) * 0.9) }

/* ── THE LISTING STATUS PILL — promoted from market.css (2026-09-27): Market's cards and Huddle's
   listing preview wear the same one. Market's own comment follows, unchanged. ── */
/* The STATUS pill — BOTTOM-left ON the photo (moved 2026-09-15, A299): the
   kit's outlined pill on an OPAQUE bg-1 chip, because over a photo the
   transparent form is illegible and glass is banned (L7/B15). Colors are the
   kit's role tokens — they flip with the theme on their own, so there is no
   dark block here.
   ⚠️ It moved to give the top-left to the SELECT box, which is the corner every
   multi-select in this app uses (the CRM's rows put it first). A status is a
   fact about the listing; a checkbox is something you DO to it, and the thing
   you act with belongs where the eye starts. */
.mcard-st{
  position:absolute; bottom:var(--atlas-s8); left:var(--atlas-s8);
  display:inline-flex; align-items:center; height:22px; line-height:1;
  padding:0 var(--atlas-s8);
  background:var(--atlas-bg-1);
  border:var(--atlas-bw) solid currentColor; border-radius:var(--atlas-r-sm);
  font-size:var(--atlas-fs-2xs); font-weight:var(--atlas-fw-bold);
  letter-spacing:.02em;
  /* ⚠️ A STATUS PILL IS ONE LINE, ALWAYS (Brandon, 2026-09-15: *"make text
     inside status pills become smaller rather than create a second line"*).
     The pill has a FIXED height, so a wrap does not grow it — the second line
     spills out of the box and over the photo, which is what he photographed.
     `nowrap` is the rule; the sizing below is what makes the rule safe. */
  white-space:nowrap;
  /* it can never escape its photo, whatever the label */
  max-width:calc(100% - var(--atlas-s16));
}
.mst-active{ color:var(--atlas-money) }
.mst-coming{ color:var(--atlas-accent) }
.mst-uc{ color:var(--atlas-warn) }
.mst-pending{ color:var(--atlas-urgent) }
.mst-sold{ color:var(--atlas-ink-3) }
/* the SPECS row — Market's card and Huddle's listing preview (promoted the same day) */
.mcard-specs{
  display:flex; align-items:center; gap:var(--atlas-s12); flex-wrap:wrap;
  margin-top:var(--atlas-s6);
  font-size:var(--atlas-fs-sm); color:var(--atlas-ink-2);
}
.mcard-spec{ display:inline-flex; align-items:center; gap:var(--atlas-s6) }
.mcard-spec svg{ color:var(--atlas-ink-3) }
.mcard-spec b{ font-weight:var(--atlas-fw-semi); color:var(--atlas-ink); font-variant-numeric:tabular-nums }

/* ── A RECORD SURFACE'S TAB ROW ────────────────────────────────────────────
   ⭐ N14. On a record — a lead, a deal — the tabs are NOT on the bar. The bar
   carries the trail (`Transactions · Deals · 285 Thistledown Rd`), and the tabs
   take the row directly beneath it, sitting ON TOP of the hairline that row was
   already drawing.

   The reason is width, and it is specific to this layout rather than a change
   of mind about tabs: a record surface has a breadcrumb of two or three steps
   AND a panel taking 340px off the right, so the bar's row is the narrowest in
   the app at exactly the moment it is asked to hold the most. Measured at
   1080px: six tabs needed 477px and had 398.

   ⚠️ IT ADDS NO ROW AND NO HAIRLINE. Both record surfaces already drew this
   48px row to hold their hairline and land it level with the panel's identity
   block; it was EMPTY. So this fills a row we were already paying for — which
   is what makes it a relocation rather than the second strip the shell
   rejected. Exactly one strip is ever on screen. */
.a-tabrow{
  height:var(--atlas-bar-h);
  display:flex; align-items:stretch; gap:var(--atlas-s8);
  padding:0 var(--atlas-s16);
  border-bottom:var(--atlas-bw) solid var(--atlas-line);
  min-width:0;
}
/* The kebab and anything else that belongs to the record sit at the far end —
   `margin-left:auto` on the SLOT, so an empty one occupies nothing and adding a
   control cannot shift the tabs. */
.a-tabrow-end{ margin-left:auto; display:flex; align-items:center; flex:none }

/* ══ PHONE TABS — THE STRIP, THE TRAVELLING MARK AND THE PAGER (MB127) ══════
   ⭐ `K.tabs`. The phone sibling of `.a-tabs` above, and a SEPARATE family on
   purpose: the anatomy genuinely differs. A desktop tab strip is labels with a
   per-tab `border-bottom`; this one has ONE mark that travels, and a STAGE whose
   panes move with the gesture. Two tab vocabularies is a drift risk, so they are
   written next to each other — if you are adding a tab behaviour, decide which
   of these two it belongs to before adding a third.

   ⚠️ ICON MODE IS THE DEFAULT, TEXT IS OPT-IN (`data-ptabs-mode="text"`). The
   PROVISIONAL convention (Brandon, 2026-09-12 — his words: *"its TBD though,
   we'll see how it shakes out"*): a RECORD'S subnavs are icons (facets of one
   thing, a set that rarely changes), a MAIN PAGE'S tabs are text (separate
   destinations, and a perm-variable count that differs per user, so a learned
   icon row would not be reliable). Recorded as a convention, NOT a law — it has
   not been lived with yet.
   ⚠️ AND "WE DO NOT HAVE THAT GLYPH" IS NEVER AN ARGUMENT HERE. The curated icon
   file is a SUBSET we control; Phosphor ships 1,512 and adding one is a line in
   `scripts/gen-phosphor-icons.mjs`. An earlier version of this work reasoned from
   the subset and concluded icons were unworkable for four surfaces — measuring
   what we HAD and reporting it as what was POSSIBLE. */
.a-ptabs{ position:relative; display:flex; align-items:stretch; gap:0;
  height:var(--atlas-h-nav); box-sizing:border-box;
  overflow-x:auto; overflow-y:hidden; scrollbar-width:none;
  -webkit-overflow-scrolling:touch;
  border-bottom:var(--atlas-bw) solid var(--atlas-line);
}
.a-ptabs::-webkit-scrollbar{ display:none }

/* THE MARK. Position AND width from two custom properties the mechanism writes,
   so content-width tabs are affordable — MB20's index math cannot express
   unequal widths, which is why it is superseded here and only here.
   ⚠️ AN UNDERLINE, NOT THE SEGMENTED CONTROL'S LIFTED PILL (Brandon,
   2026-09-12: *"it should just be a tab underline with the colored label"*).
   This reverses MB121's "sliding mark kept" and his own 2026-08-22 "we can not
   use desktop tabs on here", both by the later ruling. */
.a-ptabs-mark{ position:absolute; left:0; bottom:0; height:2px;
  transform:translateX(var(--seg-x,0px)); width:var(--seg-w,0px);
  background:var(--atlas-accent); border-radius:1px;
  pointer-events:none; z-index:1;
}
@media (prefers-reduced-motion: reduce){ .a-ptabs-mark{ transition:none } }

.a-ptab{ position:relative; display:inline-flex; align-items:center; justify-content:center;
  gap:var(--atlas-s6); flex:0 0 auto; padding:0 var(--atlas-s10);
  white-space:nowrap; cursor:pointer; font:inherit;
  font-size:var(--atlas-fs-sm); font-weight:var(--atlas-fw-normal);
  color:var(--atlas-ink-3); background:none; border:0; text-decoration:none;
  transition:color var(--atlas-dur-instant);
}
/* Two indicators, no tint: the accent and a WEIGHT step. */
.a-ptab.is-on{ color:var(--atlas-accent); font-weight:var(--atlas-fw-semi) }
@media (hover:hover){ .a-ptab:hover{ color:var(--atlas-ink) } }
.a-ptab:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press))); transition:var(--atlas-press-in, none) }

/* ⚠️⚠️ THE BOLD WIDTH IS RESERVED, OR THE WEIGHT STEP IS A REFLOW. Measured: a
   tab is 89px selected and 88px not, so every selection change nudged the row
   and the mark landed 2px off and corrected AT SETTLE. The label carries a
   hidden semibold copy of itself in the same grid cell, so the column is always
   as wide as the bold text. That is also what lets the selection flip at the
   START of a transit, putting the 100ms colour change INSIDE the 200ms move
   rather than trailing it. */
.a-ptab-lb{ display:inline-grid }
.a-ptab-lb > span{ grid-area:1/1 }
.a-ptab-lb::after{ content:attr(data-l); grid-area:1/1;
  font-weight:var(--atlas-fw-semi); visibility:hidden; height:0; overflow:hidden;
}
/* Icon mode collapses the label of every tab but the active one. ⚠️ It must stay
   `inline-grid`: declaring `inline-block` here out-specifies the base and takes
   the reserved bold copy OUT of the grid cell, where it sits BESIDE the text and
   doubles the label's natural width (65px of text measuring 130). */
.a-ptabs.is-icon .a-ptab-lb{ overflow:hidden; white-space:nowrap;
  width:var(--lb-w,0px); opacity:var(--lb-o,0);
}
/* ⚠️⚠️ THE FALLBACKS ARE THE PRE-MOUNT STATE, AND GETTING THEM WRONG IS A FLASH
   OF THE WHOLE ROW (Brandon, 2026-09-12: *"at the end of the transition the
   entire tab row flickers with every single lable becoming visible"*). The kit
   writes `--lb-w`/`--lb-o` on every paint — but a surface whose route REBUILDS
   it paints once before the kit mounts a frame later, and in that frame the
   custom properties do not exist yet. So the var() fallback IS the first frame:
   the ACTIVE tab must default to its natural width and full opacity, every other
   tab to zero. Getting this from a class the JS adds cannot work, because the JS
   has not run yet — the same shape as the boot-suppression handoff that flashed
   the legacy header for half a second (C46/trap 47). */
.a-ptabs.is-icon .a-ptab.is-on .a-ptab-lb{ width:var(--lb-w,auto); opacity:var(--lb-o,1) }
.a-ptab-ic{ display:inline-flex; flex:0 0 auto }
/* MEASURING STATE — labels are read with every tab UNCONSTRAINED. A tab is
   sized by the mechanism, so reading a label inside one returns that size and
   not the text: the first-opened tab measured 38px for 65px of text and rendered
   clipped under the next icon. For the width of a thing, ask the thing. */
.a-ptabs.is-icon.is-measuring .a-ptab{ flex:0 0 auto }
.a-ptabs.is-icon.is-measuring .a-ptab-lb{ width:auto; opacity:1 }

/* THE STAGE — Apple's page view: a filmstrip, both panes moving together, no
   parallax and no seam. The push/pop anatomy (02-STANDARD §6) is what entering a
   RECORD looks like and is deliberately NOT used here; these panes are
   neighbours on one strip, not one screen stacked over another. */
/* ══ THE GROUPED LIST (MB147) ══════════════════════════════════════════════
   A section header, then one row per fact: label leading in the quiet ink,
   value trailing in full ink, a hairline between rows and none around them.
   Apple's own grouped list, and the shape Brandon has now asked for twice —
   MB135 in his words (*"Header, then one row with name/label"*) for the CRM's
   Details pane, and again for the deal hub's People tab.

   ⚠️⚠️ IT IS IN THE KIT BECAUSE IT IS ABOUT TO BE THE FOURTH COPY. MB139
   already named the third — Huddle's eyebrow matching `.lead2-cxg-h` — as debt
   in a comment rather than promoting it, and a fourth copy is how a named debt
   becomes permanent. The deal hub is the second SURFACE to need the row itself,
   which is L32's threshold.

   ⬜ THE CRM HAS NOT MIGRATED YET, and that is deliberate rather than forgotten.
   `.lead2-kv` is this row's older twin (15 rules in `crm/lead.css`, 17 uses in
   `crm/lead.js`), but its markup is SHARED between two geometries — the desktop
   rail, where the label is a fixed 82px column, and the phone Details pane,
   where it is this grouped list — so swapping the class is a CRM refactor
   across both viewports rather than a rename. Doing it inside a deal-hub batch
   would put the app's most-used panel at risk for a feature that does not touch
   it. Named here, sized, and queued.

   ⚠️ `min-width:0` ON THE VALUE OR A LONG ONE REFUSES TO SHRINK and pushes the
   row wider than its pane — a flex item's default `min-width:auto` is its
   content. The CRM measured exactly this (scrollWidth 358 vs clientWidth 354). */
.a-kvs{ display:block }
.a-kvs + .a-kvs{ padding-top:var(--atlas-s32) }
.a-kv-h{
  margin:0 0 var(--atlas-s10);
  font-size:var(--atlas-fs-xs); font-weight:var(--atlas-fw-bold);
  letter-spacing:var(--atlas-ls-wide); text-transform:uppercase;
  color:var(--atlas-ink-3);
}
.a-kv{
  display:flex; align-items:center; justify-content:space-between;
  gap:var(--atlas-s16);
  min-height:var(--atlas-h-btn); padding:var(--atlas-s10) 0;
}
.a-kv + .a-kv{ border-top:var(--atlas-bw) solid var(--atlas-line) }
.a-kv-k{
  flex:none; font-size:var(--atlas-fs-xs); color:var(--atlas-ink-3);
}
.a-kv-v{
  flex:0 1 auto; min-width:0; text-align:right;
  color:var(--atlas-ink); overflow-wrap:anywhere;
}
.a-kv-v.is-empty{ color:var(--atlas-ink-3) }
/* A second fact about the same row — a number under a name — reads as
   subordinate rather than as its own row. */
.a-kv-sub{
  display:block; font-size:var(--atlas-fs-xs); color:var(--atlas-ink-3);
  text-decoration:none;
}

.a-ptabs-stage{ position:relative; overflow:hidden; touch-action:pan-y }
.a-ptabs-pane{ position:absolute; inset:0; background:var(--atlas-bg-1); will-change:transform }
/* The settled pane is in flow so the stage can be sized by its content where a
   surface wants that; only the transiting pair are positioned. */
.a-ptabs-stage.is-rest > .a-ptabs-pane{ position:relative; inset:auto; will-change:auto }

/* ── THE QUIET RUNG — chrome on a surface, not a member of a toolbar ───────
   A kebab in a panel's corner is the same IDEA as Filters or Columns (an
   icon-only control that opens something) at a lower volume: it sits on a
   record's identity block rather than in a row of peers, so a permanent border
   would make it the loudest thing beside the name it belongs to.
   ⚠️ IT KEEPS EVERY BEHAVIOUR — the hover fill, the accent border on hover, and
   the P41 press all still fire. Only the RESTING border goes. That distinction
   is the whole point: the control is quiet until you reach for it, not
   permanently weaker. */
.a-tb.is-quiet{
  width:28px; height:28px;
  border-color:transparent; background:transparent;
}
.a-tb.is-quiet svg{ color:var(--atlas-ink-3) }
@media (hover: hover){ .a-tb.is-quiet:hover{ background:var(--atlas-bg-2); border-color:var(--atlas-line-2) } }
@media (hover: hover){ .a-tb.is-quiet:hover svg{ color:var(--atlas-ink) } }

/* ⚠️ OVER A PHOTO the theme's ink and its `bg-2` both lose their contrast
   guarantee — a grey fill on a sunlit facade is invisible and a near-black
   glyph on a dark interior is worse.

   ⚠️ AND IT CARRIES ITS OWN GROUND AT REST, WHICH THE QUIET RUNG DOES NOT.
   That is the whole special case: `is-quiet` is transparent until you reach for
   it, which works on a surface whose colour we chose and fails on a photograph
   we did not — a 16px stroke glyph on foliage is barely there whatever colour
   it is, because the background behind each stroke changes every few pixels.
   A dark disc gives the glyph one ground instead of a hundred, and the blur
   keeps the photo readable through it rather than punching a hole in it. That
   is the same answer prod reached for its status pills over listing photos. */
.a-tb.is-quiet.on-photo{
  background:rgba(0,0,0,.42);
  border-color:rgba(255,255,255,.22);
  backdrop-filter:blur(6px);
}
.a-tb.is-quiet.on-photo svg{ color:rgba(255,255,255,.96) }
@media (hover: hover){ .a-tb.is-quiet.on-photo:hover{ background:rgba(0,0,0,.62); border-color:rgba(255,255,255,.40) } }
@media (hover: hover){ .a-tb.is-quiet.on-photo:hover svg{ color:#fff } }

/* ══ THE TIMELINE ══════════════════════════════════════════════════════════
   ⭐ PROMOTED OUT OF `crm/lead.css` (2026-08-17) on its second consumer — the
   deal hub's Activity tab. The rules below are that file's, verbatim; the
   reasoning came with them, because it is what stops the next person
   "tidying" a decision back out.

   THE LAB'S `.tl2*`. Every entry answers WHAT · WHO · WHEN on one line, with a
   body underneath only when there is one. The rail is a hairline, not a
   decorated spine: this is a dense log that gets scrolled, and ornament on a
   repeating element multiplies by the row count.

   ⚠️ NO OUTER BORDER, AND THE LAB IS RIGHT TO HAVE ONE. In the lab the
   timeline is a SPECIMEN among specimens and needs an edge so you can see
   where one asset stops. On a real surface it IS the page: it runs to the
   bottom of the viewport and scrolls, and an outline around something that
   scrolls past its own edge is a box whose bottom you never see.

   The stronger argument is the composer above it. Its border is REAL — it is a
   field, it contains input, and the edge is what says "type here". The
   timeline's edge contains nothing you can act on, and two identical outlines
   where only one is a control makes the control harder to find. */
.tl2{ border:0; border-radius:0 }
.tl2-i{
  display:flex; gap:var(--atlas-s12); padding:13px 0;
  border-bottom:var(--atlas-bw) solid var(--atlas-line);
  transition:background var(--atlas-dur-instant);
}
/* THE LAST ROW KEEPS ITS RULE — the same call as the table's. With no outer
   border to close the list, dropping it would leave the log fraying into the
   space below rather than ending.

   ⚠️ THE HOVER DOES NOT RESIZE THE ROW. The first version bled the highlight
   to the gutter edges with a negative margin and matching padding — which
   moves the row's box under the pointer, and a row that changes size when you
   point at it is the thing P39 exists to stop. */
@media (hover: hover){ .tl2-i:hover{ background:var(--atlas-bg-2) } }
/* THE GLYPH SITS ON THE NEUTRAL WELL (A26 → A347, 2026-10-26). A 24px tile on
   the kit's small radius with the WELL as its ground — bg-2, the same container
   the count (A346) and the segmented track (A338) wear — and the glyph keeping
   its hue: note, call, text, email and drip in their activity colour, every
   system row in ink-2, the AI-drafted row's gradient glyph on the same ground.
   The filled grey-quiet tile (tone as a solid ground) was built first on
   Brandon's pick and tried on real leads the same evening; a column of solid
   tiles read as too much colour, and he asked for this instead. What A26 got
   right survives whole: the system spends no colour, and nothing is a tinted
   disc. The glyph is the FILL weight at 14px — regular's sub-pixel stroke read
   as a scratch on any ground. Phones still drop the glyph (MB36). */
/* ══ THE TIMELINE, LOADING ══════════════════════════════════════════════════
   The same row with its content replaced (A121) — the glyph column, the header
   line and the body land in their final positions, so nothing moves when the
   feed arrives. Not interactive: it is not a record. */
.tl2-skel{ pointer-events:none }
.tl2-skic{ display:block; width:24px; height:24px; border-radius:var(--atlas-r-sm) }   /* the tile's own size (A347) */
/* The header's three bars sit on the row's own baseline and inherit its gap
   from `.tl2-hd` (flex), so they land where the label, the author and the stamp
   actually are. */
.tl2-skh{ display:block; height:10px; border-radius:var(--atlas-r-xs); flex:none }
/* Body lines stack on the real line rhythm, and the last one is short — the
   same paragraph convention the composer's field uses. */
.tl2-skb{ display:block; height:11px; border-radius:var(--atlas-r-xs) }
.tl2-skb + .tl2-skb{ margin-top:6px }

.tl2-ic{ width:24px; height:24px; flex:none; display:grid; place-items:center;
  margin-top:-2px;   /* a 24px tile beside a ~20px title line: centred on the title, not hung below it */
  border-radius:var(--atlas-r-sm); background:var(--atlas-bg-2); color:var(--atlas-ink-2);
  transition:background var(--atlas-dur-instant) }
.tl2-ic svg{ width:16px; height:16px }   /* 16 in 24: Phosphor's inner margin leaves ~13px of ink, Apple's tile ratio (2026-10-27) */
@media (hover: hover){ .tl2-i:hover .tl2-ic{ background:var(--atlas-bg-3) } }   /* the row hovers to bg-2; the well steps up with it */
/* An AI-drafted row takes the gradient on the GLYPH and drops its activity
   tint — two colour stories on one mark is a mess, and the gradient is already
   the system's one meaning of "a model touched this" (L6). The paint comes
   from the SVG; the well stays neutral (never a gradient fill, L13). */
.tl2-ic.is-ai{ color:var(--atlas-ink-2) }
.tl2-ic.t-note { color:var(--atlas-act-note) }
.tl2-ic.t-call { color:var(--atlas-act-call) }
.tl2-ic.t-text { color:var(--atlas-act-text) }
.tl2-ic.t-email{ color:var(--atlas-act-email) }
.tl2-ic.t-drip { color:var(--atlas-act-drip) }
.tl2-main{ flex:1; min-width:0 }
.tl2-hd{ display:flex; align-items:baseline; gap:7px; flex-wrap:wrap }
.tl2-t{ font-size:var(--atlas-fs-md); font-weight:var(--atlas-fw-semi) }
.tl2-m{ font-size:var(--atlas-fs-xs); color:var(--atlas-ink-3) }
.tl2-dot{ font-size:var(--atlas-fs-xs); color:var(--atlas-ink-3) }
/* ⭐ THE SOURCE MICRO-LABEL — new with the promotion, and the deal hub is why:
   its feed carries the deal's own rows AND the linked lead's, so a row that
   came from the CRM has to say so or the two read as one undifferentiated log.

   ⚠️ IT IS TYPE, NOT A CHIP. A bordered or filled badge on a REPEATING row is
   the tint/box problem the disc above was removed for — it multiplies down the
   feed and competes with the glyph that already carries the category. An
   uppercase tracked micro-label is the fourth hierarchy channel the type laws
   name (L11/Y1), it costs no vertical space, and at `--atlas-fs-2xs` it is the
   one size F8 permits below the 13px floor *because* it is uppercase and
   tracked. Absent when the consumer supplies nothing (A22). */
.tl2-src{
  font-size:var(--atlas-fs-2xs); font-weight:var(--atlas-fw-semi);
  letter-spacing:.06em; text-transform:uppercase; color:var(--atlas-ink-3);
}
/* THE BODY IS SELECTABLE and the chrome is not — notes get copied out of here,
   and a header that comes with them is noise in the paste. */
.tl2-b{ display:block; font-size:var(--atlas-fs-md); color:var(--atlas-ink-2);
  margin-top:var(--atlas-s4); white-space:pre-wrap; user-select:text; overflow-wrap:anywhere }
/* ⚠️ `overflow-wrap:anywhere` ON EVERY TIMELINE BODY (2026-10-12). A run with no
   break opportunity — a legacy note's 28-character "――――" rule, a long link
   or address (48 notes on 41 leads, measured) — was one word wider than a
   phone, and the WHOLE timeline scrolled sideways. Anywhere, not break-word:
   it also lets the flex column shrink past the word (the kit's `.a-kv-v`
   rule). A line that is only a rule is drawn as the hairline below (tlRules). */
/* SHORT, NOT FULL WIDTH — a full-width hairline is the line BETWEEN timeline
   rows, and the note's second half read as a separate entry (caught on the
   390px check). A short mark reads as a break inside the one note. */
.tl2-rule{ display:block; width:48px; height:0; margin:var(--atlas-s8) 0;
  border-top:var(--atlas-bw) solid var(--atlas-line-2) }
/* An expandable email row (2026-09-02): the PREVIEW (`.tl2-b`) shows collapsed,
   the full body (`.tl2-full`) is hidden, and a quiet "Read full email" toggles
   between them. `.is-tl-open` on the row swaps which is shown — expand in place,
   ephemeral (the timeline clears it when the lead is left). Geometry + tokens
   only; the affordance is a text button, no chrome. */
.tl2-full{ display:none; margin-top:var(--atlas-s4);
  font-size:var(--atlas-fs-md); color:var(--atlas-ink-2);
  white-space:pre-wrap; user-select:text; overflow-wrap:anywhere }
/* Formatting the safe-list lets through (A196) — rendered the same as it
   looked in the editor. Lists get real structure; `white-space:pre-wrap` on
   the bodies makes any stray whitespace inside a list double up, so the list
   resets it. */
.tl2-list{ margin:2px 0; padding-left:22px; white-space:normal }
.tl2-list li{ margin:1px 0 }
.tl2-b a, .tl2-full a{ color:var(--atlas-accent); text-decoration:underline; text-underline-offset:2px }
.tl2-more{ display:inline-flex; margin-top:var(--atlas-s6);
  border:0; background:transparent; padding:0; cursor:pointer; font:inherit;
  font-size:var(--atlas-fs-sm); font-weight:var(--atlas-fw-semi);
  color:var(--atlas-accent); }
.tl2-more-close{ display:none }
/* The confirmed-human open/click marker — a quiet read-receipt in the header
   meta. money tone for the check (a positive, earned signal), the label in
   ink-3 so it reads as a fact, not a shout. No tint, weight-over-color. */
.tl2-open{ display:inline-flex; align-items:center; gap:var(--atlas-s4);
  font-size:var(--atlas-fs-xs); color:var(--atlas-ink-3); white-space:nowrap; }
.tl2-open svg{ color:var(--atlas-money); flex:none }
.tl2-i.is-tl-open .tl2-b{ display:none }
.tl2-i.is-tl-open .tl2-full{ display:block }
.tl2-i.is-tl-open .tl2-more-open{ display:none }
.tl2-i.is-tl-open .tl2-more-close{ display:inline }
@media (hover: hover){ .tl2-more:hover{ text-decoration:underline } }
.tl2-i, .tl2-hd{ user-select:none }

/* ══ REACTING, EDITING AND DELETING A TIMELINE ROW ═════════════════════════
   Ported from the legacy CRM, which had all three and lost them in the
   rebuild. The plumbing never went anywhere — three endpoints and their rules
   are unchanged; this is the surface they were missing.

   ── THE ROW HOSTS THE ACTIONS ──────────────────────────────────────────── */
.tl2-i{ position:relative }
/* ⚠️ HOVER-REVEALED, AND THEREFORE DESKTOP-ONLY (C9). A hover affordance is
   invisible to a thumb and to a keyboard, so the strip is gated on a real
   pointer and the phone reaches the same three verbs through a LONG PRESS.
   `:focus-within` keeps it reachable by tab, which is the half that makes a
   hover-revealed control legitimate rather than hidden. */
.tl2-acts{
  position:absolute; top:var(--atlas-s6); right:0;
  display:none; align-items:center; gap:var(--atlas-s2);
  /* ⚠️⚠️ THE STRIP'S GROUND TRACKS THE ROW'S — C28, WHICH THIS BROKE IN ITS
     SECOND HALF (Brandon, 2026-08-28: *"looks horrible with the white
     overlay"*). The strip is absolutely positioned OVER the header line so a
     long label passes underneath it, which is what the ground is for; but it
     was pinned to `--atlas-bg-1` while `.tl2-i:hover` paints the row
     `--atlas-bg-2`. The strip is only ever VISIBLE on hover, so it was a white
     rectangle on a grey row — 100% of the time it was on screen.
     C28's rule is both halves: a floating opaque element must set its own
     background AND follow the states of the row it belongs to. */
  background:var(--atlas-bg-1); padding-left:var(--atlas-s8);
  transition:background var(--atlas-dur-instant);
}
@media (hover: hover){
  .tl2-acts{ display:flex; opacity:0; transition:opacity var(--atlas-dur-instant), background var(--atlas-dur-instant) }
  .tl2-i:hover .tl2-acts,
  .tl2-i:focus-within .tl2-acts{ opacity:1 }
  .tl2-i:hover .tl2-acts{ background:var(--atlas-bg-2) }
  /* ⚠️ AND THE ICON'S OWN HOVER HAS TO STEP PAST THE ROW'S. `.a-x:hover` is
     `--atlas-bg-2`, which is now exactly what the strip is sitting on — so
     without this the button gives no feedback at all on the one surface it
     lives on. One step further up the neutral ladder (L3: state is neutral,
     colour is meaning). */
  .tl2-i:hover .tl2-acts .a-x:hover{ background:var(--atlas-bg-3) }
}
.tl2-act{ flex:none; cursor:pointer }
@media (hover: hover){ .tl2-act.is-danger:hover{ color:var(--atlas-urgent) } }

/* ── THE REACTION PICKER ──────────────────────────────────────────────────
   ⚠️ SIX CLASSES WERE WRITTEN IN `crm/timeline.js` AND DEFINED NOWHERE (C43,
   2026-08-28). `.tl2-rxpick-b` had no rule anywhere in the repo, so on a phone
   the emoji sat in the browser's DEFAULT BUTTON — a grey rounded box at the UA
   font size. Brandon: *"the react emojis are so tiny and have grey boxes around
   them. Does not feel like a premium feature at all."* Missing CSS throws
   nothing and the markup reads correctly, which is why it survived review. */
.tl2-rxpick{ position:relative; display:inline-flex; flex:none }  /* MB106 — the host IS the pop's containing block */
/* Right-anchored: the strip is at the row's right edge, so a panel hanging from
   the LEFT of a 24px button would immediately need `placePop` to drag it back.
   `placePop` still clamps and flips (L19); this just starts it in the right
   place. */
.tl2-rxpop{ right:0; left:auto; padding:var(--atlas-s6) }
.tl2-rxrow{ display:flex; align-items:center; gap:var(--atlas-s2) }
.tl2-rxpick-b{
  display:grid; place-items:center; flex:none;
  width:36px; height:36px; padding:0;
  border:0; background:none; cursor:pointer;
  border-radius:var(--atlas-r-full);
  font-size:var(--atlas-fs-xl); line-height:1;
  transition:background var(--atlas-dur-instant);
  touch-action:manipulation; -webkit-tap-highlight-color:transparent;
}
@media (hover: hover){ .tl2-rxpick-b:hover{ background:var(--atlas-bg-2) } }
.tl2-rxpick-b:active{ transition:none }

@media (pointer: fine){ .tl2-rxpick-b:active{background:var(--atlas-bg-3); } }

/* ⚠️ `.tl2-sheet` WENT WITH THE SHEET IT STYLED (MB140, 2026-09-12). The
   timeline's phone action sheet is now `K.holdMenu`, anchored to the entry;
   leaving its rules behind is the invisible debt that bit this codebase when a
   deleted picker's `.compose-wiz-lead-row` kept styling its replacement.
   `.tl2-rxpick-b` below is KEPT — the DESKTOP reaction picker still emits it. */

/* ── THE REACTIONS ────────────────────────────────────────────────────────
   ⚠️ AN OUTLINE, NEVER A TINT (L3). "You reacted" is stated with the accent
   LINE and the neutral surface ladder — a filled chip would be the one tinted
   thing in the system, and it would out-weigh the note it is attached to. */
.tl2-rx{ display:flex; flex-wrap:wrap; gap:var(--atlas-s4); margin-top:var(--atlas-s6) }
.tl2-rx-b{
  /* 28px, not 24 — the pill has to hold a FACE now, and a face that has to
     shrink to fit its container is a face nobody can identify (Brandon,
     2026-08-28: *"make the photo a bit bigger… more proportionate to the
     emoji"*). The avatar and the emoji are sized against each other below. */
  display:inline-flex; align-items:center; gap:var(--atlas-s4);
  height:28px; padding:0 var(--atlas-s8) 0 var(--atlas-s10);
  border:var(--atlas-bw) solid var(--atlas-line-2); border-radius:var(--atlas-r-full);
  background:var(--atlas-bg-1); cursor:pointer;
  font-size:var(--atlas-fs-xs); color:var(--atlas-ink-2); line-height:1;
  transition:background var(--atlas-dur-instant), border-color var(--atlas-dur-instant);
}
@media (hover: hover){ .tl2-rx-b:hover{ background:var(--atlas-bg-2) } }
/* A CONTROL DEPRESSES (P39/P41) — instantly on the way down, so the finger is
   already there when it moves. */
.tl2-rx-b:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press))); transition:var(--atlas-press-in, none) }

@media (pointer: fine){ .tl2-rx-b:active{background:var(--atlas-bg-3); } }
.tl2-rx-b.is-mine{ border-color:var(--atlas-accent); color:var(--atlas-ink) }
/* ⚠️ THE EMOJI AND THE FACE ARE SIZED AGAINST EACH OTHER, not independently.
   An emoji glyph renders a little SHORTER than its font-size, so 16px of type
   and a 22px disc land at roughly the same optical height — which is what makes
   the pill read as two things of equal weight rather than a badge with a
   sticker on it. `line-height:1` keeps the glyph off the descender band that
   would otherwise ride it high (C24). */
.tl2-rx-e{ font-size:var(--atlas-fs-lg); line-height:1 }
.tl2-rx-n{ font-variant-numeric:tabular-nums }
/* ── WHO REACTED (2026-08-28) ─────────────────────────────────────────────
   Faces, not a number — see the note on `tlRx`. They OVERLAP by a third, which
   is what makes three of them read as a group rather than as three separate
   things, and the ring is the row's own ground so the stack has a visible edge
   between each face without inventing a border colour. */
.tl2-rx-who{ display:inline-flex; align-items:center }
.tl2-rx-who > * + *{ margin-left:-7px }
/* ⚠️ THE RING IS A BORDER, NOT A `box-shadow`. L4 allows a zero-blur ring as
   geometry, but a border says the same thing without putting another entry in
   the shadow ledger the lint suite ratchets — and `border-box` keeps the slot
   18px whatever is inside it, so a row never shifts between a photo and a mark. */
.tl2-rx-av{
  box-sizing:border-box;
  width:22px; height:22px; flex:none;
  border-radius:var(--atlas-r-full); object-fit:cover;
  /* `object-position:center` is the default, but an avatar is the one place a
     non-square source is common (a wide headshot crop), and a face cropped from
     the top edge is the failure this states out loud. */
  object-position:center;
  display:grid; place-items:center;
  background:var(--atlas-bg-2); color:var(--atlas-accent);
  border:2px solid var(--atlas-bg-1);
  /* An `<img>` is an inline replaced element, so it sits on the TEXT BASELINE
     and hangs below it by the descender — which is why a photo beside an emoji
     looks a pixel or two low no matter what the flex container says. `block`
     takes it out of the baseline entirely and lets `align-items:center` do the
     job it was already trying to do. */
  display:block;
}
.tl2-rx-av:not(img){ display:grid; place-items:center }
/* The pill's ground moves with the row, so the ring has to as well — the same
   rule as the action strip above (C28), one component further in. */
@media (hover: hover){ .tl2-i:hover .tl2-rx-av{ border-color:var(--atlas-bg-2) } }
/* ⚠️ THE SAME TWO LINES EVERY PRESSABLE NEEDS ON A PHONE, and these are not
   inside a `.pop`, so the kit's blanket rule for picker contents does not reach
   them. `touch-action:manipulation` removes the ~300ms wait for a second tap;
   the transparent highlight stops iOS painting its own grey rectangle over our
   press, which arrives at a different moment and a different shape — two
   answers to one tap, and ours is the one that matches the system. */
.tl2-rx-b, .tl2-act{
  touch-action:manipulation;
  -webkit-tap-highlight-color:transparent;
}

/* ── THE EDITOR ───────────────────────────────────────────────────────────
   ⚠️⚠️ IT MIRRORS THE DISPLAY, IT DOES NOT STRIP TO A TEXTAREA. A note carries
   line breaks, bold and mention chips; round-tripping that through
   `textContent` collapses every one of them into a single run — the exact bug
   CLAUDE.md records against the legacy version of this feature. So the editor
   is a `contenteditable` wearing the SAME class the body wears, preloaded with
   the same HTML, and what you type into looks like what you were reading. */
.tl2-ed{
  display:block; margin-top:var(--atlas-s4);
  min-height:var(--atlas-h-field); padding:var(--atlas-s8) var(--atlas-s10);
  border:var(--atlas-bw) solid var(--atlas-accent); border-radius:var(--atlas-r-md);
  background:var(--atlas-bg-1); color:var(--atlas-ink);
  font-size:var(--atlas-fs-md); white-space:pre-wrap; outline:none;
  user-select:text; -webkit-user-select:text;
}
.tl2-ed-ft{ display:flex; gap:var(--atlas-s8); margin-top:var(--atlas-s8) }
/* "edited", after the timestamp — the record says it was changed, which is the
   whole reason an edit is allowed instead of a delete. */
.tl2-ed-mark{ color:var(--atlas-ink-3); font-style:italic }

/* ══ THE COMPOSER ══════════════════════════════════════════════════════════
   LIFTED FROM THE LAB, value for value (`.cmp*`), the same way the table was.
   The first attempt here was a composer built from scratch — four naked pills
   and a bordered field — which is not the asset: the collapsed state is a
   FULL-WIDTH BOX that reads as a place to write, with `cursor:text` and the
   pills sitting quietly on the right. Brandon's words were "not even close",
   and the lesson is the one this whole rebuild runs on: THE LAB IS THE ASSET,
   and inventing a second one is how a design system becomes a mood board.

   ⚠️ DURATION IS `base` (200ms), NOT `fast` — AND I ARGUED THE WRONG WAY.
   F10 is a LOCKED decision that names this exact control: "expand/collapse is
   one of the few cases animation genuinely earns its place (it shows where
   content came from). Retune to base (200ms)." I reasoned from first
   principles — a toggle under your own cursor should be ≤150ms — and reached a
   different answer, which is exactly the failure the decisions file exists to
   prevent. The reasoning is not wrong in general; it is wrong HERE, because
   this animation has a job beyond feedback: it shows the panel growing out of
   the line you clicked, and a motion that has to be READ needs longer than one
   that only has to be felt.

   NO `overflow:hidden` — it clipped the tool tooltips in half. The radius still
   works because `.cmp` paints its own background and its children carry none. */
.cmp-pills{ display:flex; gap:var(--atlas-s4) }
/* THE CHIPS FOLLOW THE SEG (MB35 → A338, built 2026-10-27): 500 at rest in ink-2,
   600 selected, the width pinned by kit.js at the selected weight so picking a
   mode moves nothing (the same measured pin the seg and the tab strip use —
   `.cmp-pills` is a mark host with no mark). The selected chip keeps its MODE
   HUE: that is A25's colour-as-meaning, the same hue the timeline tile paints,
   not the accent-as-chrome the seg gave up. */
.cmp-pill{
  display:inline-flex; align-items:center; justify-content:center; box-sizing:border-box;
  font-size:var(--atlas-fs-2xs); font-weight:var(--atlas-fw-medium);
  height:26px; padding:0 var(--atlas-s10); line-height:1; min-width:var(--seg-mw, auto);
  border:0; background:none;
  border-radius:var(--atlas-r-sm); color:var(--atlas-ink-2); cursor:pointer;
  transition:background var(--atlas-dur-instant),color var(--atlas-dur-instant);
}
.cmp-pills.is-measure .cmp-pill{ font-weight:var(--atlas-fw-semi); min-width:0 }
@media (hover: hover){ .cmp-pill:hover{ background:var(--atlas-bg-2); color:var(--atlas-ink) } }
/* P41 — the pill row runs horizontally, so a pill presses on Y. */
.cmp-pill:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press))); transition:var(--atlas-press-in, none) }
/* EACH MODE CARRIES ITS OWN HUE when selected (A25). Note is the accent and
   comes FIRST, because a note is the default thing a person logs. The hue is
   the ONLY thing that varies — lightness and chroma are fixed by K1, which is
   what keeps four different colors reading as one set rather than four
   unrelated brand colors. */
.cmp-pill.is-on{ background:var(--atlas-bg-2); font-weight:var(--atlas-fw-semi) }
.cmp-pill.is-on.t-note { color:var(--atlas-act-note) }
.cmp-pill.is-on.t-call { color:var(--atlas-act-call) }
.cmp-pill.is-on.t-text { color:var(--atlas-act-text) }
.cmp-pill.is-on.t-email{ color:var(--atlas-act-email) }
/* THE COMMIT BUTTON CARRIES THE SAME COLOR AS THE MODE. The button already
   names the mode ("Log note", not "Save" — B11), so coloring it closes the
   loop: the pill you picked, the thing you are about to write, and the button
   that writes it are one color. It also means the composer's single strongest
   element is never the wrong color for what it does. */
.cmp-go.t-note { background:var(--atlas-act-note) }
.cmp-go.t-call { background:var(--atlas-act-call) }
.cmp-go.t-text { background:var(--atlas-act-text) }
.cmp-go.t-email{ background:var(--atlas-act-email) }
/* ⚠️ TASK TAKES THE ACCENT — IT DOES NOT GET A FIFTH HUE, deliberately. The
   four colors mean "which way you reached them"; a task is not a way of
   reaching anyone, so a fifth would quietly turn the set from "the four contact
   methods" into "five things in a row" and the color would stop carrying a
   meaning. Sharing the accent with Note is the honest pairing: those are the
   two modes that never leave Atlas. */
.cmp-pill.is-on.t-task { color:var(--atlas-accent) }
.cmp-go.t-task { background:var(--atlas-accent) }
/* ⚠️ A COMPACT CONTROL ROW, NOT A DRAWER FOOTER. It ran 64px tall — 44px
   buttons in 10px of padding — and read bulky under a box you are only typing
   two lines into (Brandon, 2026-08-14). The button is what sets the height of
   the whole band here, so it takes the compact rung (`--atlas-h-btn-sm`, 36px)
   and the fields beside it take the system's existing container-control height
   (`--atlas-h-control`, 34px) instead of the bespoke 32 they had. 52px. */

/* ── THE SCHEDULING ROW ─────────────────────────────────────────────────────
   ONE ROW, SHARING ITS LINE WITH THE COMMIT PAIR. The first cut stacked the
   fields above the buttons, which moved the commit button down a row the moment
   you chose Task — so the button you were aiming at was somewhere else. The
   fields go left, `.cmp-ft-btns` keeps its `margin-left:auto`, and the buttons
   stay exactly where they sit in every other mode.

   THE FIELDS RUN COMPACT (32px, small type) because five controls and two
   buttons have to share a line. It WRAPS rather than scrolls — a horizontally
   scrolling form is a form with a field you cannot see. */
.cmp-ft.is-sched{ flex-wrap:wrap; row-gap:var(--atlas-s8) }
.cmp-sched{ display:contents }
.cmp-extras{ display:contents }
/* ⚠️ NO WIDTHS HERE. The fields carry `.is-fit`, so each is exactly as wide as
   the text it can hold and the KIT owns that rule for everyone. Three
   hand-picked pixel widths sat here and were wrong twice in ten minutes — a
   clipped "mm/dd/yyy", then a clipped "4:25 AN" — which is what a guess about a
   font at a size on a platform will always be. */
.cmp-sched .drw-in, .cmp-loc{
  height:var(--atlas-h-control); font-size:var(--atlas-fs-sm);
}
/* ⚠️ IT MUST NOT GROW. With `flex-grow` it ate the slack and pushed the commit
   pair onto a second line — the exact thing this row exists to avoid. It gives
   up width before it wraps. */
.cmp-loc{ flex:0 1 152px; min-width:0 }
/* Matched to the compact fields so the row reads as one band, not two heights. */
/* Horizontal only — the TRACK owns the height (`--atlas-h-control`), and a
   vertical padding here is what made this control 0.75px taller than the button
   beside it and grew the whole composer when you chose Task. */
.cmp-kind .seg-b{ padding:0 var(--atlas-s10) }
.cmp-dur{ height:var(--atlas-h-control); font-size:var(--atlas-fs-sm); flex:0 0 auto }
.cmp-dur-pop{ left:0; width:132px }

/* ⚠️ F9 — TRANSFORM AND OPACITY ONLY, NEVER LAYOUT. The box changes size in one
   step and the EXPANDED CONTENT animates: a height transition here would reflow
   the whole timeline underneath on every frame, and the cost of animating
   layout scales with what is below it. Transform-origin top, so it reads as
   growing out of the collapsed line rather than fading in over it — which is
   the "shows where content came from" F10 is protecting. */
.cmp:not(.is-collapsed){
  /* ⚠️⚠️ `backwards`, NEVER `both` — AND THIS WAS THE SYSTEMIC MOBILE DROPDOWN
     BUG (2026-08-28). `forwards` holds the FINAL KEYFRAME after the animation
     ends, and this one ends at `transform: none` — which, held by an animation,
     computes to **`matrix(1, 0, 0, 1, 0, 0)`** rather than the keyword. A
     transform of any value, identity included, creates a STACKING CONTEXT, so
     an entrance animation that finished a second after load was permanently
     trapping every popover the composer would ever open: measured, the mode
     select's panel had `z-index:500` and still painted UNDER the timeline text
     (Brandon: *"this has been an issue with every single dropdown on
     mobile"*).

     ⚠️ IT IS INVISIBLE FROM THE CSS. The keyframe says `transform: none`, so
     reading it tells you there is no transform; only the COMPUTED value gives
     it away, and only while the element is not being animated. Trap 39 in a new
     costume — the z-index is correct, the ancestor is the problem — and this is
     the ancestor nobody would think to check, because its animation is over.

     ⚠️ AND `forwards` BOUGHT NOTHING HERE. The final keyframe is the element's
     own resting state (opacity 1, no transform), so persisting it is a no-op
     with a stacking context attached. The one animation that genuinely needs it
     is `a-sheet-down`, which ends OFF-SCREEN and must stay there until the node
     is removed. */
  /* ⚠️ THE KIT'S EXPAND SPRING, NOT A 200ms EASE (MB154). Brandon,
     2026-09-13: *"give it our mobile kit's expand and collapse animation so it
     isn't as snappy."* `--atlas-spring-open` is the same motion the hold menu
     and the sheet's detent snap already open on — a gentle overshoot to 1.0015
     and a long settle — and running it at its own `--atlas-spring-open-dur` is
     the token block's rule: a spring ships with its natural settling duration,
     and a foreign duration changes its velocity.
     ⚠️ STILL TRANSFORM AND OPACITY ONLY (F9, above) — a longer motion makes
     that MORE important, not less: a height transition here would reflow the
     whole timeline beneath it on every one of 610ms worth of frames. */
  animation:cmpIn var(--atlas-spring-open-dur, 610ms) var(--atlas-spring-open, ease) backwards;
  transform-origin:top center;
}
@keyframes cmpIn{
  /* ⚠️⚠️ NO UPWARD TRANSLATE — IT CLIPPED (Brandon, 2026-09-13: *"the top line
     of the composer gets clipped when it expands, very briefly during the
     animation"*). The composer sits at the TOP of its pane, and the pane lives
     inside `.a-ptabs-stage`, which is `overflow:hidden` BY NECESSITY — the
     pager clips so a transiting pane cannot show outside the stage. So a
     `translateY(-6px)` start put the composer's first frames 6px ABOVE the
     stage's own edge, and they were cut off.
     ⚠️ THE CLIP WAS ALWAYS THERE; the longer motion is what made it visible.
     At `--atlas-dur-base` the offending frames lasted ~30ms and nobody could
     see them; at 610ms there is time to watch. **A slower animation does not
     introduce these — it exposes them**, which is worth expecting the next time
     a duration grows.
     Scale alone, from a TOP origin, is the same idea without leaving the box:
     the composer grows DOWN out of the line it replaced, which is the "shows
     where the content came from" F10 is protecting. */
  from{ opacity:0; transform:scale(.985) }
  to  { opacity:1; transform:none }
}
/* ── THE COLLAPSE (MB154, corrected) ──────────────────────────────────────
   ⚠️ THERE IS NO EXIT KEYFRAME, AND THE ONE THAT WAS HERE WAS THE BUG. It faded
   the expanded box over 200ms and then swapped in the collapsed markup, so the
   HEIGHT never moved until the end — *"a slow drag into a snap"* (Brandon).
   A collapse is a size change, so the size is what animates: `collapseThen` in
   `crm/composer.js` repaints first and then walks the host's height, which
   leaves nothing to jump at the end. The expand keeps its keyframe because
   growing INTO a space reads as motion; shutting is about the space closing. */
@media (prefers-reduced-motion: reduce){
  .cmp:not(.is-collapsed){ animation:none }
}

/* Clean up sits FAR LEFT and `.cmp-ft-btns` takes `margin-left:auto`, so the
   two ends of the footer are the two intentions: act on the draft over here,
   commit it over there. A rewrite button beside "Log call" is one slip from
   logging something you have not read. */
.cmp-ai{ flex:none }
/* The mic and its recording label. The WRAPPER is the flex item now (the mic
   used to be), so it carries `flex:none` — without it the field's `flex:1`
   would squeeze the control. */
.cmp-mic-w{ position:relative; flex:none; display:flex; align-items:flex-end }
.cmp-mic{ flex:none }
/* ⭐ "Recording", under the mic, COSTING NO HEIGHT (2026-09-17). Absolute
   because `.cmp-line` is `align-items:flex-end` — the mic is already on the
   row's bottom edge, so anything in flow would make the composer taller, which
   is the one thing the request ruled out.
   ⚠️ `right:0` anchors it to the mic's own right edge rather than centring it:
   the mic is the rightmost thing in the row, and a centred label would hang its
   tail past the composer's padding.
   ⚠️ `pointer-events:none` — it sits over the row below it, and a status word
   must never eat a tap meant for the control underneath.
   ⚠️ The colour is `--atlas-urgent`, the same token the live mic glyph already
   uses. One red for one state, rather than a second red that means the same
   thing. */
.cmp-rec{
  position:absolute; top:100%; right:0; margin-top:2px;
  font-size:var(--atlas-fs-2xs); line-height:1;
  color:var(--atlas-urgent); white-space:nowrap;
  pointer-events:none; display:none;
}
/* ⚠️ PHONE ONLY (Brandon, 2026-10-23). The word was measured for the stacked
   composer at 390px, where the mic sits alone and the label has a lift to fit
   under. On the desktop the live mic is already urgent-red (A186) and the word
   lands on the footer's icon cluster — redundant and in the way. */
.cmp.is-stack .cmp-mic-w.is-live .cmp-rec{ display:block }
/* ⚠️⚠️ THE MIC LIFTS WHILE RECORDING, AND IT IS THE ONLY WAY THE LABEL FITS.
   MEASURED at 390px with a draft in the box: the mic's bottom and the commit
   button's top are **12px** apart, and the label needs 15 (13px of type + 2px
   of breathing). Placing it without this overlapped "Log note" by 3px — its
   descenders sitting on the button's edge.
   The two alternatives were both worse: shrinking the type below `--atlas-fs-2xs`
   invents a size the system does not have, and moving the label off the mic
   contradicts the one thing that was asked for.
   ⚠️ A TRANSFORM, SO IT COSTS NO LAYOUT — the row does not reflow, nothing below
   it moves, and the composer's height is identical live and idle (the whole
   constraint). It also reads correctly: the control rises when it goes live.
   ⚠️ PHONE ONLY (`.cmp.is-stack`). On the desktop the mic lives in the footer's
   icon cluster, where the geometry is different and this gap does not exist. */
.cmp.is-stack .cmp-mic-w{ transition:transform var(--atlas-dur-instant) var(--atlas-ease-out, ease) }
.cmp.is-stack .cmp-mic-w.is-live{ transform:translateY(-6px) }
@media (prefers-reduced-motion:reduce){ .cmp.is-stack .cmp-mic-w{ transition:none } }
/* The Aa toggle — quiet beside the mic; the OPEN state is the neutral ladder,
   the same vocabulary as every selected control (never a tint, L3). */
.cmp-fmt{ flex:none }
.cmp-fmt.is-on{ background:var(--atlas-bg-2); color:var(--atlas-ink) }
/* ⭐ THE FOOTER'S ICON CLUSTER READS AS ICONS, NOT BUTTONS (Brandon,
   2026-09-03: "they are real buttons… make them just clickable icons and move
   them closer together"). Borderless, tighter run — the phone's own ghost
   treatment brought to the footer. Hover keeps the bg-2 step (the affordance),
   the mic's live state is carried by the glyph alone (urgent + pulse — the
   ring went with the border, the phone's precedent), and the negative margins
   claw back half the footer's gap so the three read as one cluster. */
.cmp-ft :is(.cmp-mic, .cmp-fmt, .cmp-att-b){
  border-color:transparent; background:transparent;
  width:32px; padding:0;
}
.cmp-ft :is(.cmp-fmt, .cmp-att-b){ margin-left:calc(-1 * var(--atlas-s4)) }
.cmp-ft .cmp-mic.is-live{ border-color:transparent }
.cmp-ft .cmp-fmt.is-on{ background:var(--atlas-bg-2); color:var(--atlas-ink) }
/* ⚠️ A LIVE MICROPHONE IS A STATUS, SO IT IS DRAWN THE WAY STATUS IS DRAWN:
   outlined, coloured edge and glyph, transparent ground. Not a tinted fill (L3),
   not a glow (L5) — the two things every recording button in the world reaches
   for and the two this system does not have. The pulse is the same one the AI
   button uses while it works, because it means the same thing: this is running
   right now. */
/* ⚠️ URGENT red, not the accent (Brandon, 2026-08-30). Recording is a WARNING
   state — "this is capturing you" — not a brand state; the accent read as
   "feature on". Same outlined shape, different meaning, different hue. */
.cmp-mic.is-live{ border-color:var(--atlas-urgent) }
.cmp-mic.is-live svg{ color:var(--atlas-urgent); animation:aSoftPulse 1.1s ease-in-out infinite }
@media (prefers-reduced-motion:reduce){ .cmp-mic.is-live svg{ animation:none } }
@keyframes aSoftPulse{ 0%,100%{ opacity:1 } 50%{ opacity:.45 } }

/* ══ THE TEXT TOOLS ROW (A196) ═════════════════════════════════════════════
   Toggled by the Aa button in the footer; lives directly under the mode row
   (desktop) / above the field (phone). One quiet row: hairline-separated from
   what is around it, buttons on the neutral ladder — active is `bg-2` + full
   ink, the same vocabulary as a selected pill, never a tint (L3). */
.cmp-tools{
  display:flex; align-items:center; gap:var(--atlas-s4);
  padding:6px var(--atlas-s16);
  border-bottom:var(--atlas-bw) solid var(--atlas-line);
}
.cmp-rt{
  display:inline-flex; align-items:center; justify-content:center;
  width:28px; height:28px; padding:0; flex:none;
  border:0; background:none; border-radius:var(--atlas-r-sm);
  color:var(--atlas-ink-2); cursor:pointer;
}
@media (hover:hover){ .cmp-rt:hover{ background:var(--atlas-bg-2); color:var(--atlas-ink) } }
/* P41c — motion for every pointer, colour only for a fine one. */
.cmp-rt:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press))); transition:var(--atlas-press-in, none) }
.cmp-rt.is-on{ background:var(--atlas-bg-2); color:var(--atlas-ink) }
.cmp-rt-div{ width:1px; height:16px; background:var(--atlas-line-2); margin:0 var(--atlas-s4); flex:none }
/* Size + colour ride the kit's select shell at the row's own scale. */
.cmp-rt-sel{ height:28px; font-size:var(--atlas-fs-sm); flex:none; padding:0 var(--atlas-s8) }
.cmp-rt-selpop{ left:0; width:160px }
/* The colour pop is the kit's `.a-swatches` GRID — a real colour picker, not a
   list (Brandon, 2026-09-02). Width sized to break 9 swatches into 5 + 4. */
.cmp-rt-swpop{ left:0; width:162px; padding:var(--atlas-s10) }
/* The colour swatch — CONTENT colour, not UI colour: it previews what the
   words will wear, which is the one place a filled dot is honest. The
   trigger's dot defaults to INK (what uncoloured text actually renders as) —
   an empty white dot reads as broken, not as "default". */
.cmp-rt-sw{
  width:12px; height:12px; border-radius:50%; flex:none;
  border:var(--atlas-bw) solid var(--atlas-line-2); box-sizing:border-box;
}
[data-rt-color-v]{ background:var(--atlas-ink) }

/* ══ THE EMAIL FIELDS (A197) ═══════════════════════════════════════════════
   Email mode grows To / Cc / Bcc / Subject above the body — Gmail's shape:
   quiet hairline rows, borderless inputs, the row is the affordance. */
.cmp-em-r{
  display:flex; align-items:center; gap:var(--atlas-s8);
  min-height:36px; padding:2px var(--atlas-s16);
  border-bottom:var(--atlas-bw) solid var(--atlas-line);
}
.cmp-em-l{ font-size:var(--atlas-fs-sm); color:var(--atlas-ink-3); width:48px; flex:none }
.cmp-em-in{
  flex:1; min-width:0; height:28px; padding:0;
  border:0; background:none; outline:none;
  font:inherit; font-size:var(--atlas-fs-md); color:var(--atlas-ink);
}
.cmp-em-in::placeholder{ color:var(--atlas-ink-3) }
.cmp-em-cc{
  border:0; background:none; padding:2px 6px; flex:none;
  font-size:var(--atlas-fs-sm); color:var(--atlas-ink-3);
  border-radius:var(--atlas-r-sm); cursor:pointer;
}
@media (hover:hover){ .cmp-em-cc:hover{ background:var(--atlas-bg-2); color:var(--atlas-ink) } }
.cmp-em-cc:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press))); transition:var(--atlas-press-in, none) }
/* The tiny × on a revealed Cc/Bcc row — quiet until hovered, same family as
   every other `.a-x` in the kit. */
.cmp-em-x{ width:24px; height:24px; flex:none }
/* The recipient-suggestion pop anchors to its own row (A197) — inset past the
   label so the names align with the addresses they complete. */
.cmp-em-r{ position:relative }
.cmp-em-pop{ left:56px; right:auto; min-width:280px; max-width:360px }

/* ══ ATTACHMENT CHIPS (A197) ═══════════════════════════════════════════════
   Under the address rows, above the tools — each chip is outlined, neutral,
   name + size + remove. The row wraps; five PDFs is two lines, not a scroll. */
.cmp-attl{ display:flex; flex-wrap:wrap; gap:var(--atlas-s6) }
.cmp-attl:not(:empty){ padding:var(--atlas-s8) var(--atlas-s16);
  border-bottom:var(--atlas-bw) solid var(--atlas-line) }
.cmp-att{
  display:inline-flex; align-items:center; gap:var(--atlas-s6);
  max-width:260px; height:26px; padding:0 var(--atlas-s4) 0 var(--atlas-s8);
  border:var(--atlas-bw) solid var(--atlas-line-2); border-radius:var(--atlas-r-sm);
  font-size:var(--atlas-fs-sm); color:var(--atlas-ink-2);
}
.cmp-att svg{ flex:none }
.cmp-att-n{ min-width:0; overflow:hidden; text-overflow:ellipsis; white-space:nowrap;
  color:var(--atlas-ink) }
.cmp-att-s{ flex:none; color:var(--atlas-ink-3) }
.cmp-att-x{ width:20px; height:20px; flex:none }
.cmp-att-b{ flex:none }

/* ══ SKELETON ══════════════════════════════════════════════════════════════
   ⭐ THE KIT HAD NONE. The lab has documented one since Phase 1 and every
   surface that wanted a loading shape either shipped a spinner or nothing, so
   this is the asset that documentation was always describing. */
.a-skel{ background:var(--atlas-bg-2); border-radius:var(--atlas-r-xs);
  position:relative; overflow:hidden }
.a-skel::after{ content:''; position:absolute; inset:0;
  background:linear-gradient(90deg,transparent,var(--atlas-bg-3),transparent);
  transform:translateX(-100%); animation:aWave 1.5s ease-in-out infinite }
/* Staggered so a set reads as one surface filling in, not a row of strobes. */
.a-skel:nth-child(2n)::after{ animation-delay:.12s }
.a-skel:nth-child(3n)::after{ animation-delay:.24s }
@media (prefers-reduced-motion:reduce){ .a-skel::after{ animation:none; opacity:0 } }
/* K.skelList (MB109) — rows standing in for a section that is loading. */
.a-skel-list{ display:flex; flex-direction:column; gap:var(--atlas-s12); padding:var(--atlas-s12) 0 }
.a-skel-li > .a-skel{ display:block; height:0.9375rem }
/* The SAME skeleton waved in the AI gradient (A31) — one component, and
   "this is being generated" becomes readable without a badge on every row. */
.a-skel.is-ai::after{
  background:linear-gradient(90deg,transparent,var(--atlas-ai-a),var(--atlas-ai-b),transparent) }
@keyframes aWave{ from{ transform:translateX(-100%) } to{ transform:translateX(100%) } }

/* ══ WHAT THE AI FOUND ═════════════════════════════════════════════════════
   Rows inside the composer, between the draft and the footer. A hairline above
   separates them from the text without drawing a box around them — they are
   part of this draft, not an attachment to it. */
/* ⚠️ THE INSET IS s8 + s8, WHICH MAKES s16 — the footer's horizontal padding,
   so the check glyph lines up with the tools beneath it and the outcome lines
   up with the commit button. Split across the container and the row on purpose:
   the row keeps its own half, so its hover highlight sits INSET from the
   composer edge instead of bleeding into it (the same shape the palette's rows
   use). Written with no horizontal padding at all the first time, which put the
   glyph flush against the edge and pushed the outcome off the right side. */
.cmp-found{ border-top:var(--atlas-bw) solid var(--atlas-line);
  margin-top:var(--atlas-s12); padding:var(--atlas-s4) var(--atlas-s8);
  /* ⚠️ IT SCROLLS RATHER THAN GROWING WITHOUT LIMIT. A long dictation can find
     a dozen things, and a composer tall enough to hold all of them pushes its
     own commit button off the screen — the one control the whole flow exists to
     reach. Capped against the VIEWPORT, not a row count, because the thing that
     must stay reachable is measured in screen height; the second value stops it
     dominating a tall monitor. ~8 rows visible, and the hairlines make it
     obvious there is more.
     `overscroll-behavior:contain` so reaching the end does not then scroll the
     lead profile underneath it. */
  max-height:min(38vh, 300px); overflow-y:auto; overscroll-behavior:contain }
/* ⚠️ `box-sizing` IS NOT GLOBAL IN THIS KIT — it is declared per component. A
   `width:100%` row with padding and the default `content-box` is wider than its
   parent by exactly the padding, which is what ran the outcome off the edge. */
.cmp-fnd{ display:flex; align-items:center; gap:var(--atlas-s10);
  min-height:36px; padding:var(--atlas-s4) var(--atlas-s8); width:100%;
  box-sizing:border-box;
  border:0; background:none; text-align:left; font:inherit; color:var(--atlas-ink) }
.cmp-fnd + .cmp-fnd{ border-top:var(--atlas-bw) solid var(--atlas-line) }
/* ⚠️ THE ROW NO LONGER HIGHLIGHTS AS A WHOLE, because it is no longer one
   target. Three things inside it are clickable and they do different things —
   a single hover over all of them would promise one action. Each part shows its
   own affordance instead. */
.cmp-fnd-b{ cursor:pointer; border:0; background:none; padding:0;
  border-radius:var(--atlas-r-sm) }
@media (hover: hover){ .cmp-fnd-b:hover{ background:var(--atlas-bg-3); color:var(--atlas-ink) } }
.cmp-fnd-b:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press))); transition:var(--atlas-press-in, none) }
/* An editable value reads as text until you approach it — an input-looking box
   on every row would make the list a form, which it is not. */
.cmp-fnd-e{ cursor:pointer; border:0; background:none; padding:1px var(--atlas-s4);
  margin:0 calc(var(--atlas-s4) * -1); font:inherit; color:inherit; text-align:left;
  border-radius:var(--atlas-r-sm); max-width:100% }
@media (hover: hover){ .cmp-fnd-e:hover{ background:var(--atlas-bg-3) } }
.cmp-fnd-e:active{ transition:none }
button.cmp-fnd-t{ flex:1; min-width:0 }
/* The input is the same size as the text it replaced, so opening an edit moves
   nothing (P20). */
.cmp-fnd-in{ font:inherit; color:var(--atlas-ink); background:var(--atlas-bg-1);
  border:var(--atlas-bw) solid var(--atlas-accent); border-radius:var(--atlas-r-sm);
  padding:1px var(--atlas-s4); margin:0 calc(var(--atlas-s4) * -1); min-width:60px;
  outline:none; box-sizing:border-box }
/* The date trigger carries the kit's whole picker beside it; the wrapper must
   not take part in the row's layout beyond holding the popover. */
.cmp-fnd-dp{ position:relative; flex:none; display:inline-flex; align-items:center }
.cmp-fnd-dv{ position:absolute; width:1px; height:1px; padding:0; margin:-1px;
  overflow:hidden; clip:rect(0 0 0 0); white-space:nowrap; border:0 }
.cmp-fnd-dp .dp-pop{ right:0; left:auto; min-width:250px }
.cmp-fnd-b{ flex:none; display:flex; width:18px; height:18px; align-items:center;
  justify-content:center; color:var(--atlas-ink-2) }
.cmp-fnd-t{ flex:1; min-width:0; font-size:var(--atlas-fs-md); line-height:1.35 }
.cmp-fnd-d{ flex:none; font-size:var(--atlas-fs-xs); color:var(--atlas-ink-3);
  font-variant-numeric:tabular-nums; white-space:nowrap }
/* The sentence yields, the outcome does not — a long criteria value must wrap
   or ellipsise rather than push "Changed" out of the box. */
.cmp-fnd-t{ overflow-wrap:anywhere }
/* Struck through and dimmed, never removed: a row that vanishes cannot say
   "found, and not kept" — and it cannot be put back by the same click. */
.cmp-fnd.is-off .cmp-fnd-t, .cmp-fnd.is-off .cmp-fnd-now,
.cmp-fnd.is-off .cmp-fnd-k{ text-decoration:line-through; color:var(--atlas-ink-3) }
.cmp-fnd.is-off .cmp-fnd-b, .cmp-fnd.is-off .cmp-fnd-d{ color:var(--atlas-ink-3) }
/* A criteria row is one sentence: WHAT changed, what it WAS, what it IS. The
   old value keeps its strike so the pair reads without a legend. */
.cmp-fnd-k{ font-weight:var(--atlas-fw-semi) }
.cmp-fnd-was{ color:var(--atlas-ink-3); text-decoration:line-through }
.cmp-fnd-now{ color:var(--atlas-ink) }


/* ==========================================================================
   THE LANDING — shared motion for something ARRIVING on a surface.

   ⭐ PROMOTED TO THE KIT 2026-08-18 on its second consumer, per the module
   rule. Written for the deal checklist ("I want to FEEL something when I'm
   dropping a document, just like we FEEL something when pressing any button"
   — Brandon); the Documents tab needs the identical gesture, and a drop that
   feels different in two places on the same record reads as two products.

   ⚠️ TRANSFORM AND OPACITY ONLY (F9), and the constraint does real work: the
   instinct is to flash the row a colour, but the system has NO tinted grounds
   (every `-soft` token resolves to `bg-2`), so a flash would mean inventing
   one. Motion is also the truer signal — nothing about the row's MEANING
   changed at the moment of the drop, something LANDED in it.

   `atlasLand` is for the ROW: translate only, because P39 forbids scaling a
   press (it shrinks the hit box mid-click) and the row stays a target.
   `atlasCatch` is for the small things riding along — a pill, a dot, a count.
   They may scale: they are not targets, and the pointer is already released.

   Each surface keeps its own selector; only the keyframes are shared, because
   the keyframes are what would drift.
   ========================================================================== */
@keyframes atlasLand{
  0%   { transform:translateY(-3px) }
  45%  { transform:translateY(2px) }
  75%  { transform:translateY(-1px) }
  100% { transform:translateY(0) }
}
@keyframes atlasCatch{
  0%   { transform:scale(.82); opacity:0 }
  55%  { transform:scale(1.06); opacity:1 }
  100% { transform:scale(1); opacity:1 }
}

/* ══ THE CONFIRM ══════════════════════════════════════════════════════════════
   ONE MODAL, and it is the shape every confirm in Atlas takes from here —
   a co-buyer question today, a delete tomorrow (Brandon, 2026-08-18).

   Built to the locked spec rather than invented: P24 decides it is a MODAL and
   not a drawer (the page behind it does not matter; there is one decision and
   the work has replaced it), and P24 also fixes the geometry — CENTERED,
   ≤340px. It sits on `--atlas-z-confirm` (700), the rung P14 named for exactly
   this and which nothing had used.

   P22 — every edge is free, so it rounds on all four. A drawer rounds two.
   P26 — the scrim DIMS AND NEVER BLURS; the thing you are being asked about is
   usually the thing behind it.
   L3/L4/L6 — no tint, no glow, no gradient. The danger variant colours the
   COMMIT BUTTON's label, not a band across the panel: urgency belongs to the
   irreversible action, not to the room it happens in. */
/* ══ THE BREAKDOWN (2026-08-18) ═════════════════════════════════════════════
   Lifted verbatim from the deal hub's `.deal2-cm-math` on its second consumer.
   ⚠️ POSITION IS THE CONSUMER'S, NOT THE ASSET'S — the hub pins it absolutely
   top-right of a relative tab (a full-height column squeezed the form, a float
   dropped it to the bottom, and a grid row made every deduction push the page
   down); a create step stacks it. The asset owns the LOOK only, which is what
   lets both be right. */
.a-bd{
  padding:var(--atlas-s16);
  background:var(--atlas-bg-2);
  border:var(--atlas-bw) solid var(--atlas-line);
  border-radius:var(--atlas-r-md);
}
.a-bd-t{
  margin:0 0 var(--atlas-s12);
  font-size:var(--atlas-fs-2xs); font-weight:var(--atlas-fw-semi);
  letter-spacing:.06em; text-transform:uppercase; color:var(--atlas-ink-3);
}
.a-bd-l{
  display:flex; align-items:baseline; justify-content:space-between;
  gap:var(--atlas-s12); padding:var(--atlas-s4) 0;
}
.a-bd-k{ font-size:var(--atlas-fs-xs); color:var(--atlas-ink-2); min-width:0 }
.a-bd-v{
  font-size:var(--atlas-fs-sm); font-variant-numeric:tabular-nums;
  color:var(--atlas-ink); white-space:nowrap;
}
/* Weight, not size, carries the hierarchy — three type sizes in a twelve-line
   panel would read as three unrelated lists. */
.a-bd-l.is-sum{ border-top:var(--atlas-bw) solid var(--atlas-line);
  margin-top:var(--atlas-s4); padding-top:var(--atlas-s8) }
.a-bd-l.is-sum .a-bd-v{ font-weight:var(--atlas-fw-semi) }
.a-bd-l.is-sub .a-bd-k,
.a-bd-l.is-sub .a-bd-v{ color:var(--atlas-ink-3) }
.a-bd-l.is-total{
  border-top:var(--atlas-bw) solid var(--atlas-line);
  margin-top:var(--atlas-s8); padding-top:var(--atlas-s10);
}
.a-bd-l.is-total .a-bd-k{ color:var(--atlas-ink) }
.a-bd-l.is-total .a-bd-v{
  font-size:var(--atlas-fs-md); font-weight:var(--atlas-fw-bold); color:var(--atlas-money);
}
.a-bd-l.is-total.is-over .a-bd-v,
.a-bd-l.is-over .a-bd-v{ color:var(--atlas-urgent) }
.a-bd-note{
  display:flex; align-items:flex-start; gap:var(--atlas-s6);
  margin:var(--atlas-s8) 0 0;
  font-size:var(--atlas-fs-2xs); color:var(--atlas-ink-3);
}
.a-bd-note svg{ flex:none; margin-top:var(--atlas-s2) }

.cfm-wrap{
  position:fixed; inset:0; z-index:var(--atlas-z-confirm);
  display:flex; align-items:center; justify-content:center;
  padding:var(--atlas-s24);
  pointer-events:none;
}
.cfm-wrap.is-open{ pointer-events:auto }
/* ⚠️ THE SCRIM WENT OVER THE DIALOG, and it dimmed the thing it exists to make
   readable (Brandon, 2026-08-18: *"the modal dims everything including the
   modal"*). `.cfm-wrap` is `position:fixed` with a z-index, so it opens its own
   STACKING CONTEXT — and inside it the scrim is positioned with `z-index:300`
   while `.cfm` was a plain static flex item. A positioned element with a
   positive z-index paints above a non-positioned sibling regardless of DOM
   order, so the dim landed on top.

   ⭐ AND THAT IS WHY "ADD AS CO-BUYER" DID NOTHING. The scrim covering the card
   also took the CLICK — `e.target` was the scrim, which the handler reads as
   dismiss, so pressing the commit button resolved the promise FALSE. One cause,
   two symptoms, and the second one is the expensive kind: it looked like the
   feature was broken rather than like the overlay was mis-stacked.

   The scrim is reset to the base of this context and the dialog lifted one step
   above it. It is the SAME `.scrim` the drawer uses — same class, same
   `--atlas-scrim` token, same 200ms fade — confirmed rather than assumed; only
   its layer within this wrapper changes. */
.cfm-scrim{ --scrim-z: 0 }
.cfm{
  position:relative; z-index:1;
  width:100%; max-width:340px;
  background:var(--atlas-bg-1);
  border:var(--atlas-bw) solid var(--atlas-line);
  border-radius:var(--atlas-r-lg);
  box-shadow:var(--atlas-lift);
  padding:var(--atlas-s24);
  /* P43 — a modal crosses a SHORT gap, so `base`; 4px, which is P47's own
     arrival distance.
     ⚠️ NO `scale()`. It shipped as `translateY(4px) scale(.98)`, and `.98` is
     the exact value P13 records as "previously specified … since reversed" —
     P39 is "translate, never scale", and the kit's own `.a-btn:active` carries
     that reasoning three lines from here. A scale on an overlay is also the
     tell Brandon named: it is the motion nothing else in this system uses. */
  opacity:0; transform:translateY(4px);
  transition:opacity var(--atlas-dur-base) var(--atlas-ease-out),
             transform var(--atlas-dur-base) var(--atlas-ease-out);
}
.cfm-wrap.is-open .cfm{ opacity:1; transform:none }
/* The dialog takes focus on open (kit.js) so the keyboard starts inside it. That focus is a
   mechanism, not a state to show: WKWebView painted its default blue ring around the whole card
   (the caller-ID prompt, 2026-10-08). Tab still lands on the buttons, which keep their own ring. */
.cfm:focus{ outline:none }
/* Exits are faster and ease IN — you have already decided, so waiting on a
   leaving panel is dead time (P43). `fast`, and the node is removed on the same
   150ms rather than a rounder 200 that left it lingering after the paint had
   finished. */
.cfm-wrap:not(.is-open) .cfm{
  transition-duration:var(--atlas-dur-fast);
  transition-timing-function:var(--atlas-ease-in);
}
.cfm-t{
  font-size:var(--atlas-fs-lg); font-weight:var(--atlas-fw-bold);
  color:var(--atlas-ink); margin:0 0 var(--atlas-s8);
}
/* The body is the one place a sentence is EARNED — L13 bans subtext under a
   header on a surface, and this is not a surface: it is a question, and the
   sentence is what is being asked. */
.cfm-b{
  font-size:var(--atlas-fs-md); color:var(--atlas-ink-2);
  margin:0; line-height:1.5;
}
/* The quiet line under the question — what a person has to be told without it
   competing with what they are being asked. */
.cfm-f2{
  margin:var(--atlas-s10) 0 0;
  font-size:var(--atlas-fs-xs); color:var(--atlas-ink-3); line-height:1.5;
}
.cfm-f{
  display:flex; align-items:center; justify-content:flex-end; gap:var(--atlas-s8);
  margin-top:var(--atlas-s24);
  /* ⚠️ IT WRAPS (2026-10-10). Without it a row wider than the card spills out
     past the padding — it overflowed LEFT, because the row is right-aligned. */
  flex-wrap:wrap;
}
.cfm-f .a-btn{ max-width:100% }
/* Three or more actions — and every confirm on a phone — stack full width, the
   commit on top and cancel last (the DOM is cancel-first, so column-REVERSE).
   The phone half is `.a-cfm-ft`'s MB49 rule, which this dialog never had. */
.cfm-f.is-stack,
.a-phone .cfm-f{ flex-direction:column-reverse; align-items:stretch; flex-wrap:nowrap }
.cfm-f.is-stack .a-btn,
.a-phone .cfm-f .a-btn{ width:100%; justify-content:center }
@media (prefers-reduced-motion: reduce){
  .cfm{ transition:none }
}
/* ⭐ A WALKTHROUGH IS A FOURTH MODAL USE (2026-10-06 — recorded as an exception
   to P24's three): "how do I set this up" is content you read and then act on
   in ANOTHER app, so it replaces nothing and needs no page. Wider than a confirm
   because each step is a sentence, never wide enough to become a document. */
.cfm.is-wide{ max-width:440px }
.cfm-steps{
  margin:var(--atlas-s14) 0 0; padding:0; list-style:none; counter-reset:cfm-s;
  display:flex; flex-direction:column; gap:var(--atlas-s12); text-align:left;
}
.cfm-steps > li{
  counter-increment:cfm-s; display:grid; grid-template-columns:22px minmax(0,1fr); gap:var(--atlas-s10);
  font-size:var(--atlas-fs-sm); line-height:var(--atlas-lh); color:var(--atlas-ink-2);
}
/* A15 — numbered markers are allowed because this IS a sequence. Outlined,
   never a filled badge (L3). */
.cfm-steps > li::before{
  content:counter(cfm-s); width:22px; height:22px; border-radius:var(--atlas-r-full);
  border:var(--atlas-bw) solid var(--atlas-line-2); display:grid; place-items:center;
  font-size:var(--atlas-fs-2xs); font-weight:var(--atlas-fw-bold); color:var(--atlas-ink-2); line-height:1;
}
.cfm-steps b{ color:var(--atlas-ink); font-weight:var(--atlas-fw-semi) }

/* ══ THE PROGRESS STRIP (A-PROG) ════════════════════════════════════════════
   ⭐ PROMOTED OUT OF THE CREATE FLOW 2026-08-19 (Brandon: *"add the entire
   progress flow and style as a kit — this will be reused for our e-sign tool,
   listings, etc."*). It was `.wiz-prog*`, written for the deal wizard; nothing
   in it was ever about deals.

   ⚠️ THE KIT DRAWS; THE CONSUMER DECIDES. Every step arrives with four facts
   already answered — `live` (does this step exist), `open` (may they go there),
   `here` (are they on it) and `fill` (0…1). Reachability and completeness are
   POLICY and they differ per flow: a wizard gates forwards on completed work,
   a signing envelope gates on who has signed, a listing on what has been
   published. Baking any of that in here would make the second consumer fight
   the first. This file owns the LOOK (L32).

   FIVE STATES, and every one is a real thing a flow needs to say:
     • not live   — drawn, muted: a map of what is coming (A34), never a promise
     • live       — reachable, unvisited
     • locked     — drawn, muted, NOT clickable: the boundary is visible rather
                    than discovered by clicking
     • here       — the current step, full-ink label
     • done       — finished, carried forward

   ⚠️ A STEP IS A DESTINATION (N9), so a reachable one is a real `<a>` you can
   cmd-click and copy. LOCKED IS A CLASS ON THAT SAME ANCHOR, never an element
   swap — as a swap the strip could only unlock on a navigation, so finishing a
   step left the next one looking locked until you pressed Continue. A class can
   be patched; an element cannot be, without rebuilding the strip you may be
   clicking (P40). The lock is real: `pointer-events` takes the plain click AND
   the cmd-click, and `tabindex="-1"` takes it out of the tab order. */
.a-prog{ display:flex; gap:var(--atlas-s6) }
/* ── `K.meter` — a part of a whole, as a bar (2026-10-10) ─────────────────────
   The strip's track + fill (below), one bar long. Twice the strip's height: a
   step strip sits under a heading and is read as a sequence, a meter sits in a
   table row beside a pill and has to read at a glance. The fill takes the
   status family's colour by tone — the same five `.a-st` uses. */
.a-meter{
  display:inline-block; vertical-align:middle; flex:none;
  width:var(--a-meter-w, 64px); height:calc(var(--atlas-h-progress) * 2);
  border-radius:var(--atlas-r-full); background:var(--atlas-line); overflow:hidden;
  --a-meter-c:var(--atlas-accent);
}
.a-meter-f{
  display:block; height:100%; width:100%; border-radius:inherit;
  background:var(--a-meter-c);
  transform-origin:left center;
  transition:transform var(--atlas-dur-base) var(--atlas-ease-out);
}
.a-meter.is-done, .a-meter.is-closed{ --a-meter-c:var(--atlas-money) }
.a-meter.is-urgent{ --a-meter-c:var(--atlas-urgent) }
.a-meter.is-warn  { --a-meter-c:var(--atlas-warn) }
.a-meter.is-dead  { --a-meter-c:var(--atlas-ink-3) }
.a-meter.is-draft { --a-meter-c:var(--atlas-hue-3) }
.a-prog-i{ flex:1; min-width:0 }
/* ⚠️ `display:block` IS LOAD-BEARING, NOT TIDINESS. These became `<span>`s when
   the step gained an anchor, and HEIGHT DOES NOT APPLY TO AN INLINE ELEMENT —
   so the track and its fill silently vanished while the label, which already
   declared `block`, stayed exactly where it was. That asymmetry is the tell:
   half a component disappearing means the half that went is the half whose box
   the browser stopped honouring. */
.a-prog-t{
  display:block;
  height:var(--atlas-h-progress); border-radius:var(--atlas-r-full);
  background:var(--atlas-line); overflow:hidden;
}
.a-prog-f{
  display:block;
  height:100%; width:100%; border-radius:inherit;
  background:var(--atlas-accent);
  transform:scaleX(0); transform-origin:left center;
  transition:transform var(--atlas-dur-base) var(--atlas-ease-out);
}
.a-prog-l{
  display:block; margin-top:var(--atlas-s8);
  font-size:var(--atlas-fs-2xs); font-weight:var(--atlas-fw-semi);
  letter-spacing:.06em; text-transform:uppercase;
  color:var(--atlas-ink-3);
  white-space:nowrap; overflow:hidden; text-overflow:ellipsis;
}
a.a-prog-i{ text-decoration:none; cursor:pointer; border-radius:var(--atlas-r-sm) }
a.a-prog-i:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press))); transition:var(--atlas-press-in, none) }
a.a-prog-i.is-locked{ pointer-events:none; cursor:default }
/* THE LABEL CARRIES THE STATE — the track already carries the number, so the
   ink is free to say how far you may go rather than repeating how far you are. */
.a-prog-i:not(.is-live) .a-prog-l,
.a-prog-i.is-live.is-locked .a-prog-l{ color:var(--atlas-ink-3); opacity:.55 }
.a-prog-i.is-live .a-prog-l{ color:var(--atlas-ink-2) }
.a-prog-i.is-done .a-prog-l{ color:var(--atlas-ink) }
.a-prog-i.is-here .a-prog-l{ color:var(--atlas-ink) }
@media (prefers-reduced-motion: reduce){
  .a-prog-f{ transition:none }
}

/* ══ THE STRIP, ON A PHONE — ONE CONTINUOUS BAR ════════════════════════════
   Brandon, 2026-08-27: *"the progress bar should not be segmented on mobile.
   It should keep the same characteristics but should be one continuous bar,
   and instead of each section labeled — the title instead titles the section."*

   Seven `flex:1` segments at 390 gave seven truncated words —
   "PRO… BUY… TER… FIN… DIS… PAR… REVI…" — which is not a label, it is the
   shape of a label. And the strip was competing with a title ("Write an
   offer") that says the same thing on every step, so between them they used
   two rows to tell you nothing about where you are.

   ⚠️ IT IS THE SAME COMPONENT, NOT A SECOND ONE. No markup changes and no JS
   branch: the segments abut (`gap:0`), the inner radii square off so the joins
   disappear, and the labels are dropped. What you get is one continuous bar
   whose fill is still per-step accurate — a half-finished middle step reads as
   accent-then-track partway along, which is the truth, where a single averaged
   bar would have had to invent a number. `progressPaint` keeps working
   untouched, because nothing it writes moved.

   ⚠️ THE ROUNDING IS ON THE ENDS ONLY. Every track carries `r-full`, so at
   `gap:0` you get seven pills touching rather than one bar; squaring the middle
   and keeping the outer two is what makes it read as a single object. */
.a-phone .a-prog{ gap:0 }
.a-phone .a-prog-t{ border-radius:0 }
.a-phone .a-prog-i:first-child .a-prog-t{
  border-top-left-radius:var(--atlas-r-full); border-bottom-left-radius:var(--atlas-r-full);
}
.a-phone .a-prog-i:last-child .a-prog-t{
  border-top-right-radius:var(--atlas-r-full); border-bottom-right-radius:var(--atlas-r-full);
}
.a-phone .a-prog-l{ display:none }
/* A segment is not a target on a phone — the strip is a READOUT here, and the
   step name in the title says where you are. Removing the press stops a bar
   with no labels behaving like seven invisible buttons. */
.a-phone a.a-prog-i:active{ transform:none }

/* ══ THE RECORD SHELL (A-REC) ══════════════════════════════════════════════
   ⭐ PROMOTED 2026-08-19 (Brandon: *"the profile layout should already be a kit
   asset right?"*). It should have been, and the proof it was overdue is that it
   had already been COPIED: `.deal2-id` and `.lead2-id` were byte-identical —
   same six declarations, same tokens, same order — and six more rules with them.
   Not two people arriving at one answer; one file duplicated with the prefix
   swapped. `settings.css` carries a third `set2-id`, and three modules push
   their own `panelHtml()` into `atlasShellSetPanel`.

   `08-MODULES` states the trigger: *one consumer is a local function, two is an
   asset, and the gap between them is where copies get made.* The gap had
   already made them.

   ⚠️ THE OLD NAMES ARE ALIASES, NOT REPLACEMENTS — this is step one of three
   and it moves NOTHING visually. Each rule below carries `.a-rec-*` plus the
   `.deal2-*` / `.lead2-*` names that used to hold it, so both surfaces render
   byte-identically while ownership moves to the kit. The surfaces migrate off
   the aliases one at a time, with eyes on each; the lead profile is last
   because it is the biggest and it has variants (`lead2-idrow`) the others
   never had.

   ⚠️ AND KIT LOADS FIRST, which is what keeps this safe: anything a surface
   still overrides in its own file is a later rule at equal specificity and
   still wins. Promotion cannot silently take a local override away. */

/* The spine — frame, identity block, panel body, section. */
.a-rec-main,
.deal2-main,
.lead2-main{ min-width:0; min-height:0; overflow:auto }
.a-rec-slot-s,
.deal2-slot-s,
.lead2-slot-s{ margin:0; font-size:var(--atlas-fs-xs); color:var(--atlas-ink-3) }
.a-rec-cmp,
.deal2-cmp,
.lead2-cmp{ padding:var(--atlas-s12) var(--atlas-s16); border-bottom:var(--atlas-bw) solid var(--atlas-line); }
.a-rec-id,
.deal2-id,
.lead2-id{ height:var(--atlas-shoulder-h); padding:0 var(--atlas-s16); display:flex; flex-direction:column; justify-content:center; gap:var(--atlas-s4); border-bottom:var(--atlas-bw) solid var(--atlas-line); min-width:0; }
.a-rec-meta-sep,
.deal2-meta-sep,
.lead2-meta-sep{ color:var(--atlas-ink-3); flex:none }
.a-rec-pbody,
.deal2-pbody,
.lead2-pbody{ min-height:0 }
.a-rec-sec,
.deal2-sec,
.lead2-sec{ padding:var(--atlas-s16) }

/* Cards and their rows — the deal hub and the listing hub. */
.a-rec-card,
.deal2-card{ padding:var(--atlas-s16) }
.a-rec-card-hd,
.deal2-card-hd{ display:flex; align-items:baseline; gap:var(--atlas-s8); margin-bottom:var(--atlas-s10); }
.a-rec-card-t,
.deal2-card-t{ margin:0; font-size:var(--atlas-fs-xs); font-weight:var(--atlas-fw-semi); letter-spacing:var(--atlas-ls-wide); text-transform:uppercase; color:var(--atlas-ink-3); }
.a-rec-card-n,
.deal2-card-n{ font-size:var(--atlas-fs-xs); color:var(--atlas-ink-3); font-variant-numeric:tabular-nums; }
.a-rec-none,
.deal2-none{ margin:0; font-size:var(--atlas-fs-xs); color:var(--atlas-ink-3) }
/* A block of the record's OWN prose — a commission note, a description. The
   empty state above and this are different sentences: one is the app saying
   there is nothing, this is the record speaking, so it reads at body size in
   full ink. Wrapping is the point (`pre-wrap`) — somebody typed line breaks and
   meant them. */
/* A menu item that ENDS something. Two consumers (the task card's menu, the
   listing kebab), so it lives here rather than being written a second time —
   `crm/tasks.css` scoped its own copy to `.tskc-menu-pop` and that copy is now
   redundant. The colour is the only difference: the row is still a row. */
.pick-row.is-danger .pick-label{ color:var(--atlas-urgent) }

.a-rec-p,
.deal2-p{
  margin:0; white-space:pre-wrap;
  font-size:var(--atlas-fs-sm); line-height:1.55; color:var(--atlas-ink);
}
.a-rec-drow,
.deal2-drow{ display:flex; align-items:baseline; gap:var(--atlas-s8); padding:var(--atlas-s6) 0; min-width:0; }
.a-rec-dl,
.deal2-dl{ font-size:var(--atlas-fs-sm); color:var(--atlas-ink-2); white-space:nowrap; overflow:hidden; text-overflow:ellipsis; min-width:0; }
.a-rec-dv,
.deal2-dv{ flex:none; margin-left:auto; font-size:var(--atlas-fs-sm); color:var(--atlas-ink); font-variant-numeric:tabular-nums; }
.a-rec-prow,
.deal2-prow{ display:flex; align-items:baseline; gap:var(--atlas-s8); padding:var(--atlas-s6) 0; min-width:0; }
.a-rec-pmain,
.deal2-pmain{ display:flex; flex-direction:column; gap:2px; min-width:0 }
.a-rec-pn,
.deal2-pn{ font-size:var(--atlas-fs-sm); color:var(--atlas-ink); white-space:nowrap; overflow:hidden; text-overflow:ellipsis; min-width:0; }
.a-rec-pc,
.deal2-pc{ font-size:var(--atlas-fs-xs); color:var(--atlas-ink-3); white-space:nowrap; overflow:hidden; text-overflow:ellipsis; min-width:0; font-variant-numeric:tabular-nums; }
.a-rec-pr,
.deal2-pr{ flex:none; margin-left:auto; font-size:var(--atlas-fs-xs); color:var(--atlas-ink-3); }

/* ══ KEYBOARD FOCUS — ONE RULE, AND IT IS A SELECT STATE ════════════════════
   ⭐ Brandon, 2026-08-19, twice: first *"NOWHERE in our kit do our accent
   buttons have a ring"* (killing an accent ring I had added to `.a-btn`), then
   *"I'd actually prefer the way it's done like the mentions picker — it gives
   the SELECT state, not an outline."*

   So this is the mention picker's own look, promoted: the surface steps to
   `bg-2` and the label takes the accent. Both halves are already the kit's
   vocabulary for *this one is chosen* — `.pick-row.is-active` (the keyboard
   cursor in every picker, which is literally what he screenshotted) is that
   fill, and `.seg-b.is-on` is a surface step plus accent text. Focus is not a
   new look; it is the look the kit already had for the same idea.

   ⚠️ THE FILL IS NEUTRAL BECAUSE L3 FORBIDS A TINT. An accent-tinted surface
   was the obvious reading of "our accent colour", and it is the one thing this
   palette will not do — every `-soft` token in `atlas-tokens.css` was mapped
   back to the neutral ladder for exactly this reason. The accent arrives as
   INK instead, which is not a tint and is how `.is-on` already says it.

   ⚠️ IT REPLACED FOUR BESPOKE TREATMENTS rather than joining them: `.seg-b`,
   `.a-x` and `.a-add` each drew their own inset accent hairline and `.a-tb`
   its own accent border. Four spellings of one state is the inconsistency he
   was pointing at — keyboard focus looked like a different idea depending on
   which control you landed on (L22: one answer, one place).

   ⚠️ WHAT DELIBERATELY KEEPS ITS OWN, and why each is not an exception smuggled
   in: `.a-swatch` is a 22px circle whose whole body IS a fill, so a fill cannot
   say anything about it and it keeps its ring. The three TEXT FIELDS
   (`.a-search input`, `.drw-in`, `.pick-search-in`) keep their accent border —
   a background wash behind a caret and a line of text is the one place this
   look actively fights the content, and a field already announces focus with
   the caret. Pressables fill; fields outline. That is the whole split.

   ⚠️ NOTHING SUPPRESSES A RING IT DOES NOT REPLACE. `outline:none` appears only
   inside this selector list, so anything not named here — a bare link, a
   checkbox — keeps the browser's ring rather than losing focus entirely
   (WCAG 2.4.7). A blanket `:focus-visible{ outline:none }` would have been one
   character shorter and an accessibility regression.

   ⚠️ SOURCE ORDER IS LOAD-BEARING. Equal specificity with `.a-btn-g:hover` and
   `.seg-b.is-on`, so this block has to stay at the END of the file to win. */
/* ⚠️ AMENDED 2026-10-26 (A343): keyboard focus is ONE ZERO-BLUR RING, not a
   grey fill with an accent label — that was a SELECTED state wearing focus's
   name, and the seg, switch and tabs already wear the ring. */
.a-btn:focus-visible,
.a-tb:focus-visible,
.a-x:focus-visible,
.a-add:focus-visible,
.pick-row:focus-visible{
  outline:none;
  box-shadow:inset 0 0 0 1.5px var(--atlas-accent);
}
/* A CONTROL THAT ALREADY OWNS ITS BACKGROUND steps ITS OWN surface instead —
   painting `bg-2` over the primary would turn the committed action grey, which
   is not "works less well on a coloured button", it is breaking it. */
.a-btn-p:focus-visible{
  background:var(--atlas-accent); color:var(--atlas-on-accent);
  box-shadow:0 0 0 2px var(--atlas-bg-1), 0 0 0 3.5px var(--atlas-accent);   /* an accent ring inside an accent face is invisible — ring it outside, as the switch does */
}
/* The AI button's background is a gradient BORDER-box — one flat colour would
   erase the border that is the whole asset. Its own hover step, reused. */
.a-btn-ai:focus-visible{
  color:var(--atlas-ink);
  background:
    linear-gradient(var(--atlas-bg-2),var(--atlas-bg-2)) padding-box,
    linear-gradient(105deg,var(--atlas-ai-a),var(--atlas-ai-b)) border-box;
}
/* ⚠️ DESTRUCTIVE STAYS DESTRUCTIVE. Accent ink on a delete is the focus state
   quietly removing the one signal that button exists to carry. */
.a-btn-d:focus-visible,
.a-x-danger:focus-visible{ color:var(--atlas-urgent) }

/* ══ THE DRAWER BECOMES A SHEET ON A PHONE ═════════════════════════════════
   ⭐ Brandon, 2026-08-20: *"it should actually be a slide up sheet on mobile,
   not a drawer."* A side drawer is a desktop shape — it assumes horizontal room
   the phone does not have, and on a 390px screen a 400px panel is the whole
   screen anyway, entering sideways for no reason. A sheet rises from the thumb.

   ⚠️ THE ANIMATION HAS TO MOVE WITH IT. The panel slides on `transform`, so a
   sheet that still translates on X arrives from off-screen-right and lands in
   place — which reads as a bug rather than a transition. Y, and only Y.

   ⚠️⚠️ AND `font-size:16px` ON THE INPUT IS NOT A STYLE CHOICE, IT IS THE FIX FOR
   A ZOOM. iOS Safari zooms the whole viewport whenever a focused input computes
   under 16px, and `.drw-in` is 13.995px — so opening a drawer and focusing its
   field threw the page to ~3× and left the signer stranded off-screen (measured
   on a real iPhone). The alternative — `maximum-scale=1, user-scalable=no` — is
   WORSE: it would stop the zoom by taking pinch-zoom away from somebody reading
   a contract on a phone. Sizing the input correctly fixes the cause and keeps
   the gesture. */
@media (max-width: 720px), (max-height: 500px) and (pointer: coarse){
  /* ⚠️ THE SHEET GEOMETRY THAT USED TO LIVE HERE WAS A DEAD TWIN — every
     declaration (top/left/right/bottom, width, 90dvh cap, r-lg radius, the
     translateY) was re-declared and beaten on source order by the live sheet
     block at the END of this file (which says why it lives there), and
     `.drw.is-open{transform:none}` is the unconditional base rule near the top.
     Deleted 2026-09-11 (mobile-premium Phase 0) so there is ONE sheet geometry.
     ⚠️ The 16px pin below STAYS, but NOT for the old reason written here. A
     later fields declaration whose token cannot resolve does NOT fall back to
     this earlier one — CSS invalid-at-computed-value makes the property
     INHERIT (14px from the body context); the cascade is never revisited.
     That is exactly how a drawer mounted outside every token scope rendered
     14px fields and auto-zoomed the sheet the moment the viewport clamp came
     off (measured 2026-09-11, vvScale 1.1418 — the newlead sheet opened from
     /tasks falls back to document.body). The real fallback now lives IN the
     var() — a 16px default — and mountDrawer stamps `atlas-scope` on any
     drawer landing outside a scope; this plain pin is the last belt. */
  /* 16px exactly — the iOS threshold, not a token, because the number IS the
     rule and a token that later resolves to 15.9px would silently reopen this. */
  /* ⚠️ ONE CLASS, because the kit styles inputs, textareas and selects through
     `.drw-in` — the earlier list named two classes that do not exist, which is
     the silent kind of wrong (C15). */
  .drw-in{ font-size:16px }
}

/* ══ FIELDS READ AT THE APP'S SIZE ON A PHONE (Brandon, 2026-08-27) ═════════
   *"globally we made the text across the mobile app bigger… but typing inside
   the composers doesn't match. Can you make all composers, crm, huddle, etc and
   all fields match the same text sizes as the rest of the app."*

   MB48 took the phone base to 17px and every `rem` size followed — except
   fields, which were either at `fs-md` (15.9) or PINNED at exactly 16px for the
   iOS zoom threshold. So the app read at 17 and the thing you type into read at
   16, which is the one place the difference is under your eyes the whole time.

   ⚠️ THE ZOOM FIX IS NOT WEAKENED, IT IS RESTATED. iOS zooms whenever a focused
   input computes UNDER 16px; the pin's own note says the number is the rule and
   warns that a token later resolving to 15.9 would silently reopen it. `max()`
   says the rule out loud instead of asserting a literal — the value follows the
   app and can never cross the threshold, whatever the ramp does next.

   ⚠️⚠️ AND NO BOX MAY GROW (Brandon, same message: *"make sure when you raise
   the font of any composer that it DOES NOT increase the size of the composer
   or field"*). A fixed-height field is safe by construction; an auto-height one
   is not, so every line box below is pinned in PIXELS at the height it already
   had. That is Y6 read correctly — the glyphs are type, the line box is layout.
   Measured before: `.a-field-in` 15.861px/22.998px in a 35px box. */
@media (max-width: 720px), (max-height: 500px) and (pointer: coarse){
  /* ⚠️⚠️ `!important`, AND IT IS EARNED — THE PIN WAS BEATEN BY SOURCE ORDER FOR
     AS LONG AS IT HAS EXISTED (Brandon, 2026-09-12: the Search-criteria notes
     box "pushed everything up, zooms in, and everything now flows off screen and
     it breaks the entire app"). A surface class on the SAME element is (0,1,0),
     identical to `.drw-in`, and every surface stylesheet loads AFTER the kit —
     so `.sc2-area{font-size:var(--atlas-fs-sm)}` simply won, computed ~13px, and
     iOS auto-zoomed on focus. Zoomed, `position:fixed` lays out against the
     un-zoomed layout viewport, so the sheet shifts, the title lands over the
     Dynamic Island and content runs off screen — which reads as the app breaking
     rather than as a font-size.
     Measured: FOUR live offenders, all of them `.drw-in` wearing a surface class
     (`.sc2-in`, `.sc2-area`, `.sed2-in`, and `.sc2-f .dp .drw-in` — the last at
     (0,3,0), which even `input.drw-in` would not beat).
     **A field under 16px on iOS is a correctness bug with NO legitimate
     exception**, which is precisely the case `!important` is for: it is a floor,
     not a taste. It is scoped to the phone query, so desktop keeps its 13px. */
  .drw-in,
  .cfm-form .drw-in,
  .pop input,
  .a-field-in{ font-size:max(16px, var(--atlas-fs-base, 16px)) !important }
  /* Two more zoom traps the 2026-09-12 runtime audit caught once the clamp
     was gone (MB122a): the capture input computed 14.7px (fs-sm) and the
     kit search field 15.9 — both under iOS's 16px auto-zoom line. Same pin,
     same fallback discipline (trap 60: a var() that must survive scope-less
     contexts carries its own default). */
  .a-capture-in{ font-size:max(16px, var(--atlas-fs-sm, 16px)) !important }
  .a-search input{ font-size:max(16px, var(--atlas-fs-base, 16px)) !important }

  /* 23px = the line box it already had (22.998 rounded). Pinned, so the
     composer's resting height stays 35px and every grown line stays 23. */
  .a-field-in{ line-height:23px }

  /* ⚠️⚠️ THE MIRROR MOVES WITH THE FIELD OR THE MENTIONS COME UNSTUCK. The
     composer is a TRANSPARENT textarea over a highlight layer, and the chips
     line up only while both boxes have identical metrics — a single pixel of
     divergence in size or leading and every `@name` sits beside the word it is
     meant to be on. The kit's base rule declares the two TOGETHER for exactly
     that reason, and this keeps them together: a first pass here moved the
     mirror alone, which is the bug its own comment was warning about.
     24.8px is 16 × 1.55 — the line box these already had. */
  .a-ment-mirror,
  .a-ment .a-ment-in{ font-size:max(16px, var(--atlas-fs-base, 16px)); line-height:24.8px }

  /* A textarea in a drawer is `height:auto` with `line-height:1.55`, so it is
     the other box that would have grown. 24.8px is 16 × 1.55 — what it was. */
  textarea.drw-in{ line-height:24.8px }

  /* ⭐ THE PICKER SHEET'S INSET LIVES HERE, not on `.pop` — see the note in the
     `.pop` phone block. The list runs to the physical edge and this lets its
     LAST ROW scroll clear of the home indicator, which is the drawer's
     `.drw-b` rule exactly. */
  .pop:not(.a-pop-anchored) .pop-scroll{ padding-bottom:var(--atlas-safe-b) }
}

/* ⚠️ AND THE GREY FLASH HAS TO GO, or it competes with the press. iOS paints its
   own translucent rectangle over anything it decides is tappable, which arrives
   at a different moment and a different shape from our own `translateY` — two
   answers to one tap. Ours is the one that matches the rest of the system.
   ⚠️ Scoped to what is actually pressable: killing it globally would take the
   highlight off links inside prose, where it is the only feedback there is. */
.a-btn, .a-x, .a-tb, .pick-row, .seg-b, .sel-ctl, .a-prog-i,
.drw-ft button, [role="button"]{
  -webkit-tap-highlight-color:transparent;
}

/* ⭐ A CONFIRMATION THAT IS ALSO A LAST EDIT. Sits between the question and the
   actions, so the question stays the loudest thing in the box (B11) and the
   fields read as what you are about to send rather than as a form to fill in. */
.cfm-form{
  display:flex; flex-direction:column; gap:var(--atlas-s10);
  margin:var(--atlas-s14) 0 var(--atlas-s4);
  text-align:left;
}
.cfm-form .drw-l{ margin-bottom:var(--atlas-s4) }
/* A yes/no the confirm also asks — the bar's Enroll: "Also move the 12".
   A5: the whole label is the hit target, not the 16px box. */
.cfm-form .a-check{ display:flex; align-items:flex-start; gap:var(--atlas-s8); font-size:var(--atlas-fs-sm); color:var(--atlas-ink); line-height:1.4; cursor:pointer }
.cfm-form .a-check input{ flex:none; width:16px; height:16px; margin:2px 0 0; accent-color:var(--atlas-accent); cursor:pointer }
/* ⚠️ 16px on a phone, the same iOS zoom threshold the drawer's fields obey —
   a confirmation is exactly where a viewport lurch is least welcome. */
@media (max-width: 720px), (max-height: 500px) and (pointer: coarse){
  /* ⚠️ `.drw-in` COVERS THE TEXTAREA TOO — `textarea.drw-in` is the kit's
     multiline field. An earlier version listed a `.drw-ta` that does not exist. */
  .cfm-form .drw-in{ font-size:16px }
}

/* ══ SOURCE BADGE ═════════════════════════════════════════════════════════
   The portal a lead arrived from, as its own mark. Ported off the live app's
   glossy version — the drop shadow, the two inset highlights and the specular
   radial-gradient are all gone (L4 · L6 · B1). What separates the disc from
   the surface now is a hairline, not light.

   ⚠️ THE RING IS INSET, NOT A BORDER. A border would grow the box and shift
   every row it sits in by 2px; an inset ring is drawn inside the same
   footprint, which is the same reason focus rings are drawn this way (K6). */
.a-srcb{
  flex:0 0 auto;
  display:inline-flex; align-items:center; justify-content:center;
  border-radius:var(--atlas-r-full);
  overflow:hidden;
  box-shadow:inset 0 0 0 var(--atlas-bw) var(--atlas-line-2);
  vertical-align:middle;
  /* ⚠️ OPTICALLY LIFTED, NOT MATHEMATICALLY CENTRED (Brandon, 2026-08-21). Beside
     a name the badge is a disc next to lowercase letters, and a disc centred on
     the line box reads as sitting slightly LOW — its mass is even while the text
     beside it is weighted toward the x-height. A couple of pixels up puts it
     where the eye expects. The live app did the same thing with `top:-1px` on a
     wrapper span; this is the same correction, on the badge, so both surfaces
     inherit it rather than each remembering.

     ⚠️ `top`, NOT `translateY`. The linked variant presses with
     `transform: translateY(var(--atlas-press))`, and a transform here would be
     overwritten by it — the badge would jump DOWN by the whole lift on click. */
  position:relative;
  /* Scaled with the badge — a fixed 1.5px is the right correction at 15px
     and too little at 19, so the lift would visibly drift as text grows. */
  top:calc(-1.5px * var(--atlas-text-scale, 1));
}
/* ⚠️ CONTAIN, NOT COVER. The marks are now glyph-on-transparent with their own
   breathing room baked into the 192px canvas, so cover-cropping would cut the
   glyph's edges off — which is exactly what happened to the wordmark. */
.a-srcb img{
  width:100%; height:100%;
  object-fit:contain;
  display:block;
}
/* Only the LINKED badge is interactive — an unlinked one is a label, and a
   pointer on something that does nothing is a lie (C1). */
.a-srcb.is-link{ cursor:pointer; transition:filter var(--atlas-dur-instant) }
@media (hover: hover){ .a-srcb.is-link:hover{ filter:brightness(1.08) } }
.a-srcb.is-link:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press))); transition:var(--atlas-press-in, none) }
/* ⚠️ THE SAME DOUBLE-RING THE SWATCH USES, not an outline. A round control
   whose outline follows its own radius needs the ring drawn as geometry, and
   both stops are ZERO BLUR — L4 allows that precisely because it is geometry
   and not light. (My first pass invented --atlas-focus / --atlas-focus-w,
   neither of which exists; a token that does not resolve fails silently and
   the ring simply never appears — C43.) */
.a-srcb.is-link:focus-visible{
  outline:none;
  box-shadow:0 0 0 2px var(--atlas-bg-1), 0 0 0 3.5px var(--atlas-accent);
}

/* ═══ THE DRAWER IS A BOTTOM SHEET ON A PHONE (MB6) ═════════════════════════
   ⭐ ONE PRIMITIVE, NOT TWO. Same markup, same `drawer()`, same open/close,
   same `is-open` class — only the GEOMETRY re-points. A second component would
   be C12 (two things solving one job) and would drift the moment either was
   touched; the whole reason the kit owns a drawer is that eight surfaces stopped
   writing their own.

   ⚠️ AT THE END OF THE FILE ON PURPOSE. These rules are the same specificity as
   the base `.drw` / `.drw-ft` ones, so SOURCE ORDER is what decides them.
   Placed beside the drawer block they would lose to every `.drw-*` rule written
   after them — which is the failure that reads as "the media query isn't
   firing" while it is firing perfectly.

   WHAT CHANGES, and each is P22's free-edge argument re-run for a new edge:
   flush to the BOTTOM, so it rounds its TOP two corners only, takes a TOP
   border only, and throws its shadow upward. A sheet that rounds all four
   corners is a card that happens to be near the bottom. */
@media (max-width: 720px), (max-height: 500px) and (pointer: coarse) {

  .drw{
    top:auto; left:0; right:0; bottom:0;
    width:auto; max-width:none;
    /* THE SHEET DECLARES THAT IT RIDES THE KEYBOARD (--kb-rides). The keyboard
       primitive must know whether a scroller's surface already compensates by
       CSS (this block's bottom/max-height) before padding the scroller too —
       double compensation crushed the newlead body to its padding and slid it
       under the transparent footer (2026-09-11, measured: inline
       padding-bottom 351px inside a 272px grid track). A custom property is
       the one signal that never animates, and it lives INSIDE the media query
       so it is true exactly when the compensation is — an iPad at 820px gets
       neither, and the padding there is still correct. */
    --kb-rides:1;
    /* THE PARTIAL DETENT IS A CAP, NOT A HEIGHT. The sheet is as tall as its
       content up to this — a three-row picker that opens to 60% of the screen
       is a sheet that ignored what is in it. `is-full` raises the cap for the
       surfaces that need the room (composer, wizard). */
    height:auto; max-height:var(--atlas-sheet-partial-max);
    border-left:0;
    border-top:var(--atlas-bw) solid var(--atlas-line);
    border-radius:var(--atlas-sheet-r) var(--atlas-sheet-r) 0 0;
    /* THE HANDLE ROW IS THE GRID'S, NOT AN EXTRA ELEMENT. Adding a real node
       would change `grid-template-rows` for every drawer on every viewport and
       need a display:none that silently re-slots the body out of its `1fr`.
       A ::before costs no markup and cannot reach the desktop. */
    padding-top:var(--atlas-s12);
    transform:translateY(100%);
  }
  .drw.is-full{ max-height:var(--atlas-sheet-full) }
  /* `tall` (2026-11-03, the offer sheet): a FULL sheet whose content arrives AFTER it
     opens. `.drw` is content-height capped (12-SHEETS), so a skeleton body opened the
     sheet short and the real rows then shoved it to full — two moves for one tap.
     Declared at the open call like the detent; the keyboard's max-height still wins
     (max-height caps height), so a tall sheet rides the keys exactly as before. */
  .drw.is-full.is-tall{ height:var(--atlas-sheet-full) }

  /* ══ THE COMMIT IS ONE FULL-WIDTH BUTTON, AND THE × IS THE CANCEL ═════════
     Brandon: *"every mobile drawer that has an action button at the bottom — we
     need to make the action button full width and remove the cancel button.
     Every drawer should have an x at the top right of the sheet to close out."*

     The × already exists — `drawer()` has always put one in `.drw-hd`. What was
     wrong is the footer: two buttons sharing a row, the commit sized to its own
     label and sitting in the corner, and a Cancel duplicating a control four
     inches above it. On a phone the commit is the reason the sheet is open, so
     it gets the width; leaving is what the × and the scrim are for.

     ⚠️⚠️ `data-drw-close` IS NOT "CANCEL" — IT IS ALSO THE COMMIT ON SOME
     DRAWERS. Search criteria and the roles editor both finish with
     `<button class="a-btn a-btn-p" data-drw-close="…">Done</button>`, because
     their work is already saved and closing IS the commit. A rule hiding
     `[data-drw-close]` would delete the only button on those two. So the test
     is the GHOST class as well: `a-btn-g` + closes = a cancel. */
  .a-phone .drw-ft{
    display:grid; grid-auto-flow:row; gap:var(--atlas-s8);
    padding-bottom:max(var(--atlas-s12), var(--atlas-safe-b));
    transition:padding-bottom var(--atlas-kb-dur) var(--atlas-kb-ease);
  }
  /* ⚠️ THE SAFE AREA IS DEAD SPACE ONCE THE KEYBOARD IS UP (Brandon, 2026-08-27:
     *"too much white space between the action button and the keyboard when the
     keyboard rises"*). `--a-kb-h` is measured to the bottom of the SCREEN, so
     the sheet is already lifted past the home indicator and this padding is
     clearance for nothing — 24px of dead band under every commit button.
     The composer's rule in keyboard.css says the same thing for the same reason.

     ⚠️ BOTH CLASSES ON THE SAME ELEMENT. `.a-phone` and `.a-kb-open` are BOTH
     set on <html>, so `html.a-kb-open .a-phone` asks for a descendant carrying
     `.a-phone` and matches nothing. Written that way first, and caught by
     measuring the computed padding (still 24px) rather than by reading it.
     It also has to out-specify `.a-phone .drw-ft` above, which (0,3,1) does. */
  html.a-kb-open.a-phone .drw-ft{ padding-bottom:var(--atlas-s12) }
  .a-phone .drw-ft > .a-btn{ width:100% }
  .a-phone .drw-ft > .a-btn-g[data-drw-close]{ display:none }
  /* The spacer exists to push two buttons apart in a row; in a column it is an
     empty grid track. */
  .a-phone .drw-ft > .drw-sp{ display:none }
  /* ⚠️ AND IF HIDING THE CANCEL LEFT NOTHING, THE BAND GOES TOO. `:empty` cannot
     see this — the node is still there, just not displayed — so the footer would
     paint its border and padding as the grey strip the `:empty` rule below
     exists to prevent. Same bug, one layer along. */
  .a-phone .drw-ft:not(:has(> .a-btn:not(.a-btn-g[data-drw-close]))){ display:none }
  .drw.is-open{ transform:none }

  /* ⭐ THE SHEET SITS ON TOP OF THE KEYBOARD (MB30). The standard everywhere —
     Mail, Messages, Safari's own sheets — is that the COMMIT ROW stays visible:
     the reason you focused the field is to then commit, and a footer behind the
     keyboard is the one control you are guaranteed to want next.

     ⚠️ ATLAS DID NOT DO THIS, AND THE COMMENT THAT SAID IT DID WAS WRONG.
     `showPage` documents a per-page switch — Huddle overlays, everything else
     reflows — but `atlasSetKbResize` has exactly ONE call site and it sets
     `'none'` unconditionally. The keyboard overlays everywhere, so a
     bottom-anchored footer was simply underneath it.

     ⚠️ AND WE DO NOT FIX IT BY SWITCHING RESIZE MODES. That setting is global,
     it fights the overlay behaviour Huddle depends on (MB8), and iOS and
     Android animate the reflow differently — so the fix would be a different
     bug on each platform. `--a-kb-h` is the compensation the keyboard primitive
     already computes per platform (0 on Android, which reflows for real), which
     makes this two declarations instead of a mode war.

     ⚠️ THE MAX-HEIGHT MUST SHRINK BY THE SAME AMOUNT or a tall sheet lifted by
     300px simply runs off the top of the screen — it is `.drw-b` that has to
     give, and it can only give if the sheet is told it has less room. */
  /* ⚠️⚠️ THE BROWSER'S BAR NEEDS NO COMPENSATION AT ALL, AND THIS BLOCK USED TO
     SAY THE OPPOSITE (removed 2026-09-17, MEASURED on Brandon's phone in Chrome
     — see `surfaces/sign.md`). A232 subtracted `--atlas-chrome-b` here on the
     reasoning that `bottom:0` walks into the band once a scroll minimises the
     bar. It does not: a fixed element TRACKS THE VISUAL VIEWPORT in both states
     — `rect.bottom` 660 with the bar shown and 736 with it minimised, both
     exactly on the bar's top edge. The subtraction was the only thing putting a
     76px dead strip under the sheet.

     ⚠️ It also stopped this max-height changing at all — `64dvh - chrome-b` was
     660 in BOTH states by arithmetic accident. Now it is plain `64dvh`, so the
     sheet grows into the space a minimised bar frees, which is what Brandon
     asked for: *"id like for the constant footer to move down with the google
     chrome footer."*

     ⚠️ THE KEYBOARD TERM STAYS AND IS A DIFFERENT THING. A keyboard genuinely
     overlays the webview and nothing tracks it for us; the browser bar is the
     UA's own chrome and the UA already accounts for it. One is an obstruction we
     must model, the other is one we must not. */
  /* ⚠️⚠️ A CLOSED DRAWER MUST NOT RIDE THE KEYBOARD (MB138b, Brandon
     2026-09-12: *"i found the sheet that was showing underneath the task sheet
     — its the link a showing sheet. when i open it and close it before clicking
     the task sheet, it will show underneath"*).

     `closeDrawer` removes `is-open` and LEAVES THE NODE IN THE DOM — deliberate,
     and the showings register depends on it. A closed sheet is parked off-screen
     by `translateY(100%)`, which clears the viewport only while its bottom edge
     IS the viewport's. Raise `bottom` to the keyboard height and that stops
     being true: measured, a 172px closed sheet at `bottom:335px` translated down
     by its own height lands in the band 163–335px above the bottom edge — wholly
     inside the keyboard, and iOS 26's translucent keys show it straight through.
     It reads as a second sheet behind the keyboard because it IS one.

     The ride belongs to the sheet the keyboard was raised FOR. Scoping it here
     rather than adding `visibility:hidden` keeps the close animation intact: a
     sheet dismissed while the keyboard is up transitions `bottom` downward, the
     same direction it is already travelling. */
  .drw:not(.is-open){ bottom:0 }
  .drw{
    bottom:var(--a-kb-h, 0px);
    max-height:calc(var(--atlas-sheet-partial-max)
                    - var(--a-kb-h, 0px));
    /* ⚠️ THE GROUND BEHIND THE KEYBOARD IS A ZERO-BLUR SHADOW SLAB, NOT A
       PSEUDO (2026-09-11). The 08-30 `::after` underlay died silently when the
       09-04 WebKit fix gave `.drw` overflow:hidden — a positioned pseudo at
       top:100% is outside the box, so iOS 26's translucent keys sampled the
       PAGE behind the sheet (a red badge read straight through the keyboard)
       and the keyboard's rounded corners cut holes beside the squared footer.
       A box-shadow paints OUTSIDE overflow clipping by definition; zero blur
       makes it geometry, not glow (the same allowance as inset focus rings).
       Offset = the keyboard height, so it is inert at rest and always reaches
       the physical bottom edge mid-animation (the slab hangs off the sheet's
       CURRENT bottom, which never rises above the keyboard line). */
    /* ⚠️⚠️ HALF OFFSET, HALF SPREAD — NOT A PLAIN OFFSET (MB138, Brandon
       2026-09-12: *"the gap in the keyboard corners goes against our kit… it
       should fill white all the way down"* and *"theres another sheet you can
       see behind the keyboard"* — ONE cause, two symptoms).

       A box-shadow is the element's SILHOUETTE displaced, so `0 var(--a-kb-h)`
       draws the sheet's shape `--a-kb-h` BELOW itself — which only reaches back
       to the sheet's own bottom edge when the sheet is at least as tall as the
       keyboard. Measured on the New-task sheet: **172px tall against a 335px
       keyboard**, so the slab started 163px below the sheet and the page showed
       through the band between them, and the "corners" are the slab's own 16px
       top radius arriving mid-keyboard.
       ⚠️ I FIRST READ THE SECOND SYMPTOM AS THIS SAME CAUSE — "the page seen
       through the translucent keys" — and it was not: Brandon found it (*"its
       the link a showing sheet"*). A closed drawer riding the keyboard is its
       own bug, fixed above. Two symptoms, two causes; the tidy single
       explanation was the wrong one, and only the reproduction distinguished
       them.

       Splitting it fixes the geometry parametrically: a spread of h/2 grows the
       silhouette h/2 in EVERY direction, then an offset of h/2 moves it down —
       so the top edge lands exactly on the sheet's top (−h/2 +h/2 = 0) and the
       bottom lands a full h below it, whatever the sheet's height. The sides
       poke out h/2 and are off-screen on a full-width sheet; the top region is
       behind the opaque sheet; and per spec a spread leaves a 0 radius at 0, so
       the slab's BOTTOM corners stay square and it fills to the edges. */
    box-shadow:var(--atlas-lift), 0 calc(var(--a-kb-h, 0px) / 2) 0 calc(var(--a-kb-h, 0px) / 2) var(--atlas-bg-1);
    /* ⚠️ THE TRANSFORM KEEPS ITS OWN DURATION — `--atlas-dur-slow`, the value the
       base `.drw` rule already uses, because that is the sheet OPENING and
       re-timing it here would silently change how every drawer in the app
       arrives. The keyboard adjustment is a different motion and takes
       `--atlas-dur-fast`: it has to look like it is tracking the keyboard,
       which is quick, not like a second sheet animation. */
    /* ⚠️ THE KEYBOARD'S OWN TIMING, NOT A UI TIMING (Brandon, 2026-08-27:
       *"the keyboards in the drawers when focused dont animate up quick enough
       so it feels like it drags along"*). `--atlas-dur-fast` is 150ms with the
       kit's ease-out; the iOS keyboard takes ~250ms on a curve of its own. Two
       different motions starting together and finishing 100ms apart is exactly
       what "drags along" describes — the sheet arrives, then the keyboard keeps
       coming, and the gap between them opens and closes. Matching the keyboard
       makes them one movement. Capacitor's `keyboardWillShow` does not report
       the duration, so these are UIKit's constants, named as tokens rather than
       buried here. */
    transition:transform var(--atlas-dur-slow) var(--atlas-ease-out),
               bottom var(--atlas-kb-dur) var(--atlas-kb-ease),
               max-height var(--atlas-kb-dur) var(--atlas-kb-ease);
  }
  /* ⚠️ THE LIFT DROPS WHILE THE KEYBOARD IS UP (Brandon, 2026-09-11: "a clear
     line under the footer that makes the gaps in the corners visible").
     Shadows paint in list order, first on top — so the lift's `0 1px 2px` dark
     component drew ON the white slab, a hairline under the sheet's edge that
     the keyboard's rounded corners put on display. A sheet SITTING ON the
     keyboard is not floating; it casts no shadow. */
  html.a-kb-open .drw{
    box-shadow:0 calc(var(--a-kb-h, 0px) / 2) 0 calc(var(--a-kb-h, 0px) / 2) var(--atlas-bg-1);
    /* ⭐ THE KEYBOARD ESCALATES THE CAP (1-C, 2026-09-12). A medium sheet is
       64dvh; a keyboard is ~335px. 64dvh minus the keys leaves ~26dvh of
       body — a crushed form — and iOS's own sheets GROW when the keyboard
       appears rather than shrinking around it. While the keys are up every
       sheet reads the FULL cap (minus the keys, the MB30 ride unchanged);
       when they drop, a medium sheet settles back to medium on the same
       max-height transition the keyboard-follow already owns. (0,2,1) beats
       both the base phone rule and `.drw.is-full`, which computes the same
       value here anyway. */
    max-height:calc(var(--atlas-sheet-full)
                    - var(--a-kb-h, 0px));
  }
  .drw.is-full{
    max-height:calc(var(--atlas-sheet-full)
                    - var(--a-kb-h, 0px));
  }

  /* THE GRAB HANDLE — the affordance that says this can be dragged. Without it
     a bottom sheet reads as a modal that happens to be at the bottom, and
     nobody discovers the drag. */
  .drw::before{
    content:'';
    position:absolute; top:var(--atlas-s6); left:50%;
    width:36px; height:4px; margin-left:-18px;
    border-radius:var(--atlas-r-full);
    background:var(--atlas-line-2, var(--atlas-line));
  }

  /* WHILE DRAGGING, THE TRANSITION IS OFF. A transition on transform makes the
     sheet lag the finger by its duration, which is the single clearest "this is
     a web page" tell in a native shell — the sheet must be UNDER the thumb, not
     chasing it. */
  .drw.is-drag{ transition:none }

  /* MB18 — THE BACKGROUND CROSSES THE INSET, THE CONTENT DOES NOT. The sheet's
     box runs to `bottom:0` so the ground reaches the physical edge; its FOOTER
     carries the inset as padding so the commit button clears the home indicator
     and the gesture bar. Padded, never positioned. */
  .drw-ft{ padding-bottom:calc(var(--atlas-s12) + var(--atlas-safe-b)) }
  /* A sheet with no footer still has to keep its last row off the gesture bar. */
  .drw-b{ padding-bottom:calc(var(--atlas-s16) + var(--atlas-safe-b)) }
  .drw:has(.drw-ft:not(:empty)) .drw-b{ padding-bottom:var(--atlas-s16) }

  /* The header's close is a 44px target on touch (MB1's ladder gives the
     button its height; this is the row it sits in). */
  .drw-hd{ padding:var(--atlas-s12) var(--atlas-s16) }
}

/* ══ THE COMPOSER ON A PHONE (MB33) ════════════════════════════════════════
   ⭐ SIMPLIFIED, NOT REBUILT. Every BEHAVIOUR is the desktop composer's — the
   same `.a-ment` mirrored field, the same `K.aiBtn` state machine, the same
   `atlasDictate`, the same commit path, literally the same `footerHtml()`. That
   is what makes dictation and the AI clean-up work here by construction rather
   than by a second wiring. Only the CHROME differs.

   ⚠️ THE FOOTER WAS THE PROBLEM (Brandon: *"those buttons are ugly and look
   like desktop"*), and it was three separate desktop assumptions stacked:
     · TWO BORDERED ICON BUTTONS. The mic and the AI action each wear a full
       button shell because on a desktop they sit in a row of them. On a phone
       they are the only two things left of a toolbar, and two outlined boxes
       beside a filled commit reads as three competing controls rather than one
       action with two helpers. They go GHOST — the glyph is the control (A23),
       which is the same argument that took the box off the card's call/text.
     · A CANCEL BUTTON. It exists on a desktop because a composer sits in a page
       you can click out of and a keyboard user needs an escape. On a phone the
       collapse chevron is right there and the draft SURVIVES it (A39b), so
       Cancel is a third button offering to throw away work the other exit
       keeps.
     · SMALL TEXT. `--atlas-fs-sm` on the commit is a desktop toolbar size; the
       one button that commits should read at body size. */
/* (Superseded 2026-08-30: the sticky-in-the-scroller arrangement this used to
   describe — MB92's "the log passes underneath" — is retired; the composer is
   the last child of the HEAD and the log starts below it. Next block.) */
/* ⚠️⚠️ IN THE HEAD, NOT STICKY IN THE SCROLLER (MB93 revised, 2026-08-30). It
   was `position:sticky; z-index:1` inside the pane, then `z-index:0` for a day
   — and the z-index was the wrong lever both times. At 1 the composer's
   context out-ranked the head's and painted over a picker sheet's scrim (and
   its rows); at 0 the timeline's `position:relative` rows, later in the DOM,
   painted over the composer, and the composer's own mode select — a fixed
   `.pop` trapped inside the composer's context — went under the log. One
   element cannot be both above the sheet the head opens and above the rows
   the pane scrolls when it lives in the pane. Brandon's call settles it: the
   log CUTS OFF at the composer's bottom edge, so the composer is the last
   child of `.lead2-ph-top` (the deal hub's arrangement, MB54) and the pane
   begins beneath it. No `position`, no `z-index` — it ranks inside the head's
   one context, whose z1 is above the whole pane. `padding-bottom` is the gap
   the feed used to carry (`.lead2-ph-cmp + .lead2-feed{ margin-top }`), moved
   to the side that owns it now. */
.ash-shell.is-phone .lead2-ph-cmp{
  padding:0 0 var(--atlas-s12);
}
/* ⭐ THE LIFT IS WHAT THE HAIRLINE USED TO SAY, said properly. A line between
   two regions claims they are siblings; a lifted card over a scrolling log says
   the composer is ON TOP of it, which is now literally true. `--atlas-lift` is
   the card token (P12) — the composer is an earned card by F12's test: it is a
   distinct object that floats over other content, not a panel drawn on the
   sheet. */
.ash-shell.is-phone .lead2-ph-cmp .cmp{
  border-radius:var(--atlas-r-lg);
  /* ⚠️ `-ctl`, NOT `--atlas-lift` — AND THAT IS WHY IT READ AS A CUTOFF
     (Brandon, 2026-08-28: *"there still be a cutoff point before the composer
     instead of timeline activities literally flowing behind it"*).

     The content WAS flowing behind it — measured, a row scrolled from y=278 to
     y=18 while the composer held at 206. What was missing is the only thing
     that tells a person so. `--atlas-lift`'s working layer is
     `0 12px 26px -18px`, and an 18px NEGATIVE spread all but erases it on a
     60px card — P12 names this exactly ("the card value physically cannot
     render below ~36px … raised controls use `-ctl`"). With no shadow the
     card's bottom edge slices a row cleanly in half, which reads as a clipping
     bug rather than as one thing in front of another.

     `--atlas-lift-ctl` (`0 2px 5px -1px`) is the token built for this scale: a
     small raised control, which is what a composer floating over a log is. */
  box-shadow:var(--atlas-lift-ctl);
  /* ⚠️ THE CARD KEEPS ITS OWN BORDER, AND THAT BORDER IS THE BOUNDARY
     (Brandon, 2026-08-28: *"yes the composers own border should be the
     slice"*). I removed it first, reading the slice as the fault — wrong: the
     fault was the REGION hairline on `.lead2-ph-top`, which drew a second line
     across the full width and made the surface look divided into two panels.
     With that gone, the composer's own edge is the only line left, and it is
     the correct one: it belongs to the card, it stops where the card stops, and
     the lift behind it says the log continues underneath.
     Stripping it as well left a white card on a white sheet held up by nothing
     but a 13%-alpha shadow — less legible, not more. */
}
/* The air the wrapper gave up. On the feed, so it scrolls. */
/* (The `.lead2-ph-cmp + .lead2-feed{ margin-top }` gap rule that stood here is
   gone with the sticky arrangement — the composer is in the head now and
   carries the gap as its own padding-bottom; see the block above.) */
.ash-shell.is-phone .cmp-ft{ border-top:0 }
/* THE TOOLS ROW ON A PHONE (A196) — the same row, anchored above the field
   (there is no pills row on this layout). It SCROLLS sideways rather than
   wrapping: a wrapped format bar is two rows spent on a control you opened for
   one tap, and sideways scroll is what every phone format bar does. 32px
   targets, scrollbar hidden — the half-visible last button says there is more. */
.ash-shell.is-phone .cmp-tools{
  overflow-x:auto; -webkit-overflow-scrolling:touch; scrollbar-width:none;
  padding:6px var(--atlas-s12);
}
.ash-shell.is-phone .cmp-tools::-webkit-scrollbar{ display:none }
.ash-shell.is-phone .cmp-rt{ width:32px; height:32px }
.ash-shell.is-phone .cmp-rt-sel{ height:32px }
.ash-shell.is-phone .cmp-em-r{ padding:2px var(--atlas-s12) }
/* ⭐ ON THE PHONE A LABEL IS ITS OWN WIDTH, WITH THE SAME GAP ON EVERY LINE
   (Brandon, 2026-10-08: *"the cursor starts on the subject line, you type in the
   label. and the space between 'to' and the email is too much … make sure every
   line is consistent"*). The 48px column was a PX box around REM text: at the
   phone's type size "Subject" measured 53px — overflowing into the field — while
   "To" (16px) got a 40px gap. No single column can fix both (it must be as wide
   as the longest label), so the phone does what Apple Mail does: natural-width
   labels, one consistent gap. The desktop keeps its aligned column, where the
   labels fit. */
.ash-shell.is-phone .cmp-em-l{ width:auto }
/* ⚠️ THE COMMIT SHRINKS AND ITS TARGET DOES NOT — which is the pattern the
   token block already describes for exactly this case: *"inflating every small
   control to 44 would destroy the density this app is FOR … dense controls keep
   their visual size and EXTEND their target with a transparent ::before."*
   `--atlas-h-btn-sm` re-points to 44 on a phone (*"a button is a button"*),
   and inside a composer that is wrong in the way Brandon named: a 44px filled
   block beside a 44px mic makes the footer taller than the field it commits.
   36 visual, 44 hit. Nothing about the target changes. */
/* ⚠️ `:not(.is-icon)` — AND IT WAS A SILENT SQUASH WITHOUT IT. `.cmp-ft .a-btn`
   is MORE SPECIFIC than `.cmp-mic`, so this rule's horizontal padding won over
   the mic's own `padding:0` and put 28px of padding inside a 36px box. The
   glyph is a flex item, so it did not overflow — it SHRANK, to 6px wide by 16
   tall, and rendered as a sliver that read like a broken icon rather than a
   layout fault. An icon button's padding is its width; it must never be given
   a labelled button's. */
.ash-shell.is-phone .cmp-ft .a-btn:not(.is-icon){
  height:36px; font-size:var(--atlas-fs-md);
  padding:0 var(--atlas-s14);
  position:relative;
}
/* ⚠️ AND THE GLYPH ITSELF NEVER SHRINKS. Belt and braces, because this is the
   second time a flex child has quietly compressed instead of overflowing —
   an overflow is visible and gets fixed; a squash looks like a bad asset. */
.ash-shell.is-phone .cmp-ft svg{ flex:none }
.ash-shell.is-phone .cmp-ft .a-btn:not(.is-icon)::before{
  content:""; position:absolute; left:0; right:0;
  top:calc((var(--atlas-tap-min) - 36px) / -2);
  height:var(--atlas-tap-min);
}
/* GHOST, not outlined — the glyph IS the control (A23).
   ⭐ 40px, UP FROM 36 (Brandon, 2026-09-01: *"make our mic dictation button a
   bit bigger and slightly bolder… make sure it stays centered"*). It is the one
   control in the footer you reach for mid-sentence, and at 36 ghost it was the
   quietest thing there.
   ⚠️ THE SIZE IS A VARIABLE BECAUSE THE HIT AREA IS COMPUTED FROM IT. The
   ::before centres itself by pulling back half the difference between the tap
   minimum and the visual box — hard-code 36 in three places and changing one of
   them slides the target off-centre while everything still LOOKS right. */
/* The Aa toggle rides the same row and wears the same ghost treatment — one
   size variable, one computed hit target, for both (A196). */
.ash-shell.is-phone :is(.cmp-mic, .cmp-fmt){
  --cmp-mic-size:40px;
  border-color:transparent; background:transparent;
  height:var(--cmp-mic-size); width:var(--cmp-mic-size); padding:0; position:relative;
  color:var(--atlas-ink);
}
.ash-shell.is-phone :is(.cmp-mic, .cmp-fmt)::before{
  content:""; position:absolute;
  left:calc((var(--atlas-tap-min) - var(--cmp-mic-size)) / -2);
  top:calc((var(--atlas-tap-min) - var(--cmp-mic-size)) / -2);
  width:var(--atlas-tap-min); height:var(--atlas-tap-min);
}
/* The open state must out-specify the ghost above, or the bar reads closed. */
.ash-shell.is-phone .cmp-fmt.is-on{ background:var(--atlas-bg-2) }
/* ⚠️ NO RING ON A PHONE, DELIBERATELY (Brandon, 2026-09-01: *"I don't want the
   border to show on mobile"*). I had added one — the ghost rule above sets
   `border-color:transparent` at (0,3,0) and beats `.cmp-mic.is-live` at
   (0,2,0), so the live border had never shown and I "fixed" that. He wants the
   ghost shape kept, so the border stays invisible in BOTH states and all of the
   live signal is carried by the glyph: urgent red, filled, two pixels larger,
   and the pulse it already had.
   ⚠️ The colour is set on the BUTTON so the SVG inherits it — the glyph is
   `fill="currentColor"`. */
.ash-shell.is-phone .cmp-mic.is-live{
  border-color:transparent;
  color:var(--atlas-urgent);
}
/* A touch more contrast than the shared pulse, since the ring is gone. */
.ash-shell.is-phone .cmp-mic.is-live svg{ animation:aSoftPulse 1s ease-in-out infinite }
/* (The phone mic's `:active` fill is gone — P41c; the kit's `.a-btn:active`
   translate is its press.) */
/* ⚠️ THE AI BUTTON IS ICON-ONLY AT REST ON A PHONE (Brandon, 2026-08-22 —
   *"kit change to the mobile ai buttons — should be icon only and make it
   smaller too. Not text"*). At rest the label is "Write it up", which is ~110px
   of a 340px row to say what the broom already says, next to a commit button
   that is the actual decision.

   ⚠️ IN EVERY STATE, INCLUDING WORKING — and Brandon overruled me on this after
   seeing it: *"the AI button expanding pushes the log button. The AI button on
   mobile only should not show the status."* My argument was A32 (the button IS
   the status, narrating `Reading…` → `Found 1 task · 2 changes`), and the
   argument was right about the DESKTOP and wrong here for a reason the
   screenshot makes obvious: at 390 the narration GROWS the button, and the only
   place the extra width can come from is the commit button beside it, which
   gets shoved off the row mid-sentence.
   ⚠️ AND THE STATUS IS NOT ACTUALLY LOST, which is what makes this affordable:
   the findings render IN THE COMPOSER (A114) — the rewritten note streams into
   the field, the tasks and criteria resolve one row at a time directly above the
   chips. The outcome is on screen at full size. On a desktop the label is the
   fastest read; on a phone it is a duplicate that costs the commit button its
   place.

   ⚠️ AND THE GRADIENT BORDER STAYS. It is the asset's identity AND part of the
   state machine (A41) — an earlier pass here flattened it and tried to restore
   it with `border-color:initial`, which is `currentColor` and cannot bring back
   a gradient: the button would have gone quiet at rest and stayed quiet while
   working. Only the LABEL is hidden. */
.ash-shell.is-phone .cmp-ai{
  width:36px; padding:0; gap:0; flex:none;
}
/* ⚠️ `.ai-l` — the label's real class, checked against `aiBtn`/`aiPin` rather
   than guessed. And hiding it is what sidesteps `aiPin` cleanly: that function
   pins the widest state as an inline `min-width` ON THE LABEL (so narrating
   never resizes the button), and inline styles beat a stylesheet — but a
   `display:none` element occupies nothing whatever its min-width says. */
.ash-shell.is-phone .cmp-ai .ai-l{ display:none }
.ash-shell.is-phone [data-cmp-cancel]{ display:none }
/* ⚠️ 16px OR iOS ZOOMS THE VIEWPORT ON FOCUS — the same threshold the kit's
   drawer fields obey. On the one field in the app you type into most, a
   viewport lurch is least welcome. */
/* ⭐ AND IT FOLLOWS THE APP'S SIZE NOW (2026-08-27) — 16px was the floor, not
   the target, and the composer reading a size smaller than everything around it
   was the most visible instance of that. `max()` keeps the threshold as a
   FLOOR, which is what it always was. The line box is pinned so the box cannot
   grow (Brandon: the font may rise, the composer may not). */
.ash-shell.is-phone .lead2-ph-cmp .a-ment-in,
.ash-shell.is-phone .lead2-ph-cmp .a-ment-mirror{
  font-size:max(16px, var(--atlas-fs-base, 16px)); line-height:24.8px;
}
/* ⚠️ NO `vh` CAP — the primitive measures it (MB40). A fraction of the screen
   locks early on a big phone and still overlaps on a small one; the real limit
   is the distance to the keyboard, which `fitGrower` writes as an inline
   max-height every time the box resizes. Stated here as an absence so nobody
   re-adds one.
   THE DESKTOP CAP STAYS (`.a-ment-in{max-height:40vh}`) — there is no keyboard
   to measure to, so a fraction is the right answer there. */

/* ── THE STACKED COMPOSER (MB33) ──────────────────────────────────────────
   Prompt on top, modes as their own full-width row beneath it. The desktop puts
   the modes at the far right of a single row, which at 390 leaves the prompt
   ~90px and crushes the pills against the edge. Two lines is what prod worked
   out and it is the right answer: the modes get the width, and the prompt stops
   being an ellipsis.
   ⚠️ THE CONCEPT IS PROD'S; THE STYLING IS OURS. The reference draws a solid
   white chip for the active mode. Ours keeps `.cmp-pill.is-on`, which is the
   accent treatment every selected pill in Atlas already wears — importing the
   fill would be a second vocabulary for "chosen". */
/* ⚠️ THE WHOLE BOX IS TIGHTER, not just its field. Expanded, this thing is
   prompt + modes + commit and it was eating a third of the screen — the field
   opened three rows deep, the modes carried a desktop gap, and the box added
   `s12` all round on top. On a phone the composer is a control you use and
   dismiss, not a region you live in: the timeline behind it is the context you
   are writing ABOUT, and burying it defeats the note. */
.cmp.is-stack{ padding:var(--atlas-s10) var(--atlas-s12) var(--atlas-s12) }
.cmp.is-stack.is-collapsed{
  display:flex; flex-direction:column; align-items:stretch;
  gap:var(--atlas-s10); height:auto;
}
/* ⚠️ THE GAPS WERE THE WRONG WAY ROUND (Brandon, 2026-08-22 — *"too much space
   underneath the log button and not enough between log and email"*). The footer
   inherited `padding:s8 s16` from the desktop and the stack adds its own `s12`
   below, so there was 8px above the commit row and 20px under it — the row
   floating high in a box with a band of nothing beneath. Both come off the
   footer: the space it needs is ABOVE, separating it from the modes. */
.cmp.is-stack .cmp-modes{ margin-top:var(--atlas-s10) }
.cmp.is-stack .cmp-ft{ padding:var(--atlas-s12) 0 0 }
/* The pill row scrolls sideways rather than wrapping — a wrapped second line
   moves the field every time the set changes, and a composer that changes
   height when you switch modes is what A32 pins button widths to avoid. */
/* ⚠️ NO SIDEWAYS SCROLL ANY MORE. It was there because `flex:none` chips could
   overflow; equal flexible ones cannot, and a scroller that never scrolls is a
   gesture that swallows a tap near the edge for nothing. */
.cmp.is-stack .cmp-pills{ display:flex; gap:var(--atlas-s6); width:100% }
/* Every mode clears the tap floor. `--atlas-h-pill` is 28px on a desktop, which
   is a pointer target; the phone block re-points nothing here, so it is stated
   against the control rung instead. */
/* ── THE MODE CHIPS (MB35) ────────────────────────────────────────────────
   ⭐ THE SEGMENTED CONTROL'S LOOK, WITHOUT ITS TRACK (Brandon, 2026-08-22 —
   *"make the composer toggles look exactly like this … style the same as the
   toggle (but these are disconnected of course) — and no slide animation"*).

   Same height, same radius, same type, same selected treatment as `.seg-b`, so
   a phone has ONE chip vocabulary instead of two. What differs is the
   containment, and it is a real distinction rather than a styling variant:
     · A SEGMENTED CONTROL IS ONE CHOICE OVER A FIXED SET, which is why it has a
       TRACK — the track is the thing being divided, and the sliding mark is the
       division moving. Four views of one record.
     · THESE ARE FREE-STANDING, because the set can NARROW (a deal gets note
       only; a phone drops Task) and a track that changes width as options come
       and go reads as the control resizing itself.
   ⚠️ AND NO SLIDE, for the same reason: with no track there is nothing for the
   mark to be a fraction OF, so it would have to measure, and a measured
   animation across a set that can change size is the drift MB34 avoids by
   construction. The selected chip simply IS selected. */
.cmp.is-stack .cmp-pill{
  /* ⚠️ THEY FILL THE ROW, EVENLY (Brandon, third time of asking — my error, and
     it was one word: I kept `flex:none` from the desktop pill, where the modes
     sit at the end of a row beside a collapse control and must NOT stretch. On
     a phone they are the whole row, so four equal thirds-of-a-row is what makes
     the set readable at a glance and every target the same size. "Disconnected"
     was about the TRACK — no groove, no sliding mark — never about the width. */
  flex:1 1 0; min-width:0; justify-content:center;
  height:var(--atlas-h-control);
  padding:0 var(--atlas-s8);
  border:var(--atlas-bw) solid transparent;
  border-radius:var(--atlas-r-md);
  /* ⚠️ UNSELECTED TAKES THE GROUND, NOT A GREY (Brandon, 2026-08-22). I filled
     these with `bg-2` from the reference screenshot, which is a LIGHT-mode app
     where a grey chip on white is the recessed state. Reading it literally
     inverted the meaning on a dark theme — there, `bg-2` is a step UP, so every
     unselected mode looked raised and the selected one looked like a hole.
     The toggle's own answer is the right one and it was already there: an
     unselected segment has NO fill, and the selected one is what lifts. */
  background:transparent;
  color:var(--atlas-ink-3);
  font-size:var(--atlas-fs-sm); font-weight:var(--atlas-fw-semi);
}
/* SELECTED IS THE SEGMENT'S OWN TREATMENT — the raised surface plus the accent,
   exactly what `.seg-b.is-on` wears. Copying the reference's flat white fill
   would have been a second answer to "chosen" on one screen.

   ⚠️ AND "EXACTLY" NOW MEANS EXACTLY (Brandon, 2026-08-25: *"do we have a
   lesser lift/shadow so these are a bit less dramatic?"*). The answer to the
   question as asked is no — P12 ships TWO elevation tokens split by scale, and
   this was already on the lesser one. What made it read heavy was a BORDER
   stacked on top of the shadow, which `.seg-b.is-on` does not have: two
   separations doing one job, and the outline is the half that reads as weight
   because it is a hard edge at full contrast while the lift is soft.
   So the border goes rather than a third lift rung arriving — a third step
   between 2px and 5px of blur is B5's adjacent-values failure in shadow form,
   imperceptible and one more thing to choose wrong. The base keeps its
   TRANSPARENT border so the box does not resize on selection. */
/* …and on the phone the selected chip wears the seg's THUMB (A338's, not the old
   bg-1 + control lift), keeping its mode hue — the colour rule above still wins. */
.cmp.is-stack .cmp-pill.is-on{
  background:var(--atlas-seg-thumb);
  box-shadow:var(--atlas-lift-thumb);
}
.cmp.is-stack .a-ment{ --a-ment-pad:var(--atlas-s12) }
/* ⚠️ THE AI SKELETON IS `position:absolute; inset:0` INSIDE THE FIELD — which
   clips to nothing, because `.a-ment` never had a reason to hide its overflow.
   With the phone field opening one row deep, a three-line skeleton simply
   painted straight over the mode chips beneath it. It is a placeholder for text
   that is arriving, so clipping it to the box it will fill is the correct
   answer rather than growing the box to fit a shimmer. */
.cmp.is-stack .a-ment.is-skel{ overflow:hidden }
/* ⚠️ THE RESTING FIELD IS SHORTER. The desktop's 86px minimum is sized to a
   composer that sits in a page with room around it; on a phone it opens as a
   band of empty box between the prompt and the modes, which reads as the
   control waiting for something rather than inviting anything. It still GROWS —
   `.a-ment` autosizes — so nothing is lost except the emptiness. */
.cmp.is-stack .a-ment-in,
.cmp.is-stack .a-ment-mirror{ min-height:var(--atlas-h-btn) }

/* ══ THE SLIDING MARK (MB34) — RETIRED 2026-10-26 ═══════════════════════════
   Every `.seg-ctl` travels now (A338): kit.js mounts the thumb and animates it
   whenever `.is-on` moves, so `.is-slide`, `.a-slide`, `--a-slide-n` and
   `--a-slide-i` are gone — a consumer still writing them would be a second
   mark on the same track. MB34's rule survives intact: it is the MARK that
   moves, never the page. */

/* ══ THE TIMELINE ON A PHONE (MB36) ════════════════════════════════════════
   ⭐ NO GLYPH COLUMN, AND THE LABEL TAKES ITS COLOUR (Brandon, 2026-08-22).
   The reasoning holds on its own: at 390 the 22px glyph plus its gap costs ~30px
   of every row — about 8% of the width — to say the same thing the word beside
   it already says. "Note" IS the icon, in letters. Dropping the mark and moving
   its colour onto the word loses nothing and gives the body a full line back.

   ⚠️ THE COLOUR IS THE SAME COLOUR, from the same class. `tlRow` renders the
   tint on the label as well as the glyph, so this is one CSS rule rather than a
   second row renderer — and an activity type that gains a hue tomorrow gains it
   in both frames at once (L22).

   ⚠️ AND THE AI GRADIENT MOVES WITH IT. Provenance was on the glyph (a note
   whose first draft came from the model wears the gradient instead of its
   activity tint); with no glyph it has to live on the word or it is simply
   lost. This is the ONE place a gradient may touch type — L6 reserves the
   gradient for AI and this is exactly that, not decoration. It is also why it
   is scoped this tightly: `.tl2-t.is-ai` and nothing else. */
/* ⚠️⚠️ THE TIMELINE READS AT BODY SIZE ON A PHONE (2026-08-27, Brandon: *"make
   the… activity timeline bigger too to match what's across the rest of the app
   on mobile"*). On a desktop the feed is a column beside a rail and a panel, so
   `fs-md` is right — it is one of three things on screen. On a phone it IS the
   screen, and what it holds is PROSE somebody wrote to be read.

   ⚠️⚠️ AND THIS MOVES THE LEAD PROFILE TOO, DELIBERATELY. The timeline is ONE
   kit component with two consumers (the CRM and the deal hub) — that is why it
   was promoted out of the lead profile in the first place. Scoping this to the
   hub would give the same feed two sizes on two surfaces, which is the exact
   drift the promotion existed to prevent. If the two ever need to differ, that
   is a decision to record, not a selector to narrow.

   The meta and the source chip move one rung with it, so the hierarchy inside a
   row is unchanged — everything is one step louder, nothing is re-ranked. */
.a-phone .tl2-b{ font-size:var(--atlas-fs-base) }
.a-phone .tl2-m,
.a-phone .tl2-dot{ font-size:var(--atlas-fs-sm) }
.a-phone .tl2-src{ font-size:var(--atlas-fs-xs) }

.ash-shell.is-phone .tl2-ic{ display:none }
.ash-shell.is-phone .tl2-t.t-note { color:var(--atlas-act-note) }
.ash-shell.is-phone .tl2-t.t-call { color:var(--atlas-act-call) }
.ash-shell.is-phone .tl2-t.t-text { color:var(--atlas-act-text) }
.ash-shell.is-phone .tl2-t.t-email{ color:var(--atlas-act-email) }
.ash-shell.is-phone .tl2-t.t-drip { color:var(--atlas-act-drip) }
.ash-shell.is-phone .tl2-t.is-ai{
  background-image:linear-gradient(100deg, var(--atlas-ai-a), var(--atlas-ai-b));
  -webkit-background-clip:text; background-clip:text;
  color:transparent;
  /* ⚠️ A FALLBACK COLOUR IS NOT OPTIONAL HERE. `color:transparent` with a failed
     clip is an INVISIBLE WORD, so the AI ink is set first and the clip paints
     over it — if `background-clip:text` is ever unsupported the label reads in
     the AI colour instead of vanishing. */
  -webkit-text-fill-color:transparent;
}
@supports not ((-webkit-background-clip: text) or (background-clip: text)){
  .ash-shell.is-phone .tl2-t.is-ai{
    color:var(--atlas-ai); -webkit-text-fill-color:var(--atlas-ai); background-image:none;
  }
}

/* ══ A POPOVER IS A SHEET ON A PHONE (MB37) ════════════════════════════════
   ⭐ MB6 ALREADY SAID SO — *every desktop drawer becomes a detented sheet* —
   and a picker is the case that proves why: it is the one popover that carries
   a SEARCH FIELD, so on a phone it lands on the row it is editing and then the
   keyboard covers whatever of it is left.

   ⚠️ IT REUSES THE DRAWER'S OWN GEOMETRY TOKENS rather than inventing sheet
   numbers: `--atlas-sheet-partial-max`, `--atlas-sheet-r`, `--a-kb-h`. So a
   picker sheet and a drawer sheet are the same object at the same height with
   the same corner, and the day one of those tokens moves they move together.

   ⚠️ AND IT RIDES THE KEYBOARD, for the same reason the drawer does — this is
   the popover most likely to have a field in it, so being the one sheet that
   sits under the keyboard would be exactly backwards. */
/* ⚠️ `:not(.a-pop-anchored)` ON EVERY SHEET RULE — a mention typeahead is the one
   popover that must stay a popover (Brandon, 2026-08-25). It is attached to the
   caret of a message being written, so a bottom sheet covers the text you are
   typing and turns three keystrokes into a modal. MB37's rule is about popovers
   you OPEN; this one opens itself as you type. Matching guard in `placePop`. */
/* The lift drops while the keyboard is up — same hairline-on-the-slab reason
   as `.drw`'s rule in the MB30 block. */
html.a-kb-open.a-phone .pop:not(.a-pop-anchored){
  box-shadow:0 calc(var(--a-kb-h, 0px) / 2) 0 calc(var(--a-kb-h, 0px) / 2) var(--atlas-bg-1);
  /* The keyboard escalates the picker sheet's cap too — same reasoning as the
     drawer's rule in the MB30 block (1-C, 2026-09-12). */
  max-height:calc(var(--atlas-sheet-full) - var(--a-kb-h, 0px));
}
.a-phone .pop:not(.a-pop-anchored){
  --kb-rides:1;
  /* The keyboard-ground slab — same mechanism and reasons as `.drw`'s (see the
     MB30 block): a pseudo here was WORSE than clipped, because base `.pop` is
     overflow:auto, so the out-of-box `::after` added a keyboard-height of
     phantom scroll range to every picker sheet. */
  box-shadow:var(--atlas-lift), 0 calc(var(--a-kb-h, 0px) / 2) 0 calc(var(--a-kb-h, 0px) / 2) var(--atlas-bg-1);
  position:fixed;
  top:auto; left:0; right:0;
  bottom:var(--a-kb-h, 0px);
  width:auto; max-width:none;
  max-height:calc(var(--atlas-sheet-partial-max) - var(--a-kb-h, 0px));
  border-radius:var(--atlas-sheet-r) var(--atlas-sheet-r) 0 0;
  border-left:0; border-right:0; border-bottom:0;
  /* ⚠️⚠️ THE SHEET DOES NOT PAY THE INSET — ITS SCROLLER DOES (2026-09-12,
     Brandon: *"the bottom of the agent picker has a white block that runs across
     … when its supposed to be full edge to edge"*). This used to be
     `padding-bottom:var(--atlas-safe-b)` HERE, which confines `.pop-scroll` to
     the sheet's content box: the list then ends 34px above the physical edge and
     can never scroll into that strip, so a band of blank sheet sits permanently
     under the last row and cuts it.
     MB18 already says it — *the ground crosses the inset, the control stops at
     it* — and the DRAWER already builds it correctly (`.drw-b` takes the inset,
     `.drw` takes none). The picker simply never got the same treatment. The
     operative form, because the principle was stated at too high an altitude to
     prevent this: **a scroller pays the inset, a sheet never does.** A sheet that
     pads itself can never let content reach the edge. */ 
  z-index:var(--atlas-z-modal);
  /* ⚠️ NO BOX-SHADOW SCRIM ANY MORE. It painted the dim with no markup — and I
     chose it BECAUSE a shadow is not hit-testable, which is the same sentence
     as "it cannot absorb the tap". That is precisely the bug: it looked like a
     scrim and did not act like one, so a dismissing tap closed the sheet AND
     pressed whatever was behind it. `.a-sheet-scrim` is a real element now, and
     swallowing the tap is the whole reason a scrim exists. */
  transition:bottom var(--atlas-dur-fast) var(--atlas-ease-out),
             max-height var(--atlas-dur-fast) var(--atlas-ease-out);
}
/* The sheet's scrim — the drawer's own asset (P49), mounted by the kit when a
   menu opens on a phone. Below the sheet, above everything else. */
/* One below the panel it belongs to, and they are SIBLINGS so that comparison
   is meaningful — see the note in `sheetScrimOn`. */
.a-sheet-scrim{ z-index:calc(var(--atlas-z-modal) - 1) }
/* ⚠️⚠️ RE-AMENDED 2026-09-12, SAME DAY — THE LAYERING FIX DID NOT SURVIVE THE
   COMPOSITOR, AND THE RULE IS BACK. The morning's amendment kept the pill
   painted under sheets by z-order (nav 200 < scrim 300 < sheet 301) and it
   measured correct — until `.ash-main` (the phone's scroller) got promoted to
   a composited layer, which WebKit does LAZILY after real scrolling. From
   then on the compositor sorted the pill's layer ABOVE the scroller's whole
   subtree: the pill painted over an open sheet at z200-vs-301, over the z300
   scrim, even over a drawer portalled to document.body at z301 —
   screenshotted, hit-tested, and immune to every z bisect, with every DOM
   probe still reading a correct stacking order. Removing the pill's resting
   transform (the obvious promotion trigger) did not fix it. The lazy
   promotion is also why the bug was INTERMITTENT — pre-scroll, paint order
   ruled and the morning's verification passed honestly.

   So: Brandon's option (b) — `display:none` is compositor-proof, and THE
   ENGINE NOW OWNS THE TIMING. `a-sheet-open` comes OFF at the DISMISSAL
   DECISION (the moment a release commits to leaving — kit.js `_sheetSettle`
   calls the close path right there), not at spring-end — so the pill is back
   in place while the sheet flies past it, on every path: X-close, scrim tap,
   and mid-spring flings, which is exactly the "times perfectly to be in
   place when visible" half of the original ask. */
/* ⚠️ THE CALL BAR JOINS THIS RULE (MB129), it does not get its own. Measured
   on the sim: with the bar up and its own sheet open, the sheet's "Save
   outcome" sat at 796..840 — inside the bar's 775..874 band — and the bar
   painted over it despite z 200 against the sheet's 301 (trap 63's family: the
   compositor had stopped taking orders from z-index). The layering is the
   symptom; the design point is that the bar is the PROMPT and the sheet is the
   ANSWER, so both on screen at once is redundant even when it looks right.
   Bottom chrome hides under a sheet — the pill already says so, and one rule
   for "bottom chrome" beats two that can disagree. */
html.a-sheet-open .a-navpill,
html.a-sheet-open .a-cbar,
html.a-sheet-open .ash-pill{ display:none !important; }

/* ══ THE PILL LEADS THE PUSH AND FOLLOWS THE POP (MB163) ═══════════════════
   ⚠️ THE OLD HIDE WAS STRUCTURALLY LATE, NOT SLOW. The pill leaves through
   `:has(.crm2-surface.is-lead)` and friends — a question about whether the
   DESTINATION IS ALREADY IN THE DOM — so it could not go until the record had
   mounted and painted (Brandon: *"it stays there for like a second until the
   page is fully painted"*). No tuning fixes that; it is waiting on the wrong
   event. Those rules STAY, because they are what makes a cold deep-link arrive
   with no pill and no transition to speak of. What is new is the MOTION, driven
   from the navigation itself.

   ⚠️⚠️ MEASURED, AND THE GEOMETRY IS WHY THE EXIT HAS TO LEAD. The pill spans
   x 16..386 of a 402px screen, and the push curve is violently front-loaded:
   the incoming page's leading edge reaches the pill's band after 4% of the
   travel, which is **9ms — one frame**. There is no concurrent version of this.
   Coming back the same geometry is generous: the outgoing page clears the band
   at 96% of travel, which on that curve is 52% of the TIME (~260ms of a ~500ms
   pop), so the pill rises with ~240ms of the pop still running and reads as
   following the page out rather than waiting for it.

   ⚠️ AND THE LEAD IS LOAD-BEARING FOR A SECOND REASON. A transformed pill gets
   lazily promoted to its own compositor layer and stops obeying z-index — that
   is the whole reason the resting hide is `display:none` (see the block above:
   painting over a portalled drawer at z301, immune to every z bisect, and
   INTERMITTENT). Sequencing the exit ahead of the push means there is never a
   frame where a promoted pill and the incoming page share the screen, and
   `display:none` returns the moment the motion ends. */
html.a-pill-anim .ash-shell.is-phone .ash-pill{
  /* ⚠️ `!important` AND IT IS EARNED: a MOTION state must out-rank a RESTING
     state for exactly as long as it runs. The `:has()` hide computes around
     (0,6,0) and fires the instant the destination mounts — which is mid-exit —
     so without this the pill would vanish half-way down and the animation would
     be the thing nobody ever sees. Removed by the same code that added it. */
  /* ⚠️⚠️ `block`, NOT `flex` — THE PILL IS NOT THE FLEX CONTAINER, ITS TRACK IS.
     `.ash-shell.is-phone .ash-pill` is `display:block` and `.ash-pill-track`
     inside it is the `display:flex`. Forcing the pill itself to flex made the
     track a flex ITEM for the length of the animation, so the pill's insides
     re-laid-out on the way out and back — which is the *"buggy and glitchy"*
     rise. An override has to restate the value the element actually had, not a
     plausible one. */
  display:block !important;
  pointer-events:none;              /* it is leaving or arriving — not a target */
}
.ash-shell.is-phone .ash-pill.is-pill-out{
  /* Down and fully clear: 54px of pill plus the gap beneath it. `--atlas-ease-in`
     because it is LEAVING — an exit accelerates away, it does not ease to a
     stop somewhere you cannot see. */
  transform:translateY(calc(100% + 40px));
  transition:transform var(--atlas-pill-out-dur, 140ms) var(--atlas-ease-in);
}
.ash-shell.is-phone .ash-pill.is-pill-in{
  animation:a-pill-in var(--atlas-pill-in-dur, 300ms) both;
  /* ⚠️ ON THE RETURN ONLY. `.ash-shell.is-phone .ash-pill` carries
     `transition:transform 420ms` for the minimize-on-scroll — the same property
     this keyframe drives — and when the animation ends the transition would
     take the revert and walk it (a slow unexplained drift right after the
     bounce lands, and worse with `.is-min` on). Two systems, one property
     (trap 51).
     ⚠️⚠️ IT IS SCOPED TO THIS CLASS, NOT TO `a-pill-anim`. A blanket
     `transition:none !important` on the wrapper ALSO killed `.is-pill-out`'s
     own 140ms transition — measured, the drop became a single-frame jump from
     629 straight to 723 instead of a slide. The exit is driven BY a transition;
     only the return is driven by a keyframe. */
  transition:none;
}
/* ⚠️ A KEYFRAME, NOT `--atlas-ease-land`. That token overshoots by ~20% of the
   travel, which over a 94px exit is ~19px — a lurch, not the *"slightly above
   its position"* Brandon asked for. An overshoot that is a FIXED DISTANCE has
   to be written as one; a bezier can only ever express it as a proportion.
   The two legs carry their own easing, which is what makes it a WALL: a fast
   rise that keeps its speed into the overshoot, then an abrupt correction —
   rather than one curve easing softly into place. */
@keyframes a-pill-in{
  /* ⚠️ THE RISE IS NEAR-LINEAR, AND THAT IS THE WHOLE METAPHOR. An ease-out
     rise front-loads the distance: measured, the first cut covered 34 of the
     94px before the first sampled frame, so the pill READ AS POPPING IN
     half-way up rather than travelling — *"buggy and glitchy"*. A thing that is
     going to hit a wall moves at SPEED right up to the wall; it does not slow
     down on approach. Constant velocity up, then the correction is the only
     fast part. */
  0%   { transform:translateY(calc(100% + 40px));
         animation-timing-function:cubic-bezier(.34,.5,.5,.96); }
  72%  { transform:translateY(-7px);
         animation-timing-function:cubic-bezier(.45,0,.55,1); }
  100% { transform:translateY(0); }
}
/* Reduced motion keeps the RULE and drops the SHOW: the pill is where it
   belongs on both sides, it simply does not travel between them. */
@media (prefers-reduced-motion: reduce){
  .ash-shell.is-phone .ash-pill.is-pill-out{ transition:none }
  .ash-shell.is-phone .ash-pill.is-pill-in{ animation:none }
}

/* ⚠️⚠️ A HOST OF AN OPEN SHEET MAY NOT BE TRANSFORMED — AND `:active`
   PROPAGATES UP, WHICH IS WHAT MADE THIS UNIVERSAL (trap 39).

   Every picker-as-sheet was unusable: a row press closed the sheet and applied
   nothing, and it read exactly as *clicking THROUGH the picker* (Brandon).
   Measured, at 390x844, pressing a row inside the sheet:

       BEFORE        popY 338
       pointerdown   popY 126   <- the panel jumps UP 212px
       pointerup     popY 338   <- and snaps back

   `:active` is not just on the row you pressed — the browser applies it to
   EVERY ancestor, which includes the sheet's own host (`.lead2-ed:active`
   carries `translateY(var(--atlas-press))`, and it is one of many). The
   instant that host has a transform it becomes the containing block for the
   `position:fixed` sheet inside it, so `bottom` re-resolves against a 21px
   span instead of the viewport. The panel moves between pointerdown and
   pointerup, the pointer ends up over something else, and the browser
   RETARGETS the click to the nearest common ancestor — the scroller. So
   `[data-assign-set]` no longer matches, the row branch is skipped, and the
   click falls through to the outside-click rule, which closes it.

   ⚠️ THE SYMPTOM NAMES THE WRONG LAYER, WHICH IS WHY IT SURVIVED THREE FIXES:
   the row is correct, `elementFromPoint` returns it, and a programmatic
   `.click()` WORKS — because a synthetic click never has a pointerdown for the
   panel to move between (trap 13). Only a real press can see it.

   ⚠️ `!important` IS DELIBERATE, AND IT IS NOT A SPECIFICITY GAME. This is a
   structural invariant, not a preference: a surface author adding an ordinary
   press transform to their own wrapper next month must not be able to silently
   re-break every picker in the app. Nothing is lost — while a sheet is open
   its trigger is behind a scrim, and this `:active` is propagated rather than
   a real press on the host.

   ⚠️⚠️ IT HAS TO HOLD WHILE THE SHEET IS *PAINTED*, NOT WHILE IT IS *OPEN* —
   AND KEYING IT ON `.is-open` ALONE LEFT A SECOND, IDENTICAL BUG ON THE WAY
   OUT (Brandon: *"they still flash the desktop picker on close"*).
   `closePickers` does exactly this, in this order:

       panel.classList.add('is-closing');        // panel stays painted 220ms
       p.classList.remove('is-open', 'is-up');   // host loses is-open NOW

   so for the whole out-animation the host is no longer `.is-open` while its
   panel is still on screen. If anything transforms it in that window the sheet
   re-resolves against the host and snaps to the trigger — which is the desktop
   popover appearing for 220ms as it fades. Measured by `sheet-host-check`:
   `closing · PRESSED` moved the sheet **1720px** while all three other states
   held. So both painted states are covered, and the selector mirrors
   `OPEN_MENU` in kit.js — plus its `is-closing` twin — so the two cannot drift.

   ⚠️ EVERY PANEL CARRIES `.pop` (`pick-menu pop`, `dp-pop pop`, `tp-pop pop`),
   which is what lets one selector cover all four families. The `:has()` forms
   without `>` are there because `closePickers` finds `.pick-menu` /
   `[data-dp-pop]` at ANY depth, so a consumer may nest one deeper. */
.a-phone .is-open:has(> .pop),
.a-phone .pick.is-open,
.a-phone .dp.is-open,
.a-phone .tp.is-open,
.a-phone :has(> .pop.is-closing),
.a-phone .pick:has(.pop.is-closing),
.a-phone .dp:has(.pop.is-closing),
.a-phone .tp:has(.pop.is-closing){ transform:none !important }

/* THE GRAB HANDLE, same as the drawer's — without it a bottom-anchored panel
   reads as a modal that happens to be at the bottom. */
.a-phone .pop:not(.a-pop-anchored)::before{
  content:""; display:block; flex:none;
  width:36px; height:4px; margin:var(--atlas-s10) auto var(--atlas-s6);
  border-radius:var(--atlas-r-full); background:var(--atlas-line-2);
}
/* Rows reach the tap floor — the desktop picker row is a pointer target.
   ⚠️ ANCHORED POPS TOO (MB106): an anchored menu is tapped by the same finger
   a sheet is, so the floor keys on `.pop`, not on which shape it took. */
.a-phone .pop .pick-row{ min-height:var(--atlas-h-btn) }
/* ⚠️⚠️ `touch-action` IS WHY A ROW WOULD NOT TAP, and it took a long time to
   find because every symptom pointed elsewhere. Without it the browser holds
   the gesture open in case it becomes a scroll or a double-tap-to-zoom, and a
   quick tap on a row inside a scrollable sheet was being resolved as neither —
   no click, no PATCH, nothing in the console, and `elementFromPoint` at the
   same coordinates returning the correct row the whole time.
   The tell was in the comparison: taps on the SEGMENTED CONTROL and on a lead
   CARD worked, and the only thing those two have that a picker row did not is
   this line. Everything a finger commits with needs it. */
.a-phone .pop, .a-phone .pop .pick-row, .a-phone .pop button, .a-phone .pop a{
  touch-action:manipulation;
  -webkit-tap-highlight-color:transparent;
}
/* ⚠️ 16px IS THE FLOOR, NOT THE SIZE. The picker's search is a field like any
   other and reads at the app's size with the threshold kept as a `max()` — see
   the field block above. ⚠️ THIS ONE OUT-SPECIFIES THAT BLOCK (0,2,1 against
   0,1,0), so it kept its literal 16px while every other field moved: a fourth
   pin, found by reading the rule next to it rather than by looking at a phone,
   where a one-pixel difference in one picker is invisible until it is not. */
.a-phone .pop input{ font-size:max(16px, var(--atlas-fs-base, 16px)) }

/* ── THE TIMESTAMP NEVER TAKES ITS OWN ROW (MB39) ─────────────────────────
   `.tl2-hd` wraps, which is right on a desktop where the row is wide and a rare
   wrap is harmless. At 390 with the glyph column gone and a long author name,
   the WHEN wrapped onto a line of its own — so a two-line entry became three,
   and the time read as a heading over the body rather than as part of the row
   it belongs to.

   ⚠️ THE NAME IS WHAT GIVES, and that is the decision rather than "make it fit".
   Three things share this line and they are not equal: the TYPE says what
   happened, the TIME says when, and both are short and fixed. The AUTHOR is
   free text, it is the longest, and it is the one you can lose the tail of and
   still know what you are looking at — "Amanda Neh…" is a person you recognise.
   So the label and the time never shrink, and the name truncates into whatever
   is left. */
/* ⚠️ THREE LINES ON A PHONE, NOT TWO (Brandon, 2026-08-30: *"the activity type
   on one line, name and timestamp muted below it on second line, then the
   content starts on 3rd line"*). The TYPE takes the whole first line — it is
   the coloured word that is the row's icon here (MB36) — and the author and
   the time share the second, in the meta ink they already wear. MB39's rule
   survives on that second line: the name is still what gives, the time never
   wraps. `row-gap` is tighter than the column gap so the two lines read as one
   header over the body rather than as three rows of equal weight. */
.ash-shell.is-phone .tl2-hd{ flex-wrap:wrap; row-gap:2px; min-width:0 }
.ash-shell.is-phone .tl2-t{ flex:0 0 100% }
.ash-shell.is-phone .tl2-hd .tl2-m{
  min-width:0; overflow:hidden; text-overflow:ellipsis; white-space:nowrap;
}
.ash-shell.is-phone .tl2-when,
.ash-shell.is-phone .tl2-dot{ flex:none }

/* ══ TEXT IS SELECTABLE ON A PHONE (MB41) ══════════════════════════════════
   ⭐ Brandon: *"make sure globally on mobile these things, text can be selected
   and copied / select all and stuff natively."* — and this is a debt I created.
   The card sets `user-select:none` and `-webkit-touch-callout:none` for a real
   reason: a long-press has to open the action sheet, not a text selection, and
   iOS must not throw a Copy/Look-Up callout over a lead's name.

   ⚠️ BUT THAT RULE BELONGS TO CONTROLS, NOT TO CONTENT. A note somebody typed,
   a phone number, an address, a timeline body — those are things you copy, and
   they are half of why you opened the record. Suppressing selection there is
   taking away a native capability to protect a gesture that does not apply to
   them.

   THE LINE: anything you PRESS suppresses selection; anything you READ keeps
   it. Stated as an allow-list on the reading surfaces rather than by loosening
   the card, because the card's rule is correct where it is. */
/* ⚠️ REWRITTEN 2026-09-12 (D-1): the enumerated tl2- and lead2- classes moved to
   `data-copyable` AT THEIR EMIT SITES — the vocabulary the selection block at
   the end of this file owns (MB115: surfaces declare; and the attribute is
   what K.longPress's stand-down reads, which a class cannot give it). What
   remains here is kit chrome that cannot practically be marked per-emit.
   The row HEADER (tl2-t/tl2-m) deliberately left the allow-list: the header
   is the hold's remaining chrome (10-GESTURES C5) — body text selects, the
   header still long-presses the row. */
.ash-shell.is-phone :is(.a-ment-in, .drw-b p, .cmp-ph){
  -webkit-user-select:text; user-select:text;
  -webkit-touch-callout:default;
}

/* ══ THE SHARED SHEET MOTION (MB43) ════════════════════════════════════════
   One slide, used by every bottom sheet in the app — the drawer, the picker,
   and whatever comes next. Keyframes rather than a transition because a
   `.pop` is shown by flipping `display`, and a display change cannot be
   transitioned: the panel would jump to its final position and the transition
   would have nothing to animate from. An animation runs on the frame the
   element becomes displayed, which is exactly when a sheet should start moving.

   ⚠️ AND THE EXIT NEEDS THE ELEMENT TO STILL EXIST. `is-open` coming off makes
   it `display:none` immediately, so `.is-closing` holds it visible for the
   length of the out-animation and takes its pointer events away — it is on its
   way out, and a sheet you can still tap while it leaves is a mis-tap waiting
   to happen. */
@keyframes a-sheet-up   { from { transform:translateY(100%) } to { transform:none } }
@keyframes a-sheet-down { from { transform:none } to { transform:translateY(100%) } }

/* ⚠️ `.is-open > .pop`, NOT `.pop` — AND THIS WAS THE GLITCH. Applied to every
   `.pop`, the animation runs THE MOMENT THE ELEMENT IS PARSED, while it is
   still `display:none`. It finishes in the dark, and because `both` holds the
   end state it never runs again — so the sheet that was supposed to slide just
   appeared, and any pop that DID catch the tail of it flashed mid-animation.
   An entrance has to be attached to the thing that causes the entrance, which
   is the same rule `.is-open > .pop{display:flex}` one line up already follows. */
/* ⚠️⚠️ `:not(.is-entered)` — AN ENTRANCE MAY ONLY RUN ONCE PER OPEN (Brandon,
   2026-09-13: *"whenever you drag the sheet bigger than it's meant to be, it
   completely closes and reopens"*). Suppressing an animation and then
   UN-suppressing it RESTARTS it — that is what `animation:none` means when it
   goes away. A drag adds `.is-drag` (which kills the keyframe, correctly, so no
   animation fights the inline transform), and the release takes `.is-drag` off
   again — at which point this rule applied afresh and the sheet flew in from
   off-screen a second time. It reads as a close-and-reopen; it is one
   declaration coming back.
   `.is-entered` is stamped at drag start and cleared by `closePickers`, so the
   next real open animates and a release never can. */
.a-phone .is-open > .pop:not(.a-pop-anchored):not(.is-entered){
  animation:a-sheet-up var(--atlas-sheet-dur-in) var(--atlas-sheet-ease-in) backwards;
}
.a-phone .pop.is-closing:not(.a-pop-anchored){
  display:flex; pointer-events:none;
  animation:a-sheet-down var(--atlas-sheet-dur-out) var(--atlas-sheet-ease-out) both;
}
/* THE ENGINE'S HAND (MB116): while a finger owns the sheet — or the release
   spring is still settling — no keyframe may fight the inline transform. The
   entrance runs `backwards`-filled, so catching a pop mid-entrance without
   this left the animation in charge and the drag dead until it finished. */
.a-phone .pop.is-drag:not(.a-pop-anchored){ animation:none }
/* THE DRAWER JOINS IT — it already slid, on its own timing. Same tokens now, so
   the two cannot drift and there is one number to change. */
@media (max-width: 720px), (max-height: 500px) and (pointer: coarse){
  /* ⚠️⚠️ THIS BLOCK IS THE ONE THE CASCADE OBEYS — same specificity as the
     MB30 keyboard block above, later in the file, so ITS values win. For two
     weeks it silently overrode MB30's `--atlas-kb-*` keyboard-follow (the
     documented fix for "the keyboards in the drawers… feel like it drags
     along") back to a generic 150ms ease-out — the exact dead-fix shape
     mobile-premium/01-AUDIT Part 1 records. The keyboard tokens live HERE now,
     agreeing with MB30's block instead of fighting it.

     ⚠️ ENTRANCE AND EXIT ARE SPLIT (MB43 as intended): one `transition`
     shorthand made the drawer EXIT at the entering duration and curve. The
     BASE rule carries the exit (you have already decided — leaving is
     immediate); `.is-open` carries the entrance (arriving is considered).
     Opening reads the is-open timing, closing reads the base timing, because a
     transition uses the value that applies AFTER the class change. */
  .drw{
    transition:transform var(--atlas-sheet-dur-out) var(--atlas-sheet-ease-out),
               bottom var(--atlas-kb-dur) var(--atlas-kb-ease),
               max-height var(--atlas-kb-dur) var(--atlas-kb-ease);
  }
  .drw.is-open{
    transition:transform var(--atlas-sheet-dur-in) var(--atlas-sheet-ease-in),
               bottom var(--atlas-kb-dur) var(--atlas-kb-ease),
               max-height var(--atlas-kb-dur) var(--atlas-kb-ease);
  }
  /* ⚠️ RE-ASSERTED: `.drw.is-drag{transition:none}` (the drag kills the
     transition) is declared EARLIER and ties `.drw.is-open` at (0,2,0) — the
     is-open rule above would beat it on source order and animate against the
     finger. Stated again here so the drag stays transition-free. */
  .drw.is-drag{ transition:none }
  /* THE DETENT SNAP (1-C, 2026-09-12): medium → full is a max-height change,
     and by default max-height transitions on the KEYBOARD curve (it exists
     for the keyboard follow). An escalation is a different motion — it rides
     the sheet spring. The engine adds `.is-snap` for the snap's duration and
     removes it after; ties `.is-open` at (0,2,0) and wins on source order,
     which is also why it must stay AFTER the is-open rule above. */
  .drw.is-snap{
    transition:transform var(--atlas-sheet-dur-in) var(--atlas-sheet-ease-in),
               bottom var(--atlas-kb-dur) var(--atlas-kb-ease),
               max-height var(--atlas-spring-open-dur, 610ms) var(--atlas-spring-open, ease);
  }
}
@media (prefers-reduced-motion: reduce){
  .a-phone .pop:not(.a-pop-anchored), .a-phone .pop.is-closing:not(.a-pop-anchored){ animation:none }
  /* ⚠️ RE-ASSERTED for the same source-order reason as `.is-drag` above: the
     base reduced-motion rule near the top of the file (`.drw{transition:none}`)
     ties the phone `.drw` rule at (0,1,0) and LOSES to it on order — true of
     the previous block here too, found while splitting the timings. A
     reduced-motion phone gets no sheet transition, as the top rule intended. */
  .drw, .drw.is-open, .drw.is-snap{ transition:none }
}

/* ══ CONFIRM (P24) ════════════════════════════════════════════════════════
   ⭐ THE ASK-BEFORE-YOU-ACT DIALOG, REBUILT ON TOKENS (2026-08-27). The app's
   `atlasConfirm` — 206 call sites — drew a hand-rolled box that predates the
   token system: a hard red confirm on every question, a centred column of
   buttons, and type from the legacy stack.

   ⚠️ IT IS A DIALOG, NOT A CARD. `--atlas-z-modal` over the kit's own scrim,
   the v5 lift, one hairline. No glass (L7), no tint, no glow.
   ⚠️ AND THE FOOTER READS LEFT-TO-RIGHT TOWARD THE COMMIT, like every drawer in
   the app (P23): cancel first, the action last and on the right. The old one
   put the destructive button FIRST and centred the pair, so the eye landed on
   the irreversible half. */
.a-cfm-wrap .a-cfm-scrim{ --scrim-z:var(--atlas-z-modal) }
.a-cfm-wrap.is-open .a-cfm-scrim{ opacity:1; pointer-events:auto }
.a-cfm{
  position:fixed; z-index:calc(var(--atlas-z-modal) + 1);
  left:50%; top:50%; transform:translate(-50%, -50%) scale(.98);
  width:min(420px, calc(100vw - var(--atlas-s32)));
  background:var(--atlas-bg-1);
  border:var(--atlas-bw) solid var(--atlas-line);
  border-radius:var(--atlas-r-lg);
  box-shadow:0 1px 2px rgba(16,24,40,.06), 0 12px 26px -18px rgba(16,24,40,.45);
  padding:var(--atlas-s20);
  opacity:0;
  transition:opacity var(--atlas-dur-base) var(--atlas-ease-out),
             transform var(--atlas-dur-base) var(--atlas-ease-out);
}
.a-cfm-wrap.is-open .a-cfm{ opacity:1; transform:translate(-50%, -50%) scale(1) }
@media (prefers-reduced-motion: reduce){
  .a-cfm{ transition:none; transform:translate(-50%, -50%) }
  .a-cfm-wrap.is-open .a-cfm{ transform:translate(-50%, -50%) }
}
/* Y1 — WEIGHT OVER SIZE. The question is the subject, so it carries the weight;
   it does not need to be big to be first. */
.a-cfm-t{
  margin:0; font-size:var(--atlas-fs-lg); font-weight:var(--atlas-fw-semi);
  line-height:1.3; color:var(--atlas-ink); letter-spacing:var(--atlas-ls-tight);
}
.a-cfm-s{
  margin:var(--atlas-s8) 0 0;
  font-size:var(--atlas-fs-sm); line-height:1.5; color:var(--atlas-ink-2);
}
.a-cfm-ft{
  display:flex; align-items:center; justify-content:flex-end;
  gap:var(--atlas-s8); margin-top:var(--atlas-s20);
  flex-wrap:wrap;                    /* never spill past the padding (2026-10-10) */
}
.a-cfm-ft .a-btn{ max-width:100% }
/* ⚠️ ON A PHONE THE BUTTONS GO FULL WIDTH AND THE COMMIT GOES ON TOP — MB49's
   drawer footer rule, one level up. A 44px target is not optional and two of
   them side by side at 390 leaves neither room to say what it does. */
.a-phone .a-cfm-ft{ flex-direction:column-reverse; align-items:stretch }
.a-phone .a-cfm-ft .a-btn{ width:100%; justify-content:center }

/* ══ LONG PRESS (MB11) ═════════════════════════════════════════════════════
   The feel half of `K.longPress`. Brandon, 2026-08-28: *"any press and hold
   action needs to actually give out push animation when you hold down the note
   so it has FEELING, and right now when the toolsheet slides up it highlights
   the entire screen."*

   ⚠️ A HOLD IS NOT A PRESS, AND IT GETS ITS OWN TREATMENT DELIBERATELY.
   `:active` is instantaneous feedback that a control was actuated — for a
   SURFACE that is a step down the neutral ladder and nothing else, because a
   row that jumps reads as jitter (P39/P41, trap 6). A hold is a 480ms WAIT, and
   the entire job of the animation is to say *something is coming* before it
   arrives. So the surface steps down instantly (the press you already know) and
   then the row eases inward over the length of the hold, resolving exactly as
   the sheet takes over. That easing is the part that makes the gesture feel
   answered rather than merely detected.

   ⚠️ `pointer: coarse`, NOT A WIDTH. This is a rule about what a FINGER does —
   the exact distinction that put two bugs on Brandon's iPad on cutover day
   (`04-CONVENTIONS` M6). A long press does not exist for a mouse.

   ⚠️ AND THE SCALE IS SAFE HERE FOR THE REASON TRAP 6 BANS IT ELSEWHERE. That
   trap is about a CURSOR dropping out of a shrinking hit box mid-press; a touch
   point is captured by the element that received `touchstart` and does not
   re-hit-test, so there is nothing to drop out of. Measured at 0.98: a 94px row
   moves under 1px at each edge. */
@media (pointer: coarse){
  /* ⚠️ NO FILL (P41c, 2026-08-30). The hold used to step to `bg-2` as well as
     scale, and because the class lands at `touchstart` it painted grey on EVERY
     tap of a timeline row — measured fading in over the first 100ms of a press
     that never became a hold. The push is the feeling; the colour was the
     "selected" flash Brandon has been chasing across the whole app. */
  .is-holding{
    transform:scale(.98);
    transition:transform 460ms var(--atlas-ease-out);
  }
}
/* ⚠️⚠️ THE SELECTION GUARD, IN TWO SCOPES.
   `.is-holding *` is (0,2,0), which is what lets it beat a component that
   deliberately opted its own text back IN — `.tl2-b` is `user-select:text` so
   notes can be copied out, and at (0,1,0) a single-class rule would have lost
   to it on source order. That is the whole reason this is not one rule.
   `html.a-hold` then covers the DOCUMENT, for a finger that drifts off the row
   mid-press: without it the selection simply runs away across whatever is
   underneath, which is the "highlights the entire screen" Brandon saw.
   ⚠️ `-webkit-touch-callout` is the separate half. `user-select` stops the blue
   band; the CALLOUT (the copy/look-up bubble and the magnifier) is its own iOS
   affordance and needs its own line, or the sheet opens underneath one.

   ⚠️⚠️ AND IT IS `!important`, WHICH WAS MEASURED RATHER THAN ASSUMED. The
   first cut relied on `.is-holding *` (0,2,0) out-ranking `.tl2-b` (0,1,0) —
   correct, and it still lost, because the PHONE has its own higher rule:
   `.ash-shell.is-phone :is(.tl2-b, .tl2-t, …)` is **(0,3,0)**. Measured with
   the guard live: `a-hold` was on `<html>`, `is-holding` was on the row, and
   `user-select` still computed to **`text`** on the note body. That is trap 1 —
   a reset out-specifying the thing it is meant to govern — and no amount of
   selector chaining fixes it durably, because the NEXT component that wants
   copyable text will out-specify whatever number is chosen today.

   The precedent is C22, which sanctions `!important` for `cursor` on exactly
   this reasoning: *"the cursor is a correctness signal, not a style choice, so
   nothing should be able to out-rank it."* A selection guard during a long
   press is the same kind of statement — it does not say how the text should
   look, it says THIS GESTURE IS NOT A SELECTION — and it is live only for the
   480ms a finger is down, so it cannot leak into anything's resting style. */
html.a-hold, html.a-hold *,
.is-holding, .is-holding *{
  -webkit-user-select:none !important; user-select:none !important;
  -webkit-touch-callout:none !important;
}

/* ══ THE ONE-ROW PHONE COMPOSER (MB83) ═════════════════════════════════════
   Replaces MB33's stack. MB33 gave the four mode pills a row of their own
   because at 390 they could not share the prompt's line — the right fix for the
   shape it had, and the shape was the problem. Measured before this change:
   **102px collapsed, 175px open — 34% of the 508px left with the keyboard up**,
   most of it spent on a control you look at once.

   At rest: the prompt, and the one control that puts words in it. The mode moved
   into the action row, which only exists once the composer is open. */
.cmp.is-stack.is-line{
  display:flex; flex-direction:row; align-items:center;
  gap:var(--atlas-s8);
}
/* The prompt takes the room and the mic keeps its size — without `min-width:0`
   a flex item's floor is its MAX-CONTENT width, which is the bug that has now
   shipped three times in this codebase (MB53). */
.cmp.is-stack.is-line .cmp-ph{ flex:1; min-width:0 }

/* ⚠️ `flex-end`, NOT `center`. As the note grows the mic stays at the BOTTOM of
   the field — the convention every messaging app uses for a trailing control
   beside a growing box, and the thing that makes the row read as one control
   rather than two stacked ones. At one line the two are identical, which is why
   this is easy to get wrong and only shows on the third line. */
.cmp.is-stack .cmp-line{
  display:flex; align-items:flex-end; gap:var(--atlas-s8);
}
.cmp.is-stack .cmp-line .a-ment{ flex:1; min-width:0 }

/* ── THE MODE SELECT ──────────────────────────────────────────────────────
   The kit's `.sel-ctl` shell, sized to the action row's 36px so the three
   controls in that row share one baseline. Nothing about the shell is
   re-declared — only its height, its type size and the width of its menu, which
   is the line between using an asset and forking one (trap 19). */
.cmp-mode{
  height:36px; flex:none;
  font-size:var(--atlas-fs-md);
  padding:0 var(--atlas-s8) 0 var(--atlas-s10);
  gap:var(--atlas-s4);
}
.cmp-mode-v{ font-weight:var(--atlas-fw-semi) }
/* Left-anchored under its trigger, and wide enough that the tick has somewhere
   to sit without crowding the label. `placePop` still clamps and flips it. */
.cmp-mode-pop{ left:0; width:180px }
/* The action row is the only row on a phone, so the commit takes the far edge
   and everything else reads left-to-right: what kind of thing, then the AI, then
   the decision. `margin-left:auto` rather than a spacer element — the AI button
   appears at eight characters and the commit at one, and a spacer would have to
   survive both of those arriving independently. */
.ash-shell.is-phone .cmp-ft-btns{ margin-left:auto }

/* ⚠️ THE FINDINGS SCROLL RATHER THAN PUSH THE COMMIT UNDER THE KEYBOARD.
   `[data-kb-give]` tells `fitGrower` this is the region that yields once the
   field is already at its floor — see the note there. Without `overflow-y` the
   clamp would CLIP the last finding instead of letting you reach it, which is
   L20's rule (the part that gives is the part you can scroll back to). */
.cmp-found[data-kb-give]{ overflow-y:auto; overscroll-behavior:contain }

/* ══ A CONTROL IS NOT TEXT ═════════════════════════════════════════════════
   ⭐ Brandon, 2026-08-28, on the mode select: *"when the selector is clicked the
   entire composer selects and highlights which is a no no."*

   A `<span role="button">` is still a span, and a `<button>`'s LABEL is still
   text — so a tap with any drift starts a selection, and on a phone that paints
   a blue band across the control and everything the drag reached. It is the
   same class of thing as `cursor: pointer` (C22): not a style preference, a
   statement about what the element IS. A control reports and actuates; it is
   never something you select a word out of.

   ⚠️ STATED ONCE, FOR THE FAMILIES, rather than per component — the six places
   that had already written this locally are why it kept being missed in the
   seventh. Anything genuinely readable is deliberately absent from this list:
   `.tl2-b` (notes get copied out), `.a-ment-in`, and every real input.

   ⚠️ THIS IS THE RESTING RULE. `html.a-hold` / `.is-holding` (MB81) is the
   separate, temporary one that covers a LONG PRESS, where the target may be
   ordinary text and the suppression has to lift again afterwards. */
.sel-ctl, .sel-ctl *,
.pick-field, .pick-field *,
.pick-row, .pick-row *,
.a-btn, .a-btn *,
.a-x, .a-x *,
.a-pill, .a-pill *,
.seg-ctl, .seg-ctl *,
.cmp-pill, .cmp-ph,
.tl2-act, .tl2-rx-b, .tl2-rxpick-b{
  -webkit-user-select:none; user-select:none;
}

/* ══ A TIMELINE ROW HAS NO HOVER STATE ON A PHONE ══════════════════════════
   ⭐ Brandon, 2026-08-28: *"when you hover or click the activity timeline it
   highlights like its selected… its annoying because it shows up on press."*

   ⚠️ `@media (hover: hover)` IS THE RIGHT PREDICATE AND IT IS NOT SUFFICIENT
   HERE. It correctly excludes a phone browser — but the rebuilt shell also runs
   at phone WIDTH inside a desktop browser (`?shell=1`, a dragged window, the
   pop-out), where `hover:hover` is true and the row lights up under a cursor
   that is standing in for a thumb. And on a real touch screen `:hover` STICKS
   after a tap until you tap elsewhere, which is the "shows up on press" half.
   So the frame gets the final say: if the phone shell is mounted, the row has
   no hover state, whatever the pointer claims to be.

   ⚠️ `:not(.is-holding)` — the LONG PRESS keeps its feedback (MB80). That one
   is a deliberate answer to a deliberate gesture; this is a state nobody asked
   for. They are opposites and the selector has to say so, or removing the
   accidental highlight would take the intentional one with it.

   ⚠️ AND THE ACTION STRIP GOES WITH IT. It is desktop-only by design — the
   phone reaches the same three verbs through the long press (C9) — and it was
   only ever hidden by that same `hover:hover` gate, so it was appearing beside
   the highlight in exactly the same conditions. Stated on the frame, it cannot.

   ⚠️ `-webkit-tap-highlight-color` is a THIRD, separate mechanism: iOS paints
   its own grey block on tap regardless of our backgrounds, and it needs its own
   line or the row still flashes. */
.ash-shell.is-phone .tl2-i:hover:not(.is-holding),
.a-phone .tl2-i:hover:not(.is-holding){ background:transparent }
.ash-shell.is-phone .tl2-acts,
.a-phone .tl2-acts{ display:none }
.ash-shell.is-phone .tl2-i,
.a-phone .tl2-i{ -webkit-tap-highlight-color:transparent }

/* ══ SELECTION ON TOUCH — MB41 RESTORED (D-1, 2026-09-12) ══════════════════
   ⭐⭐ THE LAW (MB41): *anything you PRESS suppresses selection; anything you
   READ keeps it.* The block that stood here was the 2026-08-28 blanket —
   `html.a-phone *{ user-select:none !important }` — written against the
   screen-tinted-blue photo, and it silently erased MB41 for weeks: long-press
   produced NOTHING anywhere on the phone, which became this project's
   founding complaint #2. The blue-highlight problem it was blamed for was
   actually solved by the hold guard (`html.a-hold`, above) and the control
   families; both stay. Full story: mobile-premium/01-AUDIT §2.1.

   THE SHAPE (MB115 — kit vocabulary, surfaces declare):
     · The chrome DEFAULT is `none`, set ON THE SCOPE ROOTS and reaching
       everything else through `user-select:auto`'s parent resolution — NEVER
       the universal selector. That scoping is also the mitigation for a live
       iOS 26 bug: double-tap-hold-drag over content styled `none` can crash
       the web content process (03-CEILING §3, Apple forum 797368).
     · `[data-copyable]` is the ONE selectable-content declaration. A surface
       marks a note body, a phone number, an address, a name — and gets
       selection + the Copy callout. (`data-copy` was taken: the legacy drive
       share sheet uses it as a copy-button value attribute.)
     · What you TYPE into keeps its caret's selection model, as before.
   ⚠️ `-webkit-touch-callout` is a SEPARATE mechanism — `user-select` stops
   the blue band; the callout is the Copy/Look-Up bubble — each needs its line.
   ⚠️ Data detectors stay suppressed (index.html's meta + CSS net): selectable
   text must not grow auto-blue phone/address links. */
@media (pointer: coarse){
  html.a-phone .ash-shell,
  html.a-phone .atlas-scope{
    -webkit-user-select:none; user-select:none;
    -webkit-touch-callout:none;
  }
  /* What you TYPE into is an exception a caret requires. `!important` because
     the hold guard above and MB87's family rules also speak with weight, and
     a field must never become untypeable by losing a specificity race. */
  html.a-phone input,
  html.a-phone textarea,
  html.a-phone [contenteditable="true"],
  html.a-phone [contenteditable="true"] *{
    -webkit-user-select:text !important; user-select:text !important;
    -webkit-touch-callout:default;
  }
  /* ⭐ THE VOCABULARY. `!important` for the measured reason the old blanket's
     own comment recorded: `.ash-shell.is-phone :is(...)` chrome rules reach
     (0,3,0) and would beat a plain attribute rule silently, exactly where
     notes are. */
  html.a-phone [data-copyable],
  html.a-phone [data-copyable] *{
    -webkit-user-select:text !important; user-select:text !important;
    -webkit-touch-callout:default;
  }
  /* THE HOLD GUARD OUTRANKS THE VOCABULARY (source order + same weight): a
     long press that began on row CHROME must not start selecting the content
     the finger drifts across. K.longPress never ARMS inside [data-copyable]
     (10-GESTURES C5) — this covers only the drift case. */
  html.a-hold [data-copyable],
  html.a-hold [data-copyable] *,
  .is-holding [data-copyable],
  .is-holding [data-copyable] *{
    -webkit-user-select:none !important; user-select:none !important;
    -webkit-touch-callout:none !important;
  }
  /* iOS paints its own grey block on tap on top of all of this. Ours is the
     press feedback; there is no room for two. */
  html.a-phone *{ -webkit-tap-highlight-color:transparent }
}

/* ── CALL OUTCOMES (2026-09-03) — the resolved label is plain header text;
   the unresolved strip is kit pills with the remove × on the right. Type in
   rem (the text-size law); colours off the neutral ladder, no tint. */
.tl2-oc{ color:var(--atlas-ink-2); font-size:var(--atlas-fs-sm) }
.tl2-ocrow{ display:flex; flex-wrap:wrap; align-items:center; gap:6px; margin-top:6px }
/* The quiet caption line a feature hangs under a row it wrote (`opts.foot`) —
   Pocket's "Transcript · Pocket summary · Wrong lead". Caption size, muted,
   the last word at the trailing edge; on a phone each word is a 44pt target. */
.tl2-cap{ display:flex; flex-wrap:wrap; align-items:center; gap:0 6px; margin-top:6px; font-size:var(--atlas-fs-xs); color:var(--atlas-ink-3) }
.tl2-cap-b{ border:0; background:none; padding:0; font:inherit; color:inherit; cursor:pointer; min-height:20px }
.tl2-cap-b.is-on{ color:var(--atlas-ink-2) }
.tl2-cap-b.is-end{ margin-left:auto }
.tl2-cap-s{ color:var(--atlas-ink-3) }
@media (hover: hover){ .tl2-cap-b:hover{ color:var(--atlas-ink); text-decoration:underline; text-underline-offset:2px } }
.a-phone .tl2-cap{ gap:0 12px }
.a-phone .tl2-cap-b{ min-height:44px; display:inline-flex; align-items:center }
.tl2-ocpill{ font-size:.75rem; padding:3px 10px }
.tl2-ocx{ display:flex; align-items:center; justify-content:center;
  width:24px; height:24px; margin-left:auto; flex:0 0 auto;
  border:0; background:none; cursor:pointer; border-radius:6px; color:var(--atlas-ink-3) }
@media (hover: hover){ .tl2-ocx:hover{ background:var(--atlas-bg-2); color:var(--atlas-ink-2) } }
/* The composer's shared 16px content line — the mode pills and the field's
   text both sit on it, and the strip flush at the raw box edge read as a
   broken indent (Brandon's screenshot, 2026-09-03). */
.cmp-ocrow{ display:flex; flex-wrap:wrap; gap:6px; padding:8px var(--atlas-s16, 16px) 2px }

/* ══ CALENDAR BLOCK — `.a-cev` (A244) ═════════════════════════════════════════
   Ported from the lab mock Brandon ruled on, not rebuilt: the same rules, the
   same class shapes, moved into the kit because it has two consumers (the lab
   documents it, the calendar renders it) and two consumers means EXTRACT — a
   second implementation of "what does a 15-minute event look like" is a drift
   waiting to happen (A237's lesson with the month grid).

   FILLED, and only here (Brandon's ruling). The nevers forbid tinted surfaces
   because color must not become decoration; on a calendar the color IS the
   information — A238's "all red is prospecting, all green is open houses" is a
   promise you scan a WEEK by, and a 3px spine cannot keep it at that distance.
   The fill is a family member: same hue, `K.hueFill` lightness and chroma, an
   OPAQUE value rather than an opacity, so it lands identically over a grid
   rule, over today's column and over anything else beneath it. */
.a-cev{
  position:absolute; left:2px; right:2px; overflow:hidden; cursor:pointer;
  border-radius:var(--atlas-r-xs); padding:3px var(--atlas-s6) 3px 8px;
  background:var(--a-cev-bg); border:var(--atlas-bw) solid var(--a-cev-bd);
  box-shadow:inset 3px 0 0 var(--a-cev-c);
  font-size:var(--atlas-fs-2xs); color:var(--atlas-text); text-align:left;
}
.a-cev-t{ display:block; font-weight:var(--atlas-fw-bold); white-space:nowrap;
  overflow:hidden; text-overflow:ellipsis }
.a-cev-m{ display:block; color:var(--atlas-text); opacity:.75;
  white-space:nowrap; overflow:hidden; text-overflow:ellipsis }
/* ONE LINE when the block is too short for two — the rule, not a fudge. Two
   stacked lines in 15px is unreadable at any type size. */
.a-cev.is-tight{ padding-top:1px; padding-bottom:1px;
  display:flex; align-items:center; gap:var(--atlas-s6) }
.a-cev.is-tight .a-cev-t{ flex:0 1 auto }
.a-cev.is-tight .a-cev-m{ flex:0 0 auto }
/* SHOWING STATUS (A241) — carried by SHAPE, never by color: the color slot is
   already spoken for by the label. Requested has not happened to you yet, so it
   is dashed and unfilled; cancelled is struck and dimmed and stays as long as
   the feed carries it. */
.a-cev.is-req{ background:var(--atlas-bg-1); border-style:dashed }
.a-cev.is-cx{ opacity:.55 }
.a-cev.is-cx .a-cev-t{ text-decoration:line-through }
/* ALL-DAY lives in the band, never as a 24-hour block — a block that tall
   buries the day it belongs to. */
.a-cev.is-allday{ position:static; margin:2px; height:auto }
/* MULTI-DAY — one segment per day, ends rounded, middles square, so a run of
   chips reads as ONE continuous band across the columns. The alternative, a
   single box positioned across grid cells, has to escape the grid to do it.
   ⚠️ The margin goes with the radius: a 2px gap at a joined edge is a visible
   seam, which is the whole thing this is trying not to look like. The inset
   colour bar rides the FIRST segment only, for the same reason the title does —
   it marks where the event starts. */
.a-cev.is-span-start{ border-top-right-radius:0; border-bottom-right-radius:0;
  margin-right:-1px; border-right-width:0 }
.a-cev.is-span-mid{ border-radius:0; margin-left:0; margin-right:-1px;
  border-left-width:0; border-right-width:0; box-shadow:none }
.a-cev.is-span-end{ border-top-left-radius:0; border-bottom-left-radius:0;
  margin-left:0; border-left-width:0; box-shadow:none }
/* ⚠️ THE TITLE IS HIDDEN, NOT REMOVED. Removing it collapsed a continuing chip
   to 8px beside the first day's 25px — a band that changes height halfway
   across reads as broken, not as continuous. visibility:hidden keeps the box
   and takes the text out of the a11y tree, which the container's own label
   replaces. And the -1px margins above close the day divider the band crosses:
   a 1px light line at every join is exactly the seam this is avoiding. */
.a-cev.is-span-mid .a-cev-t,
.a-cev.is-span-end .a-cev-t{ visibility:hidden }
/* ── COLOUR BANDS (A249) — the label picker ────────────────────────────────
   A column of filled bands, the label centred inside, an unnamed colour left
   bare because the colour IS the content (A238). Painted with the same fill /
   edge / ink as .a-cev, so what you pick looks like what you will get.
   ⚠️ SELECTION IS A RING, NOT A TICK (A43): every row is already coloured, so a
   mark placed INSIDE one has to flip light-or-dark against it. The ring is a
   zero-blur inset — geometry, not a glow, which is banned. */
.a-bands{ display:flex; flex-direction:column; gap:var(--atlas-s4) }
.a-band{
  display:flex; align-items:center; justify-content:center;
  min-height:30px; padding:var(--atlas-s6) var(--atlas-s10);
  border-radius:var(--atlas-r-xs); cursor:pointer; width:100%;
  background:var(--ab-bg); border:var(--atlas-bw) solid var(--ab-bd);
  color:var(--ab-c); font-size:var(--atlas-fs-xs);
  font-weight:var(--atlas-fw-semi); text-align:center;
}
.a-band.is-none{ background:var(--atlas-bg-2); border-color:var(--atlas-border);
  color:var(--atlas-ink-3); border-style:dashed }
.a-band-t{ overflow:hidden; text-overflow:ellipsis; white-space:nowrap }
.a-band.is-on{ box-shadow:inset 0 0 0 2px var(--ab-c, var(--atlas-accent)) }
.a-band.is-none.is-on{ box-shadow:inset 0 0 0 2px var(--atlas-accent) }
/* A press is MOTION on touch and colour only on a real pointer (P41c). */
.a-band:active{ transform:var(--atlas-press-t-row, translateY(var(--atlas-press))); transition:var(--atlas-press-in, none) }
@media (pointer: fine){ .a-band:hover{ border-color:var(--ab-c) } }
.a-band:focus-visible{ outline:2px solid var(--atlas-accent); outline-offset:2px }
.a-cev-join{ display:inline-flex; align-items:center; gap:3px;
  color:var(--atlas-accent); font-weight:var(--atlas-fw-bold) }
/* PRESS. A block is a SURFACE, so it steps its surface and never moves — a card
   that jumps reads as jitter. The color half lives under pointer:fine (P41c);
   a finger gets nothing. The filled variant cannot step to bg-2 without erasing
   its label color, so it dims its own fill. */
@media (pointer: fine){
  .a-cev:active{ filter:brightness(.96) }
  .a-cev.is-req:active{ background:var(--atlas-bg-2); filter:none }
}

/* leadPick in FIELD mode — the same control as a form row rather than an icon
   in a composer bar. It borrows `.pick-field` / `.pick-val` wholesale, so this
   only has to make the wrapper fill its row. */
.a-leadpick.is-field{ display:block; flex:1; min-width:0 }
.a-leadpick.is-field .pick-field{ width:100% }
/* THE GHOST — an event being composed, not one that exists. Dashed and hollow,
   the same shape a requested showing wears (A241): both mean "not yet". It sits
   above the real blocks because it is a preview of a decision in progress, and
   `pointer-events:none` so it can never intercept a click meant for the grid
   underneath it — you are still choosing where it goes. */
.a-cev.is-ghost{
  background:none; border-style:dashed; border-color:var(--a-cev-c);
  box-shadow:none; pointer-events:none; z-index:3;
}
.a-cev.is-ghost .a-cev-t{ color:var(--a-cev-c) }

/* ══ THE 300ms KILLER IS A RULE, NOT AN ENUMERATION (Phase 0 item 10, 2026-09-11) ══
   index.html's `pointer: coarse` rule lists elements (a, button, the ARIA roles,
   `[onclick]`…) — and every kit clickable that is none of those kept iOS's double-tap
   wait: `.tbl2-row` is a div, so a table row tapped ~300ms slower than the button
   beside it. The kit declares the answer for EVERYTHING it owns, at ZERO specificity
   (`:where`), so any component's own `touch-action` — a drag handle's `none`, the
   markup stage, a future slider's `pan-x` — wins at any specificity, any source order.

   The second block is the NATIVE half of removing the viewport zoom clamp (MB122a):
   an app does not pinch-zoom, and with `user-scalable=no` gone from the meta the CSS
   is what says so — `pan-x pan-y` pans freely and permits neither double-tap nor
   pinch. Browsers (incl. Android Chrome, where the clamp was killing accessibility
   zoom) keep `manipulation`, which leaves pinch alive. `html.atlas-native` is the
   app-shell class the boot script sets only inside the Capacitor webview. */
@media (pointer: coarse){
  :where(.ash-shell, .ash-shell *, .drw, .drw *, .pop, .pop *, .scrim){
    touch-action: manipulation;
  }
  :where(html.atlas-native .ash-shell, html.atlas-native .ash-shell *,
         html.atlas-native .drw, html.atlas-native .drw *,
         html.atlas-native .pop, html.atlas-native .pop *,
         html.atlas-native .scrim){
    touch-action: pan-x pan-y;
  }
}

/* ══ THE ROW REVEAL — SWIPE A CARD OPEN (G9, MB128) ════════════════════════
   The mechanism is `K.swipeRow`; this is its vocabulary. A surface declares
   `data-swipe-row` on its row and hands the kit a verb list — nothing about
   the motion, the widths or the press lives at a call site (MB115).

   ⚠️ `touch-action: pan-y` IS LOAD-BEARING, NOT DECORATION. It hands the
   VERTICAL axis to the browser and keeps the horizontal for us, which is the
   only reason the drag listeners can stay PASSIVE — nothing can preventDefault
   a native scroll from a passive listener, so the alternative was never a
   half-measure, it was a different architecture (10-GESTURES C7).
   ⚠️ It also keeps what `touch-action: manipulation` was there for: `pan-y`
   permits no pinch and no double-tap zoom, so the 300ms click delay stays
   dead (trap 42). */
[data-swipe-row]{ position:relative; touch-action:pan-y }

/* THE LAYER UNDERNEATH. `bg-2` is a step along the neutral surface ladder, not
   a tint — it reads as the thing beneath the skin rather than as a coloured
   tray. It starts a third of its own width to the RIGHT and arrives at 0: the
   under-pane's treatment from 3-D's push, on the other axis. Stated as a
   percentage so it is correct before anything has been measured. */
.a-swr-acts{
  position:absolute; top:0; bottom:0; right:0;
  /* SIZED BY ITS CONTENT — `count x segment`, never a fraction of the row. An
     icon-only segment has exactly one honest width (the tap target), so the bar
     is as wide as it needs to be and the SLIVER is the remainder: a three-verb
     card keeps more of its face than a five-verb one, which is correct rather
     than a compromise. 48px clears the 44pt floor with air to spare and is what
     "tighten it up a lot" measures to — five verbs take 240 of a 378px card. */
  width:calc(var(--a-swr-n, 4) * var(--a-swr-seg, 48px));
  display:flex; align-items:stretch;
  background:var(--atlas-bg-2);
}
/* ⚠️ FULL CARD HEIGHT, EDGE TO EDGE (Brandon: *"they fill up the entire chrome,
   so they are taller buttons because they take the shape of the card"*). The
   segment is not a button drawn inside a region — the segment IS the region,
   which is what makes the bar read as one control divided rather than as icons
   floating on a panel. */
.a-swr-b{
  flex:1 1 0; min-width:0;
  display:flex; align-items:center; justify-content:center;
  padding:0; border:0; background:transparent; font:inherit;
  color:var(--atlas-ink-2); cursor:pointer;
  -webkit-tap-highlight-color:transparent;
}
/* SEPARATORS BETWEEN, NEVER AROUND — the card's own border already closes the
   outer edges, and a second line there reads as double-stroked. */
.a-swr-b + .a-swr-b{ border-left:var(--atlas-bw) solid var(--atlas-line) }
/* THE PRIMARY VERB IS FILLED, which is `.a-btn-p`'s vocabulary (an accent FACE
   for the committed action), not a tint on a chip — the thing L5 forbids is a
   tinted background standing in for state, and this is a filled control.
   ⚠️ AND IT DROPS ITS SEPARATOR: the colour change already divides it, so the
   hairline would be a second answer to the same question — and an invisible
   one, sitting against the accent. */
.a-swr-b.is-accent{
  background:var(--atlas-accent); color:var(--atlas-on-accent);
  border-left-color:transparent;
}
/* The glyph's own box — what the press moves, so the segment can hold still. */
.a-swr-in{ display:flex }
/* ⚠️⚠️ THE PRESS MOVES THE CONTENT, THE BOX HOLDS — and this is a genuinely new
   rule for a genuinely new anatomy. P41c's touch press is `scale(.97)` on the
   control, which is right for a control with air around it and WRONG for a
   segment butted against its neighbours: scaling the box opens a hairline gap
   at both seams that the neighbours do not close, and it flashes on every
   press. Moving the glyph and its label keeps the seams solid while the finger
   still sees the mark dip — which is also the card's own recorded reasoning for
   its action glyphs (*"press is the glyph going accent, not a box appearing"*),
   arrived at from the other direction. Still motion and not colour, so P41c
   holds; the token is consumed rather than copied, so MB115 holds. */
.a-swr-b:active .a-swr-in{
  transform:var(--atlas-press-t, translateY(var(--atlas-press)));
  transition:var(--atlas-press-in, none);
}

/* THE SKIN. It paints the row's own ground so nothing shows through it, and it
   is the only thing that travels.
   ⚠️ NO `will-change` — the inline `translate3d` promotes it for the duration
   of the gesture and lets it go afterwards. A persistent promotion on every
   card in a long list is both a memory cost and trap 39's shape (a stacking
   context and a containing block that nothing asked for). */
.a-swr-face{ position:relative; z-index:1; background:var(--atlas-bg-1) }
/* ⚠️ THE FACE'S PRINTING TRAVELS WITH IT AND NEVER FADES (Brandon, 2026-09-12:
   *"we dont need to make the content of the card vanish. Thats the same thing
   as during edge back the previous page is fully shown. we are simply moving
   that top layer so the content should stay there"*). A first cut faded the
   children out, to stop the sliver showing an orphaned "9h ago" — which was an
   aesthetic complaint answered by breaking the premise. The whole design is
   that this is a physical layer being slid off another one, and a physical
   layer does not dissolve as you move it; edge-back's own mover keeps every
   pixel while it travels. The fragment of card visible in the sliver is what a
   partially-uncovered card looks like, and it is also what stops the sliver
   being 138px of nothing. */

/* ══ THE SEAM AND THE DIM — the face is ON TOP OF the bar, and it has to LOOK
   it (Brandon, 2026-09-12: *"add the same lift type thing that the edge-back
   sheet has so it physically looks like its underneath the top layer"*).

   ⭐ THESE ARE EDGE-BACK'S OWN TWO LAYERS, SAME NUMBERS, MIRRORED AXIS — not a
   second opinion about depth. G1's reveal is three var-driven parts: a −33%
   parallax, a dim over the arriving pane, and a gradient seam riding the
   mover's edge. The parallax was already here; these are the other two, read
   off `.a-edge-veil` (0.28 gradient over 16px, dim 0.1, both scrubbed by the
   same progress the motion uses). One depth vocabulary, two consumers.

   ⚠️ THE SEAM RIDES THE FACE, WHICH IS WHY IT NEEDS NO SEPARATE VEIL. Edge-back
   puts it on a veil because its mover is a whole route pane it does not own;
   here the face IS ours, so `::after` at `left:100%` sits permanently on its
   trailing edge and travels with it for free — the two edges cannot drift
   because there is only one edge.
   ⚠️ And it hangs OUTSIDE the face with no `overflow` on it (trap 58); the
   CARD's `contain:paint` is what clips it, which is the same clip that masks
   the bar. */
.a-swr-face::after{
  content:''; position:absolute; top:0; bottom:0; left:100%; width:16px;
  background:linear-gradient(to right, rgb(0 0 0 / 0.28), rgb(0 0 0 / 0));
  opacity:min(1, var(--a-swr-p, 0) * 4);
  pointer-events:none;
}
/* ⚠️ NO DIM OVER THE BAR, AND ITS ABSENCE IS THE POINT. Edge-back washes its
   under-pane in `rgb(0 0 0 / 0.1 * (1-p))` because that pane is travelling
   forward out of depth. This bar is STATIC (see `_swrSet`), so a dim that
   scrubbed away as you opened the row would say the layer was rising toward
   you while it visibly did not move — motion implied by paint that the geometry
   contradicts. Depth here is carried by the two honest cues: `bg-2` is the
   ground beneath on the neutral ladder, and the seam below is the face casting
   onto it. */

/* ══ THE CALL BAR (MB129) — "you owe an outcome" ═══════════════════════════
   ⭐ Brandon, 2026-09-12: *"its a footer that raises up the nav pill to above
   it and persists through every screen… It simply is a green action log call,
   which then gives a slideup sheet with our log call options."*

   ⚠️ IT SAYS "LOG OUTCOME", NOT "LOG CALL", AND THAT IS THE WHOLE INSIGHT. The
   call is ALREADY logged — `data-call-log` writes a `call` activity at the tap,
   because `tel:` leaves the app and the webview never learns the call ended.
   What is missing is the OUTCOME, and without it `contact_made` never flips and
   the `call.logged` automation never fires. So this bar finishes a row that
   exists rather than creating a second one.

   ⚠️ GREEN IS `--atlas-act-call`, the system's own call colour (#008274 /
   #16d3c3), already worn by the composer's call commit. A new green would be a
   second vocabulary for one concept.

   ⚠️ NO RESTING TRANSFORM — it slides on `bottom`, for the same reason the pill
   does (trap 63: a resting transform promotes a layer the compositor then sorts
   above open sheets). Its own sheet must be able to cover it.

   ⚠️ PHONE ONLY. On a desktop you do not leave the app to dial, and the
   timeline's own pill strip is right there. */
.a-cbar{ display:none }
html.a-phone .a-cbar,
.ash-shell.is-phone ~ .a-cbar{ display:flex }
.a-cbar{
  position:fixed; left:0; right:0;
  bottom:calc(-1 * var(--a-cbar-self, 64px));
  z-index:var(--atlas-z-nav);
  align-items:center; gap:var(--atlas-s8);
  padding:var(--atlas-s10) var(--atlas-s12);
  padding-bottom:calc(var(--atlas-s10) + var(--atlas-safe-b));
  background:var(--atlas-bg-1);
  border-top:var(--atlas-bw) solid var(--atlas-line);
  transition:bottom var(--atlas-spring-sheet-dur, 410ms)
                    var(--atlas-spring-sheet, cubic-bezier(.16,1,.3,1));
}
.a-cbar.is-in{ bottom:0 }
@media (prefers-reduced-motion: reduce){ .a-cbar{ transition:none } }

/* THE PRIMARY TAKES THE ROW, the way MB126's Call does — one wide labelled
   verb, an icon-only secondary, and a quiet way out. The lead's NAME rides the
   label (Brandon: *"Make sure its labeled the leads name"*) and truncates,
   because the verb is the part you must be able to read. */
.a-cbar-go{
  flex:1 1 auto; min-width:0;
  background:var(--atlas-act-call); color:var(--atlas-on-accent);
  justify-content:center;
}
/* ⭐ THE BAR WEARS THE CHANNEL IT IS LOGGING (Brandon, 2026-09-14: *"it was
   supposed the text purple. same one that the composer uses for texts"*). Same
   token the composer's send button takes (`.cmp-go.t-text`) and the timeline's
   text rows take, so one verb is one colour everywhere it appears. A MIXED
   queue keeps the call green deliberately — it is about both, and inventing a
   third colour for "several things at once" would say less than the count
   already does. (0,2,0) beats the base rule; no `!important`. */
.a-cbar-go.is-text{ background:var(--atlas-act-text) }
.a-cbar-go .a-cbar-nm{
  overflow:hidden; text-overflow:ellipsis; white-space:nowrap;
  font-weight:var(--atlas-fw-semi);
}
.a-cbar-txt{ flex:none; width:var(--atlas-h-btn) }
/* See `cbSyncOwner` — the shortcut belongs to the bar's lead, and another
   lead's profile is already showing that lead's own three verbs. */
html.has-cbar-other .a-cbar-txt{ display:none }
.a-cbar-no{ flex:none }

/* ══ STACKED — THE SECOND BAR GIVES WAY (2026-09-17) ═══════════════════════
   When the bar is about a DIFFERENT lead than the profile on screen, both bars
   are up at once and together they take ~120px of the bottom. Brandon's call
   on which yields: the OUTCOME bar. The action footer belongs to the lead you
   are LOOKING AT and is the reason you are on the page; the outcome bar is a
   reminder about somebody else, so it reads as the secondary and should look
   like it.

   ⚠️ ONLY WHEN STACKED. `has-cbar-stacked` requires a surface that declares an
   owner, so on the pipeline, tasks and the dashboard — where the bar is the only
   chrome — it keeps its full size. A reminder that is the only thing on screen
   is not a secondary.
   ⚠️ THE SAFE-AREA PADDING STAYS ON THE BAR, because the bar is still the
   bottom-most thing: it is the one that must clear the home indicator. What
   shrinks is the padding ABOVE it and the height of its controls. */
html.has-cbar-stacked .a-cbar{
  padding-top:var(--atlas-s6);
  padding-bottom:calc(var(--atlas-s6) + var(--atlas-safe-b));
  gap:var(--atlas-s6);
}
/* ⚠️ THE CONTROLS DO NOT SHRINK, AND THEY MUST NOT. The first cut set them to
   `--atlas-h-btn-sm` — which MEASURES 44px, identical to `--atlas-h-btn`,
   because 44 is the touch minimum and the kit holds every phone target at it.
   The rule applied and changed nothing; it is gone rather than left looking
   like it does something. So a stacked bar slims by PADDING only (99px → 91px),
   and the real space came back from the footer's dead inset below. */

/* ── THE SHEET — one lead at a time, with the queue's position stated ──── */
.a-cbar-who{
  display:flex; align-items:baseline; gap:var(--atlas-s8);
  margin-bottom:var(--atlas-s12);
}
.a-cbar-who-n{ font-size:var(--atlas-fs-lg); font-weight:var(--atlas-fw-bold); color:var(--atlas-ink) }
.a-cbar-who-c{ font-size:var(--atlas-fs-sm); color:var(--atlas-ink-3); margin-left:auto; font-variant-numeric:tabular-nums }
/* The outcomes are the timeline's own five, as a column — a phone sheet has the
   height and a wrapped pill row reads as a word cloud. */
.a-cbar-ocs{ display:flex; flex-direction:column; gap:var(--atlas-s6) }

/* ── NEXT TASK, IN THE OUTCOME SHEET (A324) ───────────────────────────────
   The section reads as one thing: a label, the task, the pills that fill it,
   then when. */
.a-cbar-nt{ display:flex; flex-direction:column; gap:var(--atlas-s8); margin-top:var(--atlas-s14) }
.a-cbar-nt-l{ font-size:var(--atlas-fs-2xs); font-weight:var(--atlas-fw-semi);
  letter-spacing:.02em; color:var(--atlas-ink-3) }
/* Date and time share a row — they are one answer, and stacking them made the
   section taller than the note it sits above. */
.a-cbar-when{ display:flex; gap:var(--atlas-s8); align-items:flex-end }
.a-cbar-when > *{ flex:1 1 0; min-width:0 }
/* The quick-date row. Wraps rather than scrolls: four short words fit a phone,
   and a scroller hides the last option behind an edge nobody sees. */
.a-whens{ display:flex; flex-wrap:wrap; gap:var(--atlas-s6) }
/* ⚠️ THE TASK-TYPE PILLS RUN SMALLER SO FOUR FIT ONE ROW (Brandon, 2026-09-17).
   MEASURED at 390px: the row is 358px and four pills at the base size needed
   392 — 34px over, so "Email them" wrapped and the section cost an extra line
   above the note. The type step is a shortcut you glance at, not the section's
   headline, so it is the right thing to run quieter than the date row beneath
   it (which fits as-is and is left alone).
   ⚠️ SIZED DOWN, NOT TRUNCATED — the labels are what land in the task text, so
   shortening them would change what gets written down.
   ⚠️ IT STILL WRAPS AT LARGER TEXT SIZES, and that is correct: type scales and
   layout does not (the text-size law), so four fixed pills cannot survive
   1.25×. Wrapping is the honest outcome there; the alternative is clipping a
   label somebody chose. */
.a-cbar-tkp{ display:flex; flex-wrap:wrap; gap:var(--atlas-s4) }
.a-cbar-tkp .a-pill{ padding:0 var(--atlas-s8); font-size:var(--atlas-fs-2xs) }
.a-cbar-oc{
  display:flex; align-items:center; gap:var(--atlas-s8);
  width:100%; min-height:var(--atlas-h-btn);
  padding:0 var(--atlas-s12);
  background:transparent; border:var(--atlas-bw) solid var(--atlas-line);
  border-radius:var(--atlas-r-md);
  color:var(--atlas-ink); font-size:var(--atlas-fs-md); text-align:left;
  cursor:pointer;
}
.a-cbar-oc:active{
  transform:var(--atlas-press-t, translateY(var(--atlas-press)));
  transition:var(--atlas-press-in, none);
}
@media (pointer: fine){ .a-cbar-oc:active{ background:var(--atlas-bg-3) } }
.a-cbar-oc.is-on{ border-color:var(--atlas-act-call); color:var(--atlas-act-call); font-weight:var(--atlas-fw-semi) }
.a-cbar-note{ margin-top:var(--atlas-s12) }
/* The commit wears the CALL colour, not the accent — same green as the bar that
   asked for it and the pill you just chose (see cbSheetFoot's note). */
.a-btn-p.a-cbar-save{ background:var(--atlas-act-call); color:var(--atlas-on-accent) }
/* ⚠️ A TEXT'S COMMIT WEARS THE TEXT COLOUR (MB176), the same token the timeline
   icon and the composer pill already use — so the bar, the sheet and the row it
   creates read as one thread. (0,3,0) beats `.a-btn-p.a-cbar-save` without
   depending on source order, which is the same reason the green above is
   written that way. */
.a-btn-p.a-cbar-save.is-text{ background:var(--atlas-act-text) }


/* ══ HOLD MENU — THE ANCHORED CONTEXT MENU (MB140) ═════════════════════════
   One asset, every authored record: a Huddle message, a CRM timeline entry.
   The verbs are the surface's to declare; the anatomy is the kit's.

   ⚠️ ANCHORED, NOT BOTTOM-PINNED. The menu springs from the item you pressed.
   ⭐ NO DIM, NO LIFT (MB140 amended, Brandon 2026-10-08: *"just have the popup …
   the highlighting we do looks cheap"*) — it imitated iOS's context menu
   without the BLUR its material depends on, which our laws ban. The scrim is
   transparent (it still catches the dismiss) and the clone is an empty spacer
   that keeps the layout around the REAL row.
   ⚠️ Phone/coarse only. On a pointer device the row's own hover toolbar is
   the affordance and always has been (MB115 — desktop is untouched). */
.hm{ position:fixed; inset:0; z-index:var(--atlas-z-popover) }
.hm-scrim{ position:absolute; inset:0;
  /* ⭐ TRANSPARENT (2026-10-08, MB140 amended): no dim — the popup alone. The
     element stays because it is what catches the tap outside (trap 38: a real
     element absorbs the dismiss; a shadow or nothing cannot). */
  background:transparent;
  opacity:0; transition:opacity var(--atlas-dur-fast) var(--atlas-ease-out) }
.hm.is-in .hm-scrim{ opacity:1 }
/* ⚠️ THE KIT'S SPRING, NOT A TRANSITION (Brandon, 2026-09-12). `--atlas-spring-open`
   is the open spring — a gentle overshoot to 1.0015 and settle — and it MUST be
   paired with its own `--atlas-spring-open-dur`: the token block's own rule is
   that each spring ships with its natural settling duration, and running one at
   a foreign duration changes its velocity. This is CSS rather than `K.spring`
   because nothing here is finger-tracked; the kit's rule is that anything a
   finger can CATCH goes through the JS spring. */
.hm-wrap{ position:absolute; display:flex; flex-direction:column;
  align-items:flex-start; gap:var(--atlas-s8);
  opacity:0;
  transition:opacity var(--atlas-dur-fast) var(--atlas-ease-out);
  /* ⚠️⚠️ THE WRAP IS A POSITIONING BOX, NOT A TARGET (MB164, Brandon: *"tapping
     the grey space next to the menu doesn't close it. I have to go up to above
     the emoji bar"*). It is `align-items:flex-start`, so it is as WIDE as its
     widest child — the reaction bar — while the menu beneath is narrower. The
     grey to the right of the menu therefore belongs to the WRAP, which has no
     dismiss handler, so taps there did nothing; only above the bar cleared the
     wrap entirely and reached the scrim. MEASURED: wrap 24..378, menu 24..228,
     and `elementFromPoint` at 268 returned `.hm-wrap`.
     The wrap stops taking events and its children take their own back, so the
     empty space inside it falls through to the scrim like the space outside it
     already did. */
  pointer-events:none }
.hm-wrap > *{ pointer-events:auto }
.hm.is-in .hm-wrap{ opacity:1 }
/* ⭐ EACH HALF SPRINGS *FROM* THE ITEM, which is the whole point of anchoring:
   the bar sits above the subject so it grows from its BOTTOM edge, the menu
   sits below so it grows from its TOP. Scaling the wrap as one box would grow
   both away from a shared centre and read as a panel arriving, not as a menu
   coming out of the thing you pressed. Flipped, the two swap (the wrap carries
   `is-flip`). */
.hm-bar, .hm-menu, .am-menu{
  transform:scale(.9);
  transition:transform var(--atlas-spring-open-dur) var(--atlas-spring-open) }
.hm-bar{ transform-origin:bottom left }
.hm-menu{ transform-origin:top left }
.hm-wrap.is-flip .hm-bar{ transform-origin:top left }
.hm-wrap.is-flip .hm-menu{ transform-origin:bottom left }
.hm.is-in .hm-bar, .hm.is-in .hm-menu, .am.is-in .am-menu{ transform:none }

/* ── THE EXIT (MB150) ──────────────────────────────────────────────────────
   ⚠️ IT IS THE SHAPE MIRRORED, NOT THE TIMING. Each half collapses back into
   the SAME origin it grew from, so the menu reads as going back into the row it
   came out of — but on `--atlas-ease-in` at `--atlas-dur-fast`, not on the open
   spring: an overshoot on the way out reads as indecision, and 610ms of it
   stands between a person and the thing they just picked. Apple's menus resolve
   it the same way — generous in, brisk out.
   The scrim and the wrap fade on the same beat, so nothing is left hanging
   behind a collapsed menu. */
.hm.is-out .hm-scrim{
  opacity:0;
  transition:opacity var(--atlas-dur-fast) var(--atlas-ease-in);
}
.hm.is-out .hm-wrap{
  opacity:0;
  transition:opacity var(--atlas-dur-fast) var(--atlas-ease-in);
}
.hm.is-out .hm-bar, .hm.is-out .hm-menu,
.am.is-out .am-menu{
  transform:scale(.9);
  transition:transform var(--atlas-dur-fast) var(--atlas-ease-in);
}
.am.is-out .am-menu{ opacity:0; transition:transform var(--atlas-dur-fast) var(--atlas-ease-in),
                                           opacity var(--atlas-dur-fast) var(--atlas-ease-in) }
/* The clone never sprang in, so it does not spring out — it fades with the
   wrap, which is what "a picture of a row that is already on screen" leaving
   looks like. */
.hm.is-out .hm-clone{ transition:none }

@media (prefers-reduced-motion: reduce){
  /* ⚠️ THE NODE IS STILL REMOVED ON A TIMER, so cutting the duration here is
     safe — a transition that never runs fires no `transitionend`, which is why
     the JS never waited for one. */
  .hm.is-out .hm-scrim,
  .hm.is-out .hm-wrap,
  .hm.is-out .hm-bar,
  .hm.is-out .hm-menu{ transition-duration:1ms }
}
/* The clone is a PICTURE of a row that is already on screen — it does not
   spring in, it is simply what you were already looking at, now lit. */
.hm-clone{ transition:none }
/* The clone is a PICTURE of the row. It takes the surface's own classes with
   it, so it renders from the surface's stylesheet rather than from a second
   description of what a message looks like. */
/* ⚠️ NO PADDING (MB153). Brandon: *"it should just outline and copy."* The
   padded card was a second shape around the row — the copy rendered narrower
   than the thing it copied and inset from it, which is visible the moment the
   original is hidden underneath. The lift is the row at ITS OWN SIZE, on the
   card's ground. */
.hm-clone{ background:transparent; padding:0;
  /* An empty spacer now (MB140 amended, 2026-10-08) — the row's height, so the
     bar and menu sit around the REAL row; it must never take a tap. */
  pointer-events:none !important; max-height:46dvh; overflow:hidden }
/* THE LADDER, NOT A CAPSULE (Brandon, 2026-09-12). The bar and the menu are
   two halves of one popup, so they take the corner the rest of the system
   takes; a 999px pill is its own shape language and would make the bar read as
   a control rather than a surface. */
.hm-bar{ display:flex; align-items:center; gap:var(--atlas-s2);
  background:var(--atlas-bg-1); border:var(--atlas-bw) solid var(--atlas-line);
  border-radius:var(--atlas-r-lg); box-shadow:var(--atlas-lift-ctl);
  padding:var(--atlas-s4) var(--atlas-s6); max-width:100% }
/* ⚠️ RAW UNICODE, NEVER AN IMAGE — this is what makes the emoji the DEVICE'S
   (Apple Color Emoji on iOS, Noto Color Emoji on Android). No font-family here
   on purpose: Onest carries no emoji glyphs, so the OS font resolves them. */
.hm-rxb{ display:grid; place-items:center; flex:none;
  width:var(--atlas-h-btn); height:var(--atlas-h-btn); padding:0;
  border:0; background:none; cursor:pointer; border-radius:var(--atlas-r-md);
  font-size:25px; line-height:1; -webkit-tap-highlight-color:transparent }
.hm-rxb:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press)));
  transition:var(--atlas-press-in, none) }
@media (pointer: fine){ .hm-rxb:active{ background:var(--atlas-bg-3) } }
@media (hover: hover){ .hm-rxb:hover{ background:var(--atlas-bg-2) } }

/* ⭐ ONE SKIN, WORN BY BOTH MENUS (MB156). `.hm-menu` is the held one, `.am-menu`
   the tapped one — the same declaration, so they cannot drift. */
.hm-menu, .am-menu{ min-width:214px; max-width:min(100%, calc(100vw - var(--atlas-s16)));
  background:var(--atlas-bg-1); border:var(--atlas-bw) solid var(--atlas-line);
  border-radius:var(--atlas-r-lg); box-shadow:var(--atlas-lift);
  overflow:hidden }

/* ── `K.menu`'s own frame ──────────────────────────────────────────────────
   ⚠️ NO DIMMING SCRIM, and that is the difference between the two assets. A
   HOLD interrupts — it lifts the thing you are touching and dims everything
   else. A TAP asks a question; dimming the page for "Copy / Select text /
   Delete" raised from a kebab would make a small choice feel like a modal. The
   layer is there to catch the dismiss, and it is transparent. */
.am{ position:fixed; inset:0; z-index:var(--atlas-z-popover) }
.am-dismiss{ position:absolute; inset:0; background:transparent }
.am-menu{ position:absolute; opacity:0;
  transition:opacity var(--atlas-dur-fast) var(--atlas-ease-out) }
.am.is-in .am-menu{ opacity:1 }

/* ══ `.a-menu` — THE SAME MENU, RAISED BY A TAP (MB156) ════════════════════
   Brandon, 2026-09-13: *"you are literally taking our press and hold popup but
   only taking the parts you need. the parts that you are taking should be
   identical across the two assets."* So they are not copied — the rules below
   NAME BOTH, which is the only version of "identical" that cannot drift.

   ⚠️ WHAT IS TAKEN IS SMALL, because `.pop` already is most of a menu: it
   carries the same ground, the same hairline, the same `--atlas-r-lg` and the
   same `--atlas-lift` as `.hm-menu` does. The two things it lacks are the
   PADDING around the rows and the ROW ITSELF — so those are the two things
   shared, and nothing else is restated.

   ⚠️ THE ROWS KEEP THEIR OWN CLASS. Nineteen anchored menus already render
   `.pick-row`, so re-pointing that class INSIDE `.a-menu` means a surface joins
   by adding one word to its pop and deleting its own geometry — no markup
   changes, no second row vocabulary to learn, and `.pick-row` everywhere else
   (pickers, sheets, lists) is untouched.

   ⚠️ WHY A MENU IS NOT A PICKER, given both use `.pick-row`: a picker's row
   carries a VALUE you are choosing between, so it sits tighter and reads as a
   list; a menu's row is a VERB you are about to run, so it takes the hold
   menu's rung and its press. Same element, two jobs, and the container says
   which. */
.hm-menu, .a-menu{ padding:var(--atlas-s4) }
/* ⭐ THE REACTIONS AS THE CARD'S TOP ROW (MB140 amended, 2026-10-08). Same
   44px targets (the tap floor holds); the GLYPH is smaller so the row reads as
   part of the menu rather than a toolbar bolted on. Five fit the menu's own
   width, so the card stays the compact one. A hairline separates the two jobs. */
.hm-rx{ display:flex; justify-content:space-between; align-items:center;
  padding:0 0 var(--atlas-s4); margin:0 0 var(--atlas-s4);
  border-bottom:var(--atlas-bw) solid var(--atlas-line) }
.hm-rx .hm-rxb{ font-size:21px }

.hm-row,
.a-menu .pick-row{ display:flex; align-items:center; gap:var(--atlas-s10); width:100%;
  padding:11px var(--atlas-s10); border:0; background:none; cursor:pointer;
  border-radius:var(--atlas-r-md); text-align:left;
  font-size:var(--atlas-fs-md); color:var(--atlas-ink);
  -webkit-tap-highlight-color:transparent }
.hm-label{ flex:1; min-width:0 }
.hm-ic{ flex:none; color:var(--atlas-ink-3); display:flex }
.a-menu .pick-label{ flex:1; min-width:0 }
.hm-row:active,
.a-menu .pick-row:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press)));
  transition:var(--atlas-press-in, none) }
@media (pointer: fine){ .hm-row:active, .a-menu .pick-row:active{ background:var(--atlas-bg-2) } }
@media (hover: hover){ .hm-row:hover, .a-menu .pick-row:hover{ background:var(--atlas-bg-2) } }
/* A18 — danger is TEXT-coloured until it is the committed action, never a
   filled block; and a separator earns its place only before it, the way
   Apple's own menus group the destructive verb away from the reversible ones. */
.hm-row.is-danger .hm-label{ color:var(--atlas-urgent) }
.hm-row.is-danger .hm-ic{ color:var(--atlas-urgent) }
.a-menu .pick-row.is-danger{ color:var(--atlas-urgent) }
/* The current value in a SELECT menu — the one thing a verb menu never shows. */
.hm-row.is-on .hm-label{ font-weight:var(--atlas-fw-semi) }
.hm-row.is-on .hm-ic{ color:var(--atlas-accent) }
/* The heading of a group (`{ head }`) — the noun the verbs below it share. Quiet
   on purpose: smaller than a row, ink-3, never a target. Its own `is-sep` draws
   the hairline above it, exactly as a row's does. */
.hm-head{ padding:10px var(--atlas-s10) 4px; font-size:var(--atlas-fs-xs);
  font-weight:var(--atlas-fw-semi); color:var(--atlas-ink-3) }
.hm-head.is-sep{ margin-top:var(--atlas-s4); border-top:var(--atlas-bw) solid var(--atlas-line); padding-top:12px }
.hm-row.is-sep,
.a-menu .pick-row.is-sep{ margin-top:var(--atlas-s4); border-radius:0; padding-top:12px;
  border-top:var(--atlas-bw) solid var(--atlas-line) }
/* The page beneath does not scroll while the menu is up — the menu is anchored
   to a rect that would stop being true the moment it moved. */
html.a-hm-open, html.a-hm-open body{ overflow:hidden }
/* Reduce Motion keeps the fade and drops the spring — the menu still ARRIVES,
   it just does not travel (the same split K.tabs makes). */
@media (prefers-reduced-motion: reduce){
  .hm-bar, .hm-menu, .am-menu{ transform:none; transition:none }
}


/* ══ PULL TO REFRESH (MB142) ═══════════════════════════════════════════════
   ⚠️ IT SITS ON `bg-2`, NOT `bg-1`, AND THAT IS THE FIX. The version this
   replaces was a WHITE disc with a hairline border on a WHITE page — measured
   firing perfectly (indicator created, opacity 1, the refresh called) and
   invisible in the screenshot. A cue you cannot see is not a cue.
   ⚠️ The z-index is the kit's ladder and it RESOLVES here because the
   indicator mounts inside the shell; on `document.body` the semantic tier does
   not reach it and this computed `auto` (measured: 200 on the shell,
   unresolved on body — trap 60's family). */
.a-ptr{
  position:fixed; left:50%; top:calc(var(--atlas-safe-t, 0px) + 10px);
  width:36px; height:36px; margin-left:-18px;
  display:flex; align-items:center; justify-content:center;
  background:var(--atlas-bg-2, #f2f4f7);
  border:var(--atlas-bw, 1px) solid var(--atlas-line-2, #cbd0d8);
  border-radius:var(--atlas-r-full, 999px);
  box-shadow:var(--atlas-lift-ctl);
  color:var(--atlas-ink-3);
  opacity:0;
  z-index:var(--atlas-z-nav, 200);
  pointer-events:none;
}
/* ARMED IS THE ONE MOMENT IT SPEAKS — past the threshold, let go and it goes.
   The accent is the system's one colour and it carries meaning here (C5). */
.a-ptr.is-armed{ color:var(--atlas-accent); border-color:var(--atlas-accent) }
.a-ptr.is-busy svg{ animation:aPtrSpin .8s linear infinite }
@keyframes aPtrSpin{ to{ transform:rotate(360deg) } }
@media (prefers-reduced-motion:reduce){ .a-ptr.is-busy svg{ animation:none } }

/* ⭐ THE CLEAR ROW IN A LEAD PICKER (opt-in, `K.leadPick({clear})`) — modelled
   on the tags picker's create row, which is the same shape of answer: the thing
   you reach for when the LIST is not what you need. It sits under the search and
   OUTSIDE the scroll, so it cannot be hidden by scrolling, and it carries the
   accent because it is an action rather than a row of data. */
.pick-clear{
  display:block; width:100%; text-align:left;
  font:inherit; font-size:var(--atlas-fs-xs); color:var(--atlas-accent);
  background:none; border:0; border-bottom:var(--atlas-bw) solid var(--atlas-line);
  padding:var(--atlas-s8) var(--atlas-s10); cursor:pointer;
}
@media (hover: hover){ .pick-clear:hover{ background:var(--atlas-bg-2) } }
.pick-clear:active{ transform:var(--atlas-press-t, translateY(var(--atlas-press))); transition:var(--atlas-press-in, none) }

/* ═══ THE VIEWER'S FILMSTRIP AND GRID (`K.preview(items, at, {film:true})`) ══
   ⭐ PORTED FROM v3's OWN LIGHTBOX (A303) rather than invented — same strip,
   same grid, same behaviour the consumer site already ships. What changed is
   the palette: v3 hardcodes `#fff` and `rgba(255,255,255,.12)`, and this
   primitive already HAS those as `--pv-ink` / `--pv-ground`, so the port reads
   from the tokens the viewer declared for exactly this.
   ⚠️ Rendered only when a caller asks for it — no `.has-film`, no strip, and
   every existing consumer (Huddle, Drive, University) is untouched. */
/* ⚠️ THE THIRD ROW IS DECLARED, NOT IMPLIED. `.a-pv` ships two rows (bar,
   content); a strip at `grid-row:3` would rely on an implicit track, which is
   the same class of mistake as A297's `grid-row:-1` — it happens to work and
   nothing in the template says so. Scoped to film mode, so a viewer without a
   strip keeps exactly the two rows it was written with. */
.a-pv-wrap.has-film .a-pv{ grid-template-rows:auto minmax(0, 1fr) auto }
.a-pv-film{
  grid-column:1 / -1; grid-row:3;
  display:flex; gap:var(--atlas-s8);
  padding:var(--atlas-s12) var(--atlas-s16);
  overflow-x:auto; scrollbar-width:none;
}
.a-pv-film::-webkit-scrollbar{ display:none }
.a-pv-th{
  flex:0 0 84px; height:58px; padding:0; cursor:pointer;
  border:2px solid transparent; border-radius:var(--atlas-r-sm);
  background-size:cover; background-position:center; background-color:var(--pv-ground);
  opacity:.6; transition:opacity var(--atlas-dur-fast) var(--atlas-ease-out),
                        border-color var(--atlas-dur-fast) var(--atlas-ease-out);
}
@media (hover: hover){ .a-pv-th:hover{ opacity:.85 } }
.a-pv-th.is-on{ opacity:1; border-color:var(--pv-ink) }
/* THE GRID — the same items, laid out to be FOUND rather than walked to. */
.a-pv-grid{
  display:none; grid-column:1 / -1; grid-row:2 / 4;
  /* ⚠️⚠️ `min-height:0` AND `align-self:stretch` — BOTH, and the second is the
     one I left out. `.a-pv` is `align-items:center` (it centres the photo), so a
     grid item takes its CONTENT height and is then centred in its track: with 38
     photos that was a 1179px box in an 870px track, overflowing 99px ABOVE the
     viewport and straight through the bar, and never scrolling because the box
     was already as tall as everything in it. `min-height:0` alone does not help
     while the item is free to be its content height — stretch is what pins it to
     the track so `overflow-y` has something to overflow. Measured both ways. */
  align-self:stretch;
  min-height:0; overflow-y:auto; overscroll-behavior:contain;
  padding:var(--atlas-s8) var(--atlas-s16) var(--atlas-s24);
  grid-template-columns:repeat(auto-fill, minmax(220px, 1fr));
  gap:var(--atlas-s10);
  align-content:start;             /* rows pack from the top, never centred */
}
.a-pv-gi{
  aspect-ratio:3/2; padding:0; border:0; cursor:pointer;
  border-radius:var(--atlas-r-md);
  background-size:cover; background-position:center; background-color:var(--pv-ground);
  transition:filter var(--atlas-dur-fast) var(--atlas-ease-out);
}
@media (hover: hover){ .a-pv-gi:hover{ filter:brightness(.92) } }
/* the mode swap — one class on the wrap decides which body is showing */
.a-pv-wrap.is-grid .a-pv-img,
.a-pv-wrap.is-grid .a-pv-arrow,
.a-pv-wrap.is-grid .a-pv-film{ display:none }
.a-pv-wrap.is-grid .a-pv-grid{ display:grid }
/* a phone has no room for a strip beside the photo — the grid is the finder */
.a-phone .a-pv-th{ flex-basis:64px; height:46px }

/* ── BRAND GLYPH IN A TOOLBAR BUTTON (2026-09-22) ────────────────────────────
   A product mark (the Google Sheets icon) inside a standard `.a-tb is-icon` —
   two consumers (CRM pipeline, Transactions), so the rules are the kit's (the
   table.css lesson). `.is-brand-off` wears the link state: muted until the
   thing exists, full colour once it does — still clickable either way. */
.a-tb .tb-brand{ flex:none }
.a-tb.is-brand-off .tb-brand{ filter:grayscale(1); opacity:.5 }
