/* Music Note — Loading Screen
   Origin: Figma PlayGround / node 167:3 (artboard 1440 x 1024).
   The artboard is the reference, not the implementation: type and controls
   flow and size fluidly, while the artwork keeps its design-pixel geometry
   and scales as one unit (see the fit script in index.html). */

:root {
  /* THE PANEL'S ON-SCREEN WIDTH, and the only place it is written down.
     Invariant 15's header arithmetic is all derived from it — the nav's slide,
     the place chip's anchor and both of its max-widths — and that arithmetic
     has been broken twice by someone changing one number and not the rest.
     Every dependent value below is now expressed in terms of this:

       nav slide           = W
       chip anchor         = W + 168   (24 inset + W + 128 collapsed nav + 16 gap)
       chip max-width      = 100% - (W + 192)
       chip centred (1025) = 50% + W/2, max-width 100% - (W + 336)
       disc centre         = W - radius, so the rim lands on the trailing edge

     Was 400px through 2026-09-16; 520 is that plus 30%. */
  --panel-w: 520px;

  --bg: #0d0d0d;
  --cta: #fdcb6e;
  --cta-rgb: 253, 203, 110;
  --fg: #ffffff;
  /* The hairline around a map note's OUTER edge — the outside of the grey
     #DADADA track ring, not the coloured disc inside it. It went on the disc
     first, which drew a line in the middle of the pin instead of around it.

     Dark rather than the white ring most map pins use, because the pin's outer
     ring is already a light grey against a light OpenFreeMap basemap; a white
     outline there is invisible, and a dark one is the only thing that separates
     the two. One value to change if a different treatment is wanted.

     Applied as `stroke` on a circle in each sprite symbol, through a style
     attribute: `var()` does not work in a presentation attribute, and custom
     properties inherit into a <use> shadow tree. The circle's radius is
     per-symbol — the same design is exported at four different scales, and the
     ring already touches the top of every viewBox, so the outline sits just
     INSIDE the outer edge. There is no room outside it. */
  --pin-edge: rgba(13, 13, 13, 0.35);

  /* bounding box of the artwork in original design pixels */
  --art-w: 1155.7px;
  --art-h: 751.7px;
  --art-scale: 0.5;

  /* Rings that grow out of the globe. Every ring is the same size and expands
     from --ring-start to full over --ring-cycle; the stagger spreads them
     evenly around that cycle, so at any instant you see a concentric set that
     is drifting outward rather than sitting still. Sized in vmin so the set
     relates to the viewport, not to the artwork.

     --ring-alpha is NOT the on-screen value. The keyframes fade opacity as a
     ring travels, and that MULTIPLIES this number; a 1px stroke is antialiased
     on top. An earlier pass at an effective 0.07-0.21 rendered as 16-50 grey
     levels on a rgb(13,13,13) page and the user could not see it at all.
     Judge any retune by the rendered grey, never by this token. */
  --ring-rgb: 255, 255, 255;
  /* Peak opacity, reached as a ring clears the globe; it decays from there as
     the ring travels (see the keyframes). History, because this token has been
     over- and under-shot in both directions: 0.28 measured as an effective 0.27
     and read as far too faint; 0.57 (effective 0.555, grey 147 against the
     page's 13) was then signed off but later read as too strong. 0.42 sits
     between them. */
  /* 2026-09-09: 0.42 -> 0.52, asked for as "10% less transparent" — read as ten
     points on the 0-100 opacity scale, not a 10% relative nudge (which would be
     0.46 and barely visible). Judged as invariant 8 demands, by the RENDERED
     grey against the #0d0d0d page: 115 -> 139. That lands between the old 0.42
     and the 0.57 (grey 151) that was previously signed off and then read as too
     strong, so there is headroom left in both directions. */
  --ring-alpha: 0.52;     /* peak, as a ring clears the globe */
  /* Must match the number of .ring spans in the markup. It also sets the
     SPACING — the travel distance is divided by it — so dropping 10 to 6 is
     what opened the set from 57px to ~95px apart on desktop. Raising it back
     crowds the rings again; it is not a free knob. */
  --ring-count: 6;
  /* A ring's full-travel diameter, as a MULTIPLE OF THE GLOBE — not of the
     viewport. It was 180vmin, which decoupled the two: the globe is sized from
     whatever height .art-slot has left after the title, the buttons and the
     credit, while vmin follows the whole window. On a short, wide viewport the
     slot is squeezed and the globe shrinks, vmin does not, and the rings
     outgrow the sphere they are supposed to be emerging from behind.

     Measured at 1032x780 before the change: a ring reached 348.2px at the 6%
     mark where its opacity hits full, against a globe of 350.5px — 2.3px of
     margin, and negative on a shorter window. That is the "sometimes they are
     not behind the globe". Tied to the globe it is 312.9 against 350.5 at every
     size, because both now scale with --art-scale together.

     3.6 is the largest span that keeps the 6% ring inside the globe:
     scale at 6% is 0.248, and 0.248 x 3.6 = 0.89 of the globe's diameter.
     The cost is that on a very short, wide window the outermost ring no longer
     quite reaches the left and right edges. It is nearly transparent out there
     by design, and a ring born in front of the sphere is the worse artefact. */
  --globe-size: 550px;    /* must match .globe's width/height */
  --ring-span: 3.6;
  --ring-start: 0.2;      /* scale at birth — inside the globe, so hidden by it */
  /* One ring's whole journey, globe to edge. This also sets how often a new
     ring appears — cycle / --ring-count — but not the spacing between them,
     which is fixed by the travel distance and the count. So changing it slows
     the motion without thinning the set. */
  --ring-cycle: 24s;

  /* Type scale — whole pixel steps. The widest step matches the Figma
     artboard for the title (56 / 18); the tagline sits at 20px. */
  --size-title: 56px;
  --size-body: 20px;
  --size-label: 18px;

  /* Spacing scale — whole pixels, every value a multiple of 4.

     These were clamp(min, Nvh, max) until now, and the switch to steps is the
     whole point rather than a side effect: fluid interpolation lands on a
     fractional pixel at nearly every viewport size (the title/tagline gap was
     measuring 9.42px at 785px tall, and 9.74px at 812px), so no amount of
     picking round endpoints keeps a clamp on the grid. Stepping is the same
     decision already made for the type scale above, for the same reason.

     Steps below are chosen to land within ~2px of what the clamps were
     producing at each common size, so this is a regularisation, not a
     re-spacing. The one deliberate change is --gap-title, which was resolving
     to 9-10px and is now 12. */
  /* THE 4-POINT GRID APPLIES TO SPACING EVERYWHERE, NOT JUST TO THIS SCALE
     (extended app-wide 2026-09-18). Every `padding`, `margin` and `gap` in this
     file is a multiple of 4 EXCEPT the list below, and each exception is
     off-grid because something was measured — not because it drifted. Snap a
     new value to the grid; do NOT snap one of these.

       - `.visually-hidden` and `.card__close` `margin: -1px` — the standard
         screen-reader clip idiom. 1px is the whole technique.
       - `.map-place__clock` `padding: 2px 6px` with `margin: -2px -6px` — a
         CANCELLING PAIR (invariant 10). It is what keeps the digits exactly
         where the old `<span>` put them. The two must always be equal and
         opposite; changing one alone moves the clock.
       - `.map-place__clock::before` `inset: -10px -4px` — the 44px tap target.
         The clock's own box is 24px, so 24 + 10 + 10 = 44. An on-grid -8 gives
         40 and fails it; the inset cannot be on-grid unless the control is.
       - `.drop__genre-del::before` `inset: -9px -5px -9px -4px` (and -10/-6/-5
         at the wider breakpoint) — the same job, asymmetric on purpose so the
         target does not overlap the chip's own label.
       - `.drop__genre[aria-pressed="true"]` `padding: 7px 11px`, and
         `.drop__genre--custom[aria-pressed="true"]` `padding-right: 35px`/`39px`
         — always the unpressed value MINUS ONE, absorbing the 1px border so the
         row does not reflow as chips toggle. Derived: snap the base, and these
         follow it.
       - `.map-search__toggle` `padding-right: 6px` — sets the 6px gap between
         the magnifier and the placeholder while keeping the icon's 18px inset
         from the pill's edge unchanged. Both of those were measured.
       - `.map-place__clock` `gap: 6px` — the space between the digits and their
         caret, and THE SAME 6px as the line above by intent (2026-09-19): one
         icon-to-text gap serving both ends of the bar. It is derived from that
         measurement rather than chosen, which is what puts it on this list
         instead of on the grid. Change the two together or not at all.
       - `.card__wave-row` `gap: 2px` — the space between waveform BARS. That is
         a graphic's internal rhythm, not layout spacing; at 4px the waveform
         becomes a different drawing.

     Sizing, radii and type are deliberately NOT governed by this: the radii are
     shape tokens (50/100/999px), the type follows its own scale above, and
     several box sizes are fixed by MapLibre (29px controls) or by tap-target
     minimums (44px). */
  --pad-top: 80px;
  --pad-bottom: 40px;
  --pad-inline: 40px;
  --gap-title: 12px;      /* .title -> .tagline */
  --gap-actions: 24px;    /* artwork -> the button row */
}

/* Roomy windows — the 1024px-tall artboard this was drawn against. */
@media (min-height: 1000px) {
  :root {
    --pad-top: 100px;
    --pad-bottom: 52px;
    --gap-actions: 32px;
  }
}

/* Wide and short: a laptop window. The reclaimed height goes to the artwork
   instead of the padding. Narrow-and-short (a phone) is deliberately excluded
   — it has no spare width to trade for the same effect. */
@media (min-width: 641px) and (max-height: 900px) {
  :root {
    --pad-top: 32px;
    --pad-bottom: 28px;
    --gap-actions: 16px;
  }
}

/* Very short, at any width. */
@media (max-height: 560px) {
  :root {
    --pad-top: 24px;
    --pad-bottom: 24px;
    --gap-title: 8px;
    --gap-actions: 16px;
  }
}

@media (max-width: 1199px) {
  :root {
    --size-title: 44px;
    --size-body: 20px;
    --size-label: 18px;
  }
}

@media (max-width: 767px) {
  :root {
    --size-title: 36px;
    --size-body: 18px;
    --size-label: 16px;
    --pad-inline: 24px;
  }
}

@media (max-width: 479px) {
  :root {
    --size-title: 30px;
    --size-body: 16px;
    --size-label: 16px;
    --pad-inline: 20px;
  }
}

* { box-sizing: border-box; }

/* The hidden attribute only gets `display: none` from the UA stylesheet, and
   ANY author display rule beats it. Three elements here are toggled with
   .hidden and styled `display: flex`, so all three ignored it: the custom-genre
   input sat open from the start, and the card's countdown and the chip's clock
   each showed a stray separator before they had anything to say. */
[hidden] { display: none !important; }

html, body {
  margin: 0;
  background: var(--bg);
  /* NO PULL-TO-REFRESH (2026-10-01). A downward swipe on a phone — most often
     on the open record, which now closes on that swipe (card.js) — reloaded
     the whole page and dropped the user back on the globe. */
  overscroll-behavior: none;
}

/* TEXT SELECTION IS STYLED, NOT LEFT TO THE BROWSER DEFAULT (2026-09-25).
   Reported directly: an unstyled selection reads as "light purple" and hard
   to read. That colour was never set anywhere in this file — it is the
   OS/browser default highlight, which on a Mac follows the SYSTEM Accent /
   Highlight Colour setting. That is exactly the problem: it is out of this
   app's control, varies per visitor, and was never checked against any of
   this app's own surfaces (the dark vinyl panel, the kraft sleeve, the
   landing page).
   `::selection` REPLACES BOTH `background` and `color` at once, so a single
   rule can work everywhere regardless of what is underneath — the selection
   fully repaints over the surface rather than tinting it. That is what
   makes ONE global rule enough instead of one per surface (dark app chrome,
   light kraft sleeve): `var(--cta)` (the app's own gold, already used for
   warnings and the primary CTA) as a SOLID block with near-black text reads
   as branded rather than generic, and measures 12.91:1 — `#fdcb6e` against
   `#0d0d0d`, both fixed values rather than `currentColor`, so it can never
   end up light-on-light if a future surface's own text colour changes. */
::selection {
  background: var(--cta);
  color: #0d0d0d;
}

body {
  font-family: "Inter", -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
  -webkit-font-smoothing: antialiased;
  color: var(--fg);
}

/* FORM CONTROLS DO NOT INHERIT `font-family`, AND THAT IS NOT A DEFAULT WORTH
   LIVING WITH (2026-09-18). Every `<button>`, `<input>`, `<select>` and
   `<textarea>` otherwise falls back to the UA's own face — measured, sixteen
   controls in this app were computing to **Arial at 13.3333px**: the four map
   buttons, the search toggle and clear, both panel close buttons, play, copy,
   and the visually-hidden labels inside them.
   Nothing was visibly wrong, because every one of those is icon-only or
   screen-reader-only. That is exactly what makes it worth fixing pre-emptively:
   the failure is INVISIBLE UNTIL SOMEONE ADDS A LABEL, and then one control
   renders in Arial next to Inter and reads as a rendering fault rather than a
   missing declaration. Discover would have hit this the day it gained a visible
   word, had it stayed in the header bar.
   `font-family`, NOT the `font` shorthand: `font: inherit` would drag
   font-size and line-height along with it and resize controls that are
   currently sized by the UA's 13.3333px. This changes the face and nothing
   else — verified, thirteen controls measured identically before and after,
   including the place clock, which stays Bungee because its own rule still
   wins on specificity. */
button,
input,
select,
textarea { font-family: inherit; }

.screen {
  position: relative;
  display: flex;
  flex-direction: column;
  align-items: center;
  min-height: 100vh;
  min-height: 100dvh;
  overflow: hidden; /* lets the artwork bleed off-screen on narrow viewports */
  padding:
    max(var(--pad-top), env(safe-area-inset-top))
    var(--pad-inline)
    max(var(--pad-bottom), env(safe-area-inset-bottom));
  background: var(--bg);
}

/* ---------- Type ---------- */

.intro {
  flex: none;
  width: 100%;
  text-align: center;
}

.title {
  margin: 0;
  font-family: "Bungee", "Inter", sans-serif;
  font-weight: 400;
  font-size: var(--size-title);
  line-height: 1.2;
  letter-spacing: 1px;
  color: var(--fg);
  white-space: nowrap;
}

.tagline {
  max-width: 850px;
  margin: var(--gap-title) auto 0;
  font-weight: 400;
  font-size: var(--size-body);
  line-height: 1.35;
  text-align: center;
  text-wrap: balance;
  color: var(--fg);
}

/* The artwork sits on z-index 1 and the copy on 2, so the rings — which live
   inside .art-slot but run far wider than it — always pass behind the text
   rather than over it. */
.screen__main,
.art-slot {
  position: relative;
  z-index: 1;
}

.intro,
.actions,
.credit {
  position: relative;
  z-index: 2;
}

/* <main> is the landmark; it also has to be the column that .intro / .art-slot
   / .actions were laid out in when they were direct children of .screen. It
   takes the space left over by the credit, and .art-slot takes the space left
   over inside it — the same two-level flex the layout already relied on. */
.screen__main {
  flex: 1 1 0;
  min-height: 0;
  display: flex;
  flex-direction: column;
  align-items: center;
  width: 100%;
}

/* ---------- Artwork ---------- */

/* flex: 1 1 0 with min-height:0 so the slot takes the leftover space
   independently of the artwork's own (large) intrinsic size */
.art-slot {
  flex: 1 1 0;
  min-height: 0;
  width: 100%;
  display: flex;
  align-items: center;
  justify-content: center;
}

.art {
  position: relative;
  flex: none;
  width: var(--art-w);
  height: var(--art-h);
  transform: scale(var(--art-scale));
  transform-origin: center center;
}

/* The artwork is decorative, and the earth PNG in particular overhangs its
   550px box by ~100px on every side (the exported glow), which would otherwise
   sit on top of the copy and swallow clicks and text selection. */
.art {
  pointer-events: none;
  user-select: none;
  -webkit-user-select: none;
}

.globe {
  position: absolute;
}

.globe__inner {
  position: absolute;
}

.globe__inner img,
.globe__drop img {
  display: block;
  width: 100%;
  height: 100%;
  max-width: none;
}

/* positions below are design pixels, offset to the artwork's bounding box */

.globe { left: 319.7px; top: 97.2px; width: var(--globe-size); height: var(--globe-size); }

/* The .globe__inner box is the original PNG's footprint: the sphere plus the
   ~100px of baked glow it carried on every side. */
.globe__inner { inset: -17.67% -18.33% -19% -18.33%; }

/* ---------- Breathing rings ---------- */

/* Rings that grow out of the globe. Decorative only: aria-hidden in the markup,
   and never a pointer target.

   Only transform and opacity animate, so this stays off the layout and paint
   path entirely.

   Every ring is the same size and scales up from --ring-start; the negative,
   evenly-spread delays put each one at a different point of the same journey,
   so the set reads as concentric circles drifting outward. A ring is born at a
   scale smaller than the globe and the globe is painted over it, so it is
   simply invisible until it clears the edge — the emergence needs no mask and
   no per-breakpoint maths, which matters because the globe/ring size ratio is
   not the same on desktop and phone. */
/* The rings are drawn by an inline script in index.html onto this one canvas
   (2026-09-30) — six huge CSS-animated circles crashed iPhone Safari. Behind
   all content: .screen__main is z-index 1. */
.rings-canvas {
  position: absolute;
  inset: 0;
  width: 100%;
  height: 100%;
  z-index: 0;
  pointer-events: none;
}

/* 3D sphere fills the 550px box; the halo the PNG used to carry is redrawn
   here as a gradient behind it. Both stay hidden until globe.js confirms
   WebGL and the texture actually work. */
.globe__canvas,
.globe__glow { display: none; }

.globe--3d .globe__canvas,
.globe--3d .globe__glow { display: block; }

.globe__canvas {
  position: absolute;
  inset: 0;
  width: 100%;
  height: 100%;
  /* .art is pointer-events:none so the artwork never swallows clicks; the
     sphere opts back in because it is draggable. The 50% radius keeps the hit
     area on the globe itself rather than the corners of its bounding square. */
  pointer-events: auto;
  border-radius: 50%;
  touch-action: none;   /* a drag must rotate the globe, not pan the page */
  cursor: grab;
}

.globe--dragging .globe__canvas { cursor: grabbing; }

.globe__canvas:focus-visible {
  outline: 2px solid var(--cta);
  outline-offset: 8px;
}

.globe__glow {
  position: absolute;
  inset: -17.67% -18.33% -19% -18.33%;
  border-radius: 50%;
  background: radial-gradient(
    circle at 50% 50%,
    rgba(150, 235, 215, 0) 0 33%,
    rgba(150, 235, 215, 0.30) 37.5%,
    rgba(110, 210, 195, 0.12) 44%,
    rgba(110, 210, 195, 0) 56%
  );
}

/* WebGL unavailable, or the texture failed: bring the original render back. */
.globe--fallback .globe__inner {
  background: url(assets/earth.png) center / 100% 100% no-repeat;
}

/* Notes other "people" are dropping on the globe. globe.js creates these and
   sets transform/opacity every frame, projecting a lat/lon through the same
   matrices the sphere is drawn with; left/top stay at 0 so nothing reflows.
   Sized in the artwork's design pixels, so they scale with .art like the rest
   of the composition. Decorative: aria-hidden from JS, and never a pointer
   target, so the sphere underneath stays draggable. */
.globe__drop {
  position: absolute;
  left: 0;
  top: 0;
  width: 24px;
  height: 24px;
  pointer-events: none;
  opacity: 0;
  /* a white note over white cloud would otherwise disappear */
  filter: drop-shadow(0 1px 2px rgba(0, 0, 0, 0.55));
  will-change: transform, opacity;
}

/* ---------- Buttons ---------- */

.actions {
  flex: none;
  display: flex;
  align-items: center;
  justify-content: center;
  gap: 24px;
  width: 100%;
  margin-top: var(--gap-actions);
}

/* Hover sprouts an equaliser out of the button's top edge. The bar heights are
   the real ones from the Figma "soundwaves" frame (node 196:3) — every 4th bar
   of the 95 in that strip, so the designed rhythm survives at button width. */

.btn {
  --eq-h: 20px;            /* how far the bars stand above the button */
  position: relative;
  flex: 0 1 310px;
  height: 44px;
  padding: 0;
  border: none;
  border-radius: 8px;
  background: transparent;
  cursor: pointer;
  font: inherit;
}

/* The ring is INSIDE the button now, and it is drawn on .btn__face rather than
   on .btn — two decisions that go together, both of them non-obvious.
 
   Inside, because the equaliser stands in the 20px band directly above the top
   edge: any positive outline-offset puts the ring's top edge through the comb,
   and the bars (descendants of .btn) paint over it, so it reads as a dashed
   line rather than a ring. That collision is why focus used to be left out of
   the equaliser altogether; keeping the two apart is what lets keyboard users
   have the same feedback as hover.
 
   On .btn__face, because Chrome paints an element's outline BEFORE its
   positioned descendants — so an inset ring on .btn is completely hidden by
   .btn__face (position: absolute, inset: 0, opaque fill). Verified: invisible
   even at outline-width 6px. The old +4px ring escaped this only by sitting
   outside the face's box. .btn__eq and .btn__content paint above the face but
   neither reaches its edges, so the ring stays clear of both. */
.btn:focus-visible { outline: none; }

.btn:focus-visible .btn__face {
  outline: 2px solid var(--fg);
  outline-offset: -4px;
  border-radius: 8px;
}

/* The ring's colour has to follow whatever it now sits on. White stays right
   for the secondary — its face is transparent, so the ring lands on the
   near-black page at ~19:1 — but on the primary's #fdcb6e fill white is about
   1.5:1, under the 3:1 a focus indicator needs. Black on that fill is ~12:1,
   the same reasoning that makes the primary's label black. */
.btn--primary:focus-visible .btn__face { outline-color: #000000; }

/* --- fill / outline --- */

.btn__face {
  position: absolute;
  inset: 0;
  border-radius: 8px;
  pointer-events: none;
  transition: background-color 340ms cubic-bezier(0.4, 0, 0.2, 1);
}

/* --- equaliser --- */

/* The bars stand above the button, rooted on its top edge — so the button
   interior stays clean and the label has nothing behind it.
 
   This element is the clip window, not just a row: it is anchored bottom-up on
   the button's top edge and grows from 0 to --eq-h, which uncovers each bar
   from its base first and reads as the row rising out from behind the button.
   Animating the container's height rather than the bars' own transform is what
   keeps the two motions independent — the bars' transform stays free for the
   height loop, so the reveal and the bounce never fight over one property. */
.btn__eq {
  position: absolute;
  left: 0;
  right: 0;
  bottom: 100%;            /* sit on the top edge, grow upward */
  height: 0;
  opacity: 0;
  display: flex;
  align-items: flex-end;
  justify-content: space-between;
  gap: 4px;
  padding: 0 12px;
  overflow: hidden;
  pointer-events: none;
  /* Leaving. Still quicker than the entrance so the row clears out rather than
     lingering under a cursor that has moved on, but softened along with it.
     The opacity is the load-bearing half here: removing a running CSS
     animation reverts .btn__bar's transform instantly, and the fade is what
     hides that snap — so it has to outlast .btn__bar's own 160ms transition,
     which 200ms does. */
  transition: height 240ms ease, opacity 200ms ease;
}

/* Focus-visible is included deliberately — see .btn:focus-visible above, which
   moved the ring inside the button so it no longer crosses these bars. Touch
   has no hover and gets this on :active instead, further down. */
.btn:hover .btn__eq,
.btn:focus-visible .btn__eq {
  height: var(--eq-h);
  opacity: 1;
  /* Arriving. 340ms on a gentle curve, up from 220ms on cubic-bezier(0.22,
     0.61, 0.36, 1) — that one is an ease-out-quart, which leaves almost all of
     its distance in the first third and reads as a pop however long you make
     it. This curve eases in as well as out, so the row starts from rest and
     settles rather than snapping into place. */
  transition: height 340ms cubic-bezier(0.4, 0, 0.2, 1),
              opacity 280ms cubic-bezier(0.4, 0, 0.2, 1);
}

.btn__bar {
  flex: 1 1 0;
  max-width: 4px;
  height: calc(var(--h) * var(--eq-h));
  /* Top only. The bars are 4px wide, so a 2px radius is a full semicircle —
     rounding the bottom too curved each bar away from the button's flat top
     edge, and across 24 bars that junction read as a dotted seam instead of a
     join. Flat bottoms make them look extruded from the button. */
  border-radius: 2px 2px 0 0;
  background: currentColor;

  /* The bar is ALWAYS drawn at its full height and never scaled. It is slid
     down instead, and .btn__eq's overflow clips whatever passes below the
     button's top edge, so the visible height is (100% - translateY).
 
     This has to be a translate, not scaleY. border-radius is resolved before
     the transform, so scaleY squashes the cap with everything else: at the
     resting 0.45 the 2px round top rendered as a 2px x 0.9px ellipse, i.e.
     visibly flattened, and it only reached a true semicircle at the very top
     of each bounce. Translating leaves the cap untouched at every height, and
     the flat bottom now comes from the clip rather than from the radius. */
  transform: translateY(55%);
  /* 160ms, not the 260ms that matched the old container grow: this is the
     resting transform the bars revert to when eq-bounce is removed on
     hover-out, and it has to finish inside the 120ms opacity fade or the jump
     shows. */
  transition: transform 160ms ease;
}

.btn:hover .btn__bar,
.btn:focus-visible .btn__bar {
  animation: eq-bounce var(--dur, 620ms) var(--delay, 0s) ease-in-out infinite alternate;
}

/* negative delays start each bar mid-cycle, so the row never moves as a block */
.btn__bar:nth-child(5n+1) { --dur: 560ms; --delay: -80ms; }
.btn__bar:nth-child(5n+2) { --dur: 720ms; --delay: -300ms; }
.btn__bar:nth-child(5n+3) { --dur: 620ms; --delay: -160ms; }
.btn__bar:nth-child(5n+4) { --dur: 800ms; --delay: -420ms; }
.btn__bar:nth-child(5n+5) { --dur: 680ms; --delay: -240ms; }

/* 55% down = 45% visible, the same range the old scaleY(0.45) covered */
@keyframes eq-bounce {
  from { transform: translateY(55%); }
  to   { transform: translateY(0); }
}

/* --- content --- */

.btn__content {
  position: absolute;
  left: 50%;
  top: 50%;
  transform: translate(-50%, -50%);
  display: flex;
  align-items: center;
  white-space: nowrap;
  pointer-events: none;
}

.btn__label {
  flex: none;
  font-size: var(--size-label);
  line-height: 20px;
}

/* --- primary CTA: filled --- */

.btn--primary .btn__face { background: var(--cta); }
/* Was a black shadow tint when the bars sat inside the yellow fill; above the
   button they are on the near-black page, so they take the CTA colour instead. */
.btn--primary .btn__eq { color: var(--cta); }

.btn--primary .btn__label {
  font-weight: 600;
  color: #000000;
}

/* --- secondary: outlined --- */

.btn--secondary .btn__face { border: 1.5px solid var(--cta); }
/* A shade softer than the primary's, matching how the outline reads lighter
   than the fill. */
.btn--secondary .btn__eq { color: rgba(var(--cta-rgb), 0.72); }

.btn--secondary:hover .btn__face,
.btn--secondary:focus-visible .btn__face { background: rgba(var(--cta-rgb), 0.09); }

.btn--secondary .btn__label {
  font-weight: 500;
  color: var(--cta);
}

/* ---------- Narrow viewports ---------- */

@media (max-width: 640px) {
  .actions {
    flex-direction: column;
    /* 12px until the equaliser moved above the buttons: stacked, the lower
       button's 14px of bars ran 2px into the one above it. 20px clears them. */
    gap: 20px;
  }

  .btn {
    --eq-h: 16px;  /* shorter, so a stacked pair does not crowd the artwork */
    flex: none;
    width: 100%;
    max-width: 340px;
    height: 48px; /* comfortable touch target */
  }
}

/* Touch devices get no hover; run the equaliser on press instead so it can
   never latch on after a tap. */
@media (hover: none) {
  .btn:hover .btn__eq { height: 0; opacity: 0; }
  .btn:hover .btn__bar { animation: none; }
  .btn--secondary:hover .btn__face { background: transparent; }

  .btn:active .btn__eq {
    height: var(--eq-h);
    opacity: 1;
    transition: height 340ms cubic-bezier(0.4, 0, 0.2, 1),
                opacity 280ms cubic-bezier(0.4, 0, 0.2, 1);
  }
  .btn:active .btn__bar {
    animation: eq-bounce var(--dur, 620ms) var(--delay, 0s) ease-in-out infinite alternate;
  }
  .btn--secondary:active .btn__face { background: rgba(var(--cta-rgb), 0.09); }
}

/* --- the equaliser is decoration; hold it still if motion is unwelcome --- */

@media (prefers-reduced-motion: reduce) {
  /* A plain opacity crossfade: height snaps to full so nothing grows or
     slides, and only the fade is left. Overriding the whole shorthand (rather
     than just transition-duration) is what drops height out of the transition
     in both directions. */
  .btn__eq,
  .btn:hover .btn__eq,
  .btn:focus-visible .btn__eq,
  .btn:active .btn__eq {
    transition: opacity 160ms linear;
  }

  .btn__bar { transition: none; }

  .btn:hover .btn__bar,
  .btn:focus-visible .btn__bar,
  .btn:active .btn__bar {
    animation: none;
    transform: translateY(0); /* the designed heights, held still */
  }
}

/* ---------- Locate me: status line ---------- */

/* Sits under the buttons and is empty most of the time. It keeps its 20px line
   box even when empty (min-height, not height) so the layout does not jump the
   moment a message appears — the buttons would otherwise shift up mid-click. */
.locate-status {
  min-height: 20px;
  margin: var(--gap-title) auto 0;
  max-width: 480px;
  padding: 0 var(--pad-inline);
  font-size: var(--size-label);
  line-height: 20px;
  text-align: center;
  text-wrap: balance;
  /* 0.72 on #0d0d0d is 8.9:1 — this carries real instructions (how to unblock
     location in site settings), so it is not decorative small print. */
  color: rgba(255, 255, 255, 0.72);
}

.locate-status--error { color: var(--cta); }

/* ---------- Attribution ---------- */

/* CC BY 4.0 on the earth texture requires a visible credit. Kept small and
   in the bottom-right corner so it reads as a footnote, not as content. */
.credit {
  align-self: flex-end;
  margin: 12px 0 0;
  font-size: 13px;
  line-height: 1.4;
  /* 0.48, not the 0.42 this started at: composited on #0d0d0d that was 4.08:1,
     under the 4.5:1 WCAG AA needs for 13px text. 0.45 is the bare minimum;
     0.48 gives 5.0:1 with a little margin and still reads as a footnote.
     This is the licence line — it has to be legible. */
  color: rgba(255, 255, 255, 0.48);
}

.credit a {
  color: inherit;
  text-decoration: underline;
  text-underline-offset: 2px;
}

.credit a:hover { color: rgba(255, 255, 255, 0.85); }

/* Same look and corner as the credit, one line beneath it. */
.policy-link {
  position: relative;
  z-index: 2;
  align-self: flex-end;
  margin: 4px 0 0;
  font-size: 13px;
  line-height: 1.4;
  color: rgba(255, 255, 255, 0.48);
}
.policy-link a { color: inherit; text-decoration: underline; text-underline-offset: 2px; }
.policy-link a:hover { color: rgba(255, 255, 255, 0.85); }
.policy-link a:focus-visible {
  color: rgba(255, 255, 255, 0.85);
  outline: 2px solid var(--fg);
  outline-offset: 4px;
  border-radius: 2px;
}
@media (max-width: 640px) {
  .policy-link { align-self: center; }
}

/* The buttons get a real ring on focus; these links only brightened, which is a
   colour-only focus indicator. Match the buttons so keyboard focus is visible
   the same way everywhere. */
.credit a:focus-visible {
  color: rgba(255, 255, 255, 0.85);
  outline: 2px solid var(--fg);
  outline-offset: 4px;
  border-radius: 2px;
}

@media (max-width: 640px) {
  .credit {
    align-self: center;
    text-align: center;
  }
}

/* ---------- Admin entry (2026-09-25) ---------- */

/* The site's own way in, deliberately quieter than the licence credit above:
   that line has to be legible (invariant 1's own 5.0:1), this one does not —
   nobody but the owner is meant to notice it, and the owner always has
   :focus-visible's full-strength ring to find it by keyboard. 0.22 idle is
   below AA on purpose, the same kind of accepted trade the locate marker's
   red makes (invariant 30), and it is the user's own call, not an oversight. */
.owner-link {
  position: absolute;
  left: var(--pad-inline);
  bottom: max(var(--pad-bottom), env(safe-area-inset-bottom));
  z-index: 2;
  font-size: 11px;
  line-height: 1.4;
  color: rgba(255, 255, 255, 0.22);
  text-decoration: none;
}

.owner-link:hover,
.owner-link:focus-visible {
  color: rgba(255, 255, 255, 0.72);
  text-decoration: underline;
  text-underline-offset: 2px;
}

.owner-link:focus-visible {
  outline: 2px solid var(--fg);
  outline-offset: 4px;
  border-radius: 2px;
}

/* Below 640px .credit centres and can wrap to two lines (see the media query
   above), landing at the same "bottom: pad-bottom" row this link sits on
   while absolutely positioned — close enough on a narrow screen for the two
   to overlap, or sit near enough that a tap meant for one link lands on the
   other. Drop out of absolute positioning here so this link flows in after
   .credit instead, with a real gap between the two lines. Placed after
   .owner-link's own base rule so it wins on source order at equal
   specificity. */
@media (max-width: 640px) {
  .owner-link {
    position: static;
    display: block;
    text-align: center;
    margin: 16px 0 0;
  }
}

/* ---------- Map view (Figma node 190:8) ---------- */

/* Covers the landing screen rather than replacing it: the globe keeps its
   WebGL context and its orientation, so going back is instant and the page
   never re-initialises. .screen is made inert in map.js while this is up —
   without that its buttons stay tabbable underneath.

   Hidden by VISIBILITY, never by display:none or the hidden attribute, and
   that is load-bearing. MapLibre measures its container and caches the size;
   taking it out of layout collapses that to the library's 400x300 default, and
   a later resize() does not recover the centre — a second "Locate me" put the
   "you are here" marker at (200, 150) instead of the middle of the screen.
   visibility:hidden keeps the box laid out and measurable while still removing
   it from the tab order and the accessibility tree. */
.map-view {
  position: fixed;
  inset: 0;
  z-index: 10;
  /* Transparent, not the page colour: the map is crossfaded over a globe that
     is STILL DIVING underneath, and an opaque backdrop would wash that to flat
     dark halfway through the blend. The map's own canvas is opaque, so nothing
     shows through once the fade completes. */
  background: transparent;
  visibility: hidden;
  pointer-events: none;
  opacity: 0;
  /* No scale here any more. The map's own zoom carries the motion now, and a
     second transform on the container just fought it. */
  transition: opacity 600ms linear, visibility 0s linear 600ms;
}

.map-view--in {
  visibility: visible;
  pointer-events: auto;
  opacity: 1;
  /* Linear on the way in, deliberately. An eased fade holds near 0 at the
     start, which delays the reveal past the moment the two scales actually
     match and reintroduces the seam. */
  transition: opacity 600ms linear, visibility 0s;
}

.map-view__canvas { position: absolute; inset: 0; }

/* The floating top-left "Discover" button that used to live here is GONE.
   Its rules were dead for a long time — nothing in the markup carried the class
   — and on 2026-09-18 they came back to bite: Discover became a MapLibre
   control reusing the name `.map-discover`, and the corpse's
   `position: absolute; top: 24px; left: 24px` dragged the new button 24px out
   of its control group and 14px off the right edge of the screen, while every
   rule I had just written computed exactly as declared. Dead CSS is not inert
   if someone later picks the same class name. */

/* Readable by assistive tech, invisible on screen. Not display:none, which
   would take it out of the accessibility tree as well. */
.visually-hidden {
  position: absolute;
  width: 1px;
  height: 1px;
  margin: -1px;
  padding: 0;
  overflow: hidden;
  clip-path: inset(50%);
  white-space: nowrap;
}

/* --- view switcher, top-left (Figma had this as a bottom tab bar) --- */

/* ONE BAR, ONE SURFACE (2026-09-17). Discover, search and the place chip were
   three floating chips with three backgrounds, three radii, three shadows and
   three different type treatments. They are now segments of a single pill.

   THE FILL IS NEAR-SOLID AND THAT IS NOT THE REFERENCE LOOK'S ALPHA. The pill
   SHAPE comes from the old place chip (100px radius), which is what was asked
   for — but its 0.7 black does not come with it. The chip got away with 0.7
   because flat grey basemap sits behind it; the Discover and search end sits
   over NOTES, and at 0.7 a red disc passing underneath bled through and read as
   part of the control. That is why those two were 0.94. One bar means one fill,
   and the fill has to satisfy the harder of the two. Do not take this to 0.7.

   One shadow on the whole bar, never per segment — the segments below are
   deliberately stripped of their own background, radius and elevation. */
.map-nav {
  position: absolute;
  top: 24px;
  /* CENTRED BY LAYOUT, NOT BY TRANSFORM (2026-09-18). `left: 0; right: 0` plus
     `margin-inline: auto` centres the bar inside the map, and `width:
     fit-content` is what keeps it hugging its content — an absolutely
     positioned flex box with both insets set would otherwise stretch to the
     full row. It computes to exactly the shrink-to-fit width it had while it
     was anchored at `left: 24px`, so nothing about the segments' sizing moves.
     Deliberately NOT `left: 50%; transform: translateX(-50%)`: `transform` is
     already spoken for — it is how the bar slides clear of an open panel, and
     it is the one property that may be animated here. A centring transform
     would have to be restated inside every slide, which is exactly the kind of
     sum invariant 15 deleted. */
  left: 0;
  right: 0;
  width: fit-content;
  margin-inline: auto;
  z-index: 3;
  display: flex;
  align-items: stretch;
  height: 56px;
  /* Hugs its content on desktop. It cannot be allowed to run off the right
     edge, so the place segment truncates instead — see min-width: 0 below. */
  /* TWO CAPS, AND THEY DO DIFFERENT JOBS. `100% - 48px` stops the bar reaching
     the window edges. The 720px is an aesthetic ceiling: without it the bar
     grows to whatever the place name needs, and Bungee caps are wide enough
     that "CITY OF WESTMINSTER, UNITED KINGDOM" measured 444px on its own and
     dragged the bar to 924px across a 1047px window — a header spanning the
     screen. At 720 the place segment truncates instead, which is the trade
     invariant 10 already made: a shortened name beats a clock pushed off.

     This is NOT invariant 15's arithmetic returning. That was a set of
     reserves that had to agree with the nav's width, the panel's width and two
     breakpoints, and had to be re-derived when any of them moved. This is one
     number capping one object, and nothing else depends on it. */
  max-width: min(calc(100% - 48px), 720px);
  border-radius: 100px;
  /* 12px until Discover left this bar (2026-09-18). That padding was bought by
     a specific problem: Discover was two lines, icon over label, and its label
     sat at y+36..48 where the pill's 28px cap has drawn inward 8.4px — measured,
     the word painted 8.4px OUTSIDE the pill, onto the map.
     The search toggle that now leads the bar is a single centred icon on the
     bar's midline, which is exactly where the cap is at its WIDEST, so it needs
     none of that. 4px is ordinary breathing room, not clearance.
     Keep the lesson though: a rectangle inside a curved container is not inside
     it at the corners. Anything two-line or bottom-aligned put at either end of
     this bar needs the 8.4px back. */
  padding-left: 4px;
  background: rgba(35, 35, 35, 0.94);
  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.35);
  /* The chip used to animate `left` between its anchored and centred rules.
     In flow there is no `left` to animate and nothing to retune: the bar moves
     as one object when a panel opens, which is the transform below. */
  transition: transform 340ms cubic-bezier(0.4, 0, 0.2, 1);
}

/* Thin, low-opacity, and full height minus the bar's vertical padding — enough
   to separate the segments without them reading as three objects again. The
   12px block margin is what stops it touching the pill's edges. */
.map-bar__divider {
  flex: none;
  align-self: stretch;
  width: 1px;
  margin: 12px 0;
  background: rgba(255, 255, 255, 0.14);
}

.map-nav__btn {
  display: flex;
  flex-direction: column;
  align-items: center;
  gap: 4px;
  width: 60px;
  /* HOLDS ITS 60px. As a flex item it defaulted to shrink:1 and was squeezed to
     47px once the bar hit its max-width — the merge quietly taking 13px off a
     tap target, which is the one thing the brief said it must not do. Only the
     place segment gives way. */
  flex: none;
  padding: 8px 0;
  border: none;
  /* No surface of its own any more — the bar carries the fill, the radius and
     the shadow. The rounding here matches the pill so the hover state does not
     paint square corners over the bar's left end. */
  border-radius: 100px 0 0 100px;
  background: none;
  color: var(--fg);
  font: inherit;
  font-size: 11px;
  /* Secondary WEIGHT, shared with the search field, so the hierarchy against
     the place name is deliberate rather than three independent choices. The
     COLOUR stays full white: it was #a1a1a1 once and a permanently grey label
     on a button that is never disabled read as disabled. Weight is the knob
     here, not colour. */
  font-weight: 500;
  line-height: 12px;
  letter-spacing: 0.117px;
  cursor: pointer;
  transition: background-color 340ms cubic-bezier(0.4, 0, 0.2, 1),
              box-shadow 340ms cubic-bezier(0.4, 0, 0.2, 1);
}

/* Full white, label and icon alike, and no dimming on the icon. The label used
   to sit at #a1a1a1 with the icon at 0.75 opacity, which is a resting state
   that reads as disabled — and this button is never disabled. */
.map-nav__btn .icon { opacity: 1; }

/* Hover goes DARKER, not lighter. The old hover lifted the ground from #232323
   to #303030, so the button brightened as the cursor arrived and the whole
   control looked like it was switching on. Dropping to #121212 lets the white
   text step forward instead, and the shadow lifts the button off the map. */
.map-nav__btn:hover {
  background: rgba(18, 18, 18, 0.96);
  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.35);
}

.map-nav__btn:focus-visible { outline: 2px solid var(--fg); outline-offset: 4px; }

/* --- search, sharing the header row with Discover ---
 *
 * Both controls answer "take me somewhere": one at random, one by name. The
 * pill matches .map-nav__btn exactly — same 0.94-alpha near-solid ground, same
 * 16px radius, same 56px height — because they read as one control group and a
 * translucent field would let a bright pin bleed through the text.
 *
 * COLLAPSED BELOW 861px, and that is not a style preference. Measured at 375px:
 * the nav ends at x=76 and .map-place is pinned by `right: 16px` with
 * `max-width: calc(100% - 140px)`, so its left edge can reach x=124. That
 * leaves 48px — not a search field. So under 861px the pill is its icon alone,
 * and opening it expands the field across the row and takes the chip out of the
 * way. Above 861px there is room for both at once and nothing collapses.
 */
.map-search {
  position: relative;
  /* Creates a STACKING CONTEXT, which is load-bearing: the pressed surface
     below is `z-index: -1`, and without a context here that -1 would escape
     this element and sink behind `.map-nav`'s own fill, making the press
     invisible instead of merely mis-stacked. Painting order only, no visual
     effect of its own. */
  z-index: 0;
  display: flex;
  align-items: center;
  /* Height comes from the bar now (align-items: stretch), not from a number
     repeated here that would drift from it. */
  padding: 0 4px 0 0;
  background: none;
  /* No fill and no radius OF ITS OWN, still. It carried a 100px radius while
     the focus state was an outline, purely to stop that ring being a square
     inside a rounded bar. The active state is now a pressed surface, and that
     surface is a `::before` that reaches back over the bar's padding to sit on
     the pill's real cap — see the note there. Putting the radius back here
     would round the wrong box, 4px inboard of the one that matters. */
  /* DOES NOT SHRINK. The order the brief asked for is: the place segment gives
     way first, the field keeps its width. At `flex-shrink: 1` both gave way
     together — measured, the field went 244 -> 175px while the name was also
     truncating, so the one segment you are typing into got narrower to protect
     a name that was being cut off anyway. `basis: auto` still lets the form
     GROW when the field opens on a phone; it just refuses to be squeezed. */
  flex: 0 0 auto;
}

.map-search__toggle,
.map-search__clear {
  display: flex;
  flex: none;
  align-items: center;
  justify-content: center;
  border: none;
  background: none;
  /* Buttons carry a UA padding of about 1px 6px. Only `padding-right` was ever
     overridden below, so 6px of LEFT padding survived — invisible while the
     icon was pushed to the trailing edge, and 3px off-centre the moment the
     collapsed pill tried to centre it. Reset it here and set the trailing gap
     explicitly where it is wanted. */
  padding: 0;
  color: #a1a1a1;
  cursor: pointer;
  /* Width, because the toggle resizes when the pill collapses and it has to
     travel with the field rather than snapping while the field slides. */
  /* 260ms to match the pressed surface's RELEASE; the focused rule below
     halves it for the press, the same split the surface uses. */
  transition: color 260ms ease, width 300ms cubic-bezier(0.4, 0, 0.2, 1);
}

/* The magnifier end of the pill is the whole tap target: on a phone this is the
   only thing the pill shows, so it stays at or above 44px in both directions.

   It was a 56px square with the icon centred, which put 18px between the icon
   and the placeholder — the icon read as a separate button rather than as the
   field's own affordance. Narrowing it to 44 and pushing the icon to its
   trailing edge closes that to 6px while leaving the icon's 18px inset from the
   pill's left edge exactly where it was: the gap shrinks, the icon does not
   move. */
.map-search__toggle {
  width: 44px;
  height: 56px;
  padding-right: 6px;
  justify-content: flex-end;
  border-radius: 16px;
}

/* Absolutely positioned, and that is load-bearing rather than tidy. In the flow
   it added its own 32px to the pill the moment someone typed, which widened the
   nav from 324px to 356px and drove it 4px into the place chip — a layout that
   broke only while you were using it. Out of the flow the pill is a fixed width
   whatever the field contains, and the input reserves the same 32px as padding
   so the text never runs under the button. */
.map-search__clear {
  position: absolute;
  right: 8px;
  top: 50%;
  transform: translateY(-50%);
  width: 32px;
  height: 32px;
  border-radius: 50%;
}

/* No hover fill: a segment that lights its own rectangle inside a shared
   pill is the three-chips look coming back through the back door. */
.map-search__toggle:hover,
.map-search__clear:hover { color: #ffffff; }

.map-search__toggle:focus-visible,
.map-search__clear:focus-visible { outline: 2px solid var(--fg); outline-offset: -4px; }

.map-search__input {
  box-sizing: border-box;
  /* 120px, down from 196 (2026-09-27) — sized for "Search" alone now that the
     placeholder dropped "a location" (see the label/title/placeholder below),
     not for the old, much longer string this box used to have to hold.
     Effectively a DESKTOP-ONLY number even though it lives in the base rule:
     below 860px `.map-search__input` is completely overridden — collapsed to
     `width: 0` at rest, `width: auto; flex: 1` while open — so this value is
     never actually rendered there. Mobile's own treatment is still an open
     question and deliberately untouched here. */
  width: 120px;
  min-width: 0;
  height: 56px;
  padding: 0 32px 0 0;   /* the clear button's seat; see above */
  border: none;
  background: none;
  /* WHITE ALWAYS, AND NOT VIA `var()` OR VIA `:focus` (2026-09-18, after this
     was reported four times).
     What you type is the one thing in this bar that must always be legible, so
     its colour is now the single least conditional declaration that can
     express that: a literal on the base rule. Everything clever about it has
     been taken away on purpose.
       - It no longer waits for `:focus`. A focus-gated colour is only correct
         while `:focus` is matching, and that is not guaranteed at the moment
         somebody looks: a screenshot utility, a window losing focus or an
         engine that drops focus styling on an inactive window all suppress it
         while the text is still on screen and still being read. The BAR still
         responds to focus — the surface, the buttons, the place segment — but
         the typed characters do not depend on it.
       - It is `#ffffff`, not `var(--fg)`. Identical value, but a var that
         fails to resolve computes to the INHERITED colour instead, which is a
         silent grey in any context where the chain differs. There is nothing
         to resolve here.
       - It was `#fafafa`, which is not white and was never meant to be read as
         white next to icons that are. */
  color: #ffffff;
  font: inherit;
  font-size: 14px;
  /* 500, NOT the inherited 400. THE COLOUR WAS ALREADY MAXED OUT AND THE TEXT
     STILL READ GREY — reported twice, 2026-09-18, and the diagnosis is worth
     keeping because every instinct here points the wrong way.
     `getComputedStyle` said `rgb(255,255,255)` while the glyphs on screen were
     plainly grey, which looks impossible until you see WHAT ELSE is in this
     bar: the place name and the clock are BUNGEE, a heavy display face, and
     the magnifier and the clear button are 2px icon strokes. The input was the
     only thing in the bar set in Inter at weight 400, and `body` carries
     `-webkit-font-smoothing: antialiased`, which thins light-on-dark text
     further. So a genuinely white 14px/400 glyph sat beside much heavier white
     neighbours and read as grey by comparison.
     Weight is one knob; SMOOTHING is the other, and it turned out to be the
     bigger one — see the declaration below. Inter is loaded at 400, 500 and
     600 (index.html), so both weight steps are real faces, not synthesised. */
  font-weight: 500;
  /* THE GLOBAL `antialiased` IS WHAT MADE WHITE TEXT RENDER GREY HERE, AND
     UNDOING IT FOR THIS ONE FIELD IS THE ACTUAL FIX (2026-09-18, after five
     reports).
     `body` sets `-webkit-font-smoothing: antialiased`. On macOS that switches
     glyphs from LCD/subpixel rendering to greyscale, which THINS light-on-dark
     text — the stems lose coverage and a genuinely `#ffffff` glyph paints as a
     grey smear. It is a flattering choice for dark-on-light and the wrong one
     for a white 14px field on a near-black ground.
     Proved by putting four `#ffffff` samples side by side in the same font and
     size, differing only in smoothing: `subpixel-antialiased` renders visibly
     heavier and brighter than `antialiased` at both 500 and 600.
     **THAT TEST ONLY WORKS AT 1:1.** An earlier run of it concluded "no
     difference" and sent this down the wrong path for three rounds, because it
     was read off a screenshot the pane had downscaled from 1500px to 800 —
     which destroys exactly the sub-pixel stem coverage being compared. Match
     the viewport to the capture width before judging any glyph rendering.
     Scoped to the input deliberately. The icons beside it are SVG strokes and
     the place name is Bungee, a heavy display face; neither was ever affected,
     which is why the field looked wrong NEXT TO THEM and the bug read as a
     colour problem for so long. */
  -webkit-font-smoothing: subpixel-antialiased;
  /* Composited, the pill is about #303030 over the light basemap, and about
     #1a1a1a once the segment is pressed; #ffffff is 12.6:1 and 17.4:1 against
     those. Judged against the RENDERED grey, not against the 0.94-alpha
     token — see the contrast note in CLAUDE.md. */
  transition: width 300ms cubic-bezier(0.4, 0, 0.2, 1), opacity 200ms ease,
              color 260ms ease;
}

/* Fades OUT on focus rather than snapping — see the `:focus` rule below.
   `opacity: 1` is still needed here: Firefox dims placeholders by default. */
.map-search__input::placeholder {
  color: #a1a1a1;
  opacity: 1;
  transition: color 130ms ease;
}
.map-search__input:focus { outline: none; }

/* THE ACTIVE STATE IS THE SEGMENT BEING PRESSED IN (2026-09-18).
 *
 * Third treatment for this one state, and the first two are worth keeping in
 * mind because each failed for a reason that still applies:
 *
 *   1. `outline: 2px solid var(--fg)` on the form. An outline traces the
 *      element's OWN box, so on a segment inside a pill it can only be a
 *      rectangle floating in the middle of the bar. Rounding it just made it a
 *      rounded rectangle floating in the middle of the bar — the shape was
 *      never the problem, outlining a segment was.
 *   2. A 2px white rule along the bottom edge. It read well while search was a
 *      MIDDLE segment, and stopped working the day Discover left the bar and
 *      search inherited the pill's left end cap: the rule ran 6.68px out past
 *      the curve onto the map, and pulling it in fixed the leak but left a
 *      bright white line sitting on a near-black bar.
 *
 * Both were marks drawn NEXT TO the control. This one is the control itself
 * changing state: the segment recesses, like a transport key on a tape deck
 * going down. That is why it cannot leak — there is no separate mark to leak,
 * only a surface, and the surface is cut to the pill's own curve.
 *
 * IT STILL FOLLOWS THE INPUT'S FOCUS, NEVER `:focus-within`. The toggle and the
 * clear button keep their own inset outlines so a keyboard user can tell WHICH
 * of the three controls they are on; `:focus-within` paints for all three and
 * says nothing. That distinction survived all three treatments and must.
 */

/* THE SURFACE IS A PSEUDO-ELEMENT, NOT A BACKGROUND ON THE SEGMENT, AND THE
   -4px IS THE WHOLE REASON. The bar carries `padding-left: 4px`, so the
   segment's own box starts 4px inside the pill. A radius on that box clamps to
   28px around ITS left edge, i.e. 4px right of the pill's own cap centre — which
   leaves a 4px crescent of un-pressed bar showing around the curve, reading as
   a misprint rather than a bevel. Reaching back over the padding with
   `inset: 0 0 0 -4px` puts this surface's cap exactly on the pill's.
   It is `::before` rather than `::after` so it paints in tree order BEFORE the
   icon and the input, i.e. behind them. `.map-search` itself still has no
   background and no radius of its own — see the note on that rule. */
.map-search::before {
  content: '';
  position: absolute;
  /* BEHIND THE CONTENT, AND THIS IS THE WHOLE BUG THAT MADE THE TYPED TEXT
     LOOK GREY FOR FIVE ROUNDS (found 2026-09-18).
     An absolutely positioned `::before` is a POSITIONED DESCENDANT, and
     positioned descendants paint AFTER in-flow content — so this surface was
     laid ON TOP of the input's characters, not behind them. White text under
     `rgba(8,8,8,0.55)` composites to `0.45 x 255 + 0.55 x 8` = **#777**, which
     is precisely the grey that kept being reported.
     THE ASYMMETRY IS THE TELL, and it is what made this look like a colour
     bug: the clear button survived because it is `position: absolute` too and
     sits LATER in DOM order, and the magnifier survived because its focus
     nudge is a `transform`, which creates a stacking context. Both painted
     above the veil. Only the text — in-flow and unpositioned — went under it.
     So `color` was correct the whole time and every measurement of it agreed,
     while the pixels on screen did not. `getComputedStyle` cannot see a veil.
     The fix is painting order, not colour: `z-index: -1` here, and
     `z-index: 0` on `.map-search` to give it a stacking context so this cannot
     sink below the BAR's fill as well. Same device as `.vinyl { z-index: -1 }`
     on the panels (invariant 26), and for the same reason.
     **Never give this a positive z-index, and never remove the stacking
     context from `.map-search`.** */
  z-index: -1;
  inset: 0 0 0 -4px;
  border-radius: 100px 0 0 100px;
  background-color: transparent;
  pointer-events: none;
  /* THE RELEASE, and it is deliberately slower than the press below. A key you
     let go of comes back up more gently than it went down; equal timings read
     as a light switch. */
  transition: background-color 260ms cubic-bezier(0.4, 0, 0.2, 1),
              box-shadow 260ms cubic-bezier(0.4, 0, 0.2, 1);
}

/* HOVER IS THE SAME PRESS, PART OF THE WAY DOWN (2026-09-19). Until now the
   segment answered a hover with nothing at all — the two buttons inside it
   changed colour and the segment itself sat still, so there was no sign the
   whole thing was one control until you clicked into it.
   No new treatment: this is the focused surface at roughly 40% — 0.22 against
   0.55, and a shallower shadow — so hovering reads as the key starting to go
   down and focusing finishes the movement. One object, two depths.
   DARKER, NEVER LIGHTER, the same rule the focus state and the nav buttons
   follow. Composites to about #262626 against the bar's ~#2f2f2f: a step you
   can see without the segment becoming a second object.
   200ms, between the 130ms press and the 260ms release — the nearer this gets
   to being committed, the faster it moves.
   GATED ON `(hover: hover)`, and that is load-bearing: on a touchscreen
   `:hover` STICKS after a tap, so an ungated rule would leave the segment
   permanently half-pressed after the first time anyone touched it. Same gate,
   same reason, as the map buttons (invariant 35).
   Specificity puts focus on top without relying on source order: the `:has()`
   rule below is (0,3,0) against this one's (0,2,0). */
@media (hover: hover) {
  .map-search:hover::before {
    background-color: rgba(8, 8, 8, 0.22);
    box-shadow: inset 0 1px 3px rgba(0, 0, 0, 0.45),
                inset 0 -1px 0 rgba(255, 255, 255, 0.05);
    transition-duration: 200ms;
  }
}

.map-search:has(.map-search__input:focus)::before {
  /* Composites to about #1a1a1a against the bar's own ~#2f2f2f over a light
     basemap — a step you can see without the segment becoming a second object.
     DARKER, never lighter: the same rule the nav buttons' hover follows, and
     for the same reason. A segment that brightens looks like it switched on;
     one that darkens looks like it went down. */
  background-color: rgba(8, 8, 8, 0.55);
  /* The recess. A shadow cast INWARD from the top edge is what says the surface
     has dropped below the ones beside it; the 1px lit lower lip is the far wall
     of the well catching the same light. Both are inset, so nothing is drawn
     outside the segment and there is nothing to clip. */
  box-shadow: inset 0 2px 5px rgba(0, 0, 0, 0.75),
              inset 0 -1px 0 rgba(255, 255, 255, 0.09);
  /* THE PRESS, twice as fast as the release above. A key goes down with the
     finger, not after it. */
  transition-duration: 130ms;
}

/* EVERYTHING IN THE SEGMENT COMES UP TO THE APP'S WHITE WHILE IT IS ACTIVE
   (asked for 2026-09-18: the text has to be legible when you are using it, and
   the icon has to match the text).
   At rest the placeholder and the two buttons sit at #a1a1a1, which is a
   deliberate secondary weight against the Bungee place name — it is the
   resting state that is quiet, not the active one. On focus the two buttons and
   the typed value go to var(--fg), so the field reads as one lit object rather
   than a white caret in a grey box. The typed value moved too: #fafafa was
   already close enough to read well, but close enough and the icon's white are
   not the SAME white, and matching them is what was asked for.
   Contrast against the pressed ground (~#1a1a1a) is 17.4:1. The icon clears
   WCAG 1.4.11's 3:1 many times over.
   THE PLACEHOLDER IS THE EXCEPTION AND GOES THE OTHER WAY — it fades out
   entirely on focus. See its own rule below. */
/* THE INPUT STYLES ITSELF FROM ITS OWN `:focus`, AND NEVER FROM THE BAR'S
   `:has()`. Two separate reasons, and the first one was a real bug that
   reached the user (2026-09-18, reported three times).
   1. IT WAS WRITTEN AS ONE RULE GROUPING A PSEUDO-ELEMENT WITH A NORMAL
      SELECTOR:
          .map-search:has(...) .map-search__input,
          .map-search:has(...) .map-search__input::placeholder { color: ... }
      **If ANY selector in a comma-separated list is not understood by the
      engine, the WHOLE rule is discarded** — declarations and all. So an
      engine that parses `::placeholder` differently threw away the plain
      `.map-search__input` half too, and the typed text stayed at its resting
      colour. The toggle and the clear button went white in the same state
      because THEIR rule is separate and contains no pseudo-element. That
      asymmetry — icons white, text grey — is the signature of this mistake,
      and it is invisible in any single browser that happens to parse the list.
      **Never group a pseudo-element selector with a non-pseudo one.** Split
      them, always, even when the declarations are identical.
   2. The input's own appearance does not need to know about its parent. The
      `:has()` on the bar is right for the pressed SURFACE, for the two buttons
      and for the place segment, because those genuinely key off a different
      element's focus. The input keying off its own `:focus` removes an engine
      dependency from the one thing that has to be legible.
   Specificity holds either way: `:focus` at (0,2,0) beats the base (0,1,0),
   and the placeholder rule at (0,2,1) beats its base (0,1,1). */
/* Colour is NOT here any more — it is unconditional on the base rule above,
   deliberately. Only the weight is a focus state. */
.map-search__input:focus {
  /* A step heavier while it is active. 600 is what finally reads as
     white rather than grey; 500 alone was an improvement and not enough — see
     the note on the base rule for why weight is the knob here and not colour.
     DELIBERATELY NOT TRANSITIONED. Glyph widths change with the weight, so
     easing it would drag the text a fraction of a pixel per frame for the
     whole transition — the one thing you must not do to characters somebody is
     reading while they type. It steps at the instant the surface goes down, so
     it reads as part of the press rather than as a reflow. */
  font-weight: 600;
}

/* THE PROMPT GETS OUT OF THE WAY WHEN YOU CLICK IN (asked for 2026-09-18).
   It briefly went white on focus instead, which was the wrong answer to the
   right observation: once the field is yours, "Search" is an instruction
   you have already followed, and a lit one competes with the
   caret and with the first character you type.
   `color: transparent`, not `opacity: 0` — the base rule needs `opacity: 1`
   to override Firefox's default dimming, and having the two fight over the
   same property is how that override gets lost. It fades over 130ms, the
   press's own timing, so the prompt leaves as the surface goes down instead
   of blinking out.
   NOTHING IS LOST ACCESSIBLY. The field's accessible name comes from its
   `<label class="visually-hidden">Search</label>`, not from the
   placeholder, so a screen reader still announces it in full — which is why
   this is safe to do at all. A placeholder must never be the only label.
   Its OWN rule, never folded into the one above it. See 1. above. */
.map-search__input:focus::placeholder {
  color: transparent;
}

.map-search:has(.map-search__input:focus) .map-search__toggle,
.map-search:has(.map-search__input:focus) .map-search__clear {
  color: var(--fg);
  /* Halved for the press, like the surface and the glyph. Width keeps its own
     timing — it belongs to the pill collapsing, not to this. */
  transition: color 130ms ease, width 300ms cubic-bezier(0.4, 0, 0.2, 1);
}

/* The glyph travels with the surface it sits on. 1px, and only the icon — the
   input is left alone deliberately, because nudging text and a caret at the
   moment they are focused reads as a jolt rather than as a press. Same split
   timing as the surface: down with the finger, back up more slowly. */
/* TWO STATES WANT THIS ONE `transform`, SO NEITHER OF THEM WRITES IT DIRECTLY.
   The focus nudge below and the hover scale further down are independent — you
   can hover a focused field — and a second rule setting `transform` would
   silently delete the first, which is the collision invariants 28 and 30 are
   both about. So the transform is assembled once, here, out of two custom
   properties that each state sets on its own. They compose instead of fighting.
   (A `var()` change still transitions: what is animated is `transform`, whose
   computed value changes when the variable does. Verified on screen.)

   THE ORIGIN IS THE LENS, NOT THE ICON'S CENTRE, and that is the whole idea.
   Phosphor's magnifying glass is a circle of r=72 centred on (112,112) in a 256
   viewBox — 43.75% — with the handle running off to the bottom right. Scaling
   from there swells the LENS and leaves the handle where it is, which reads as
   the glass magnifying rather than the glyph inflating. That also keeps it
   distinct from the + button, which scales uniformly from its middle
   (invariant 35); the two are on screen together and should not read as the
   same move. */
.map-search__toggle .icon {
  transform: translateY(var(--tgl-y, 0px)) scale(var(--tgl-s, 1));
  transform-origin: 43.75% 43.75%;
  transition: transform 260ms cubic-bezier(0.4, 0, 0.2, 1);
}

.map-search:has(.map-search__input:focus) .map-search__toggle {
  --tgl-y: 1px;
}

.map-search:has(.map-search__input:focus) .map-search__toggle .icon {
  transition-duration: 130ms;
}

/* THE MAGNIFIER MAGNIFIES. It is the only verb this icon owns at BOTH widths —
   above 861px clicking it submits the search, below it opens the collapsed
   pill, so a motion meaning "open" would be wrong on a desktop and one meaning
   "go" would be wrong on a phone. "Look closer" is true of both.
   Gated for the reason above: a stuck :hover would leave the lens permanently
   enlarged after one tap. */
@media (hover: hover) {
  .map-search__toggle:hover .icon {
    --tgl-s: 1.18;
    transition-duration: 200ms;
  }
}

/* THE CLEAR BUTTON'S X HOPS, AND IT HOPS THE OTHER WAY FROM THE CARET.
   The motion lives on the ICON, never on the button: `.map-search__clear` is
   absolutely positioned and centred with `transform: translateY(-50%)`, so a
   transform declared there would overwrite its own centring and drop it half
   its height down the pill.
   UP, not down. The caret's dip means something — it is the direction its menu
   opens — and giving an unrelated control the identical gesture is what would
   drain that of meaning. Lifting reads as the text being taken away.
   AND ROTATION WAS NEVER AVAILABLE HERE, which is worth writing down: an X has
   four-fold symmetry, so a quarter turn lands on a shape identical to where it
   started — invisible, exactly the trap the crosshair's 45deg avoids
   (invariant 35) — and 45deg turns it into a PLUS, which reads as "add". */
.map-search__clear .icon {
  transition: transform 280ms cubic-bezier(0.4, 0, 0.2, 1);
}

@media (hover: hover) {
  .map-search__clear:hover .icon {
    transform: translateY(-2px);
    /* The overshoot is the bounce, and it is only on the way IN. A spring on
       the way out reads as a wobble, so the base rule keeps the plain curve —
       the same split the press uses, with no JS to swap anything. */
    transition: transform 260ms cubic-bezier(0.34, 1.4, 0.64, 1);
  }
}

/* Split, not grouped — a pseudo-element must never share a selector list with
   a normal selector, or an engine that parses it differently discards BOTH.
   See the long note on `.map-search__input:focus`; that mistake shipped once. */
@media (prefers-reduced-motion: reduce) {
  .map-search::before { transition: none; }
  .map-place__time::before { transition: none; }
  .map-search__toggle .icon { transition: none; }
}

/* Safari draws its own clear button on type="search" and it is the wrong
   colour on a dark pill; ours is .map-search__clear. */
.map-search__input::-webkit-search-decoration,
.map-search__input::-webkit-search-cancel-button { -webkit-appearance: none; appearance: none; }

.map-search__status {
  position: absolute;
  top: calc(100% + 8px);
  left: 0;
  margin: 0;
  padding: 8px 12px;
  border-radius: 10px;
  background: rgba(35, 35, 35, 0.94);
  color: #fafafa;
  font-size: 12px;
  line-height: 16px;
  white-space: nowrap;
}

/* Suggestions under the search field (2026-09-30). Same opaque surface as the
   clock menu — rows of text over moving map tiles need it — and rows are 44px
   tall, the project's tap-target minimum (invariant 10). `hidden` wins over
   `display: flex`, hence the attribute selector. */
.map-search__list {
  position: absolute;
  z-index: 3;
  top: calc(100% + 8px);
  left: 0;
  width: max(100%, 300px);
  max-width: calc(100vw - 32px);
  margin: 0;
  padding: 8px;
  list-style: none;
  display: flex;
  flex-direction: column;
  gap: 4px;
  border: 1px solid rgba(255, 255, 255, 0.1);
  border-radius: 16px;
  background: #262626;
  box-shadow: 0 16px 32px -8px rgba(0, 0, 0, 0.7);
  animation: clock-menu-in 140ms cubic-bezier(0.4, 0, 0.2, 1);
  transform-origin: top left;
}
.map-search__list[hidden] { display: none; }

.map-search__option {
  display: flex;
  flex-direction: column;
  justify-content: center;
  min-height: 44px;
  padding: 4px 12px;
  border-radius: 10px;
  color: #ffffff;
  cursor: pointer;
  transition: background-color 150ms ease;
}
.map-search__option-name { font-size: 14px; line-height: 20px; font-weight: 600; }
.map-search__option-detail { font-size: 12px; line-height: 16px; color: #a1a1a1; }
.map-search__option:hover,
.map-search__option[aria-selected="true"] { background: #3a3a3a; }
/* The input keeps focus, so the highlighted row needs its own mark for a
   keyboard user: an inset ring, the same one the clock menu uses. */
.map-search__option[aria-selected="true"] { outline: 2px solid var(--fg); outline-offset: -2px; }

@media (prefers-reduced-motion: reduce) {
  .map-search__list { animation: none; }
  .map-search__option { transition: none; }
}

/* An empty status must not paint an empty pill. */
.map-search__status:empty { display: none; }

/* A generic, short-lived notice — same pill treatment as the search status
   above, but centred and anchored to the whole map rather than to one
   control, since the one thing that currently uses it (Discover's "no live
   notes anywhere yet" message) has no single field to hang off. Opacity, not
   `hidden`, so `showToast()` in map.js can just toggle a class and let the
   fade do the rest. */
/* Day/night dim (map.js, "day/night dim"). Multiplied over the basemap
   tiles only — it sits after the canvas and before every Marker, so notes
   and the locate circle are never dimmed. Opacity is the night amount 0..1,
   set from the sun's height at the map centre. At full strength it takes
   Positron's land #f2f3f0 to about #7d8494, a muted slate that keeps the
   black vinyl notes (#1f1f1f) at ~5:1. */
.map-night {
  position: absolute;
  inset: 0;
  background: #848a9d;
  mix-blend-mode: multiply;
  pointer-events: none;
  opacity: 0;
  transition: opacity 1200ms ease;
}
@media (prefers-reduced-motion: reduce) {
  .map-night { transition: none; }
}

.map-toast {
  position: absolute;
  top: 96px;
  left: 50%;
  transform: translateX(-50%);
  margin: 0;
  padding: 10px 16px;
  border-radius: 10px;
  background: rgba(35, 35, 35, 0.94);
  color: #fafafa;
  font-size: 13px;
  line-height: 18px;
  text-align: center;
  max-width: calc(100% - 32px);
  z-index: 6;
  pointer-events: none;
  opacity: 0;
  transition: opacity 200ms ease;
}
.map-toast.is-shown { opacity: 1; }

@media (prefers-reduced-motion: reduce) {
  .map-toast { transition: none; }
}

/* A COLLAPSED pill is a button, not a field, and it has to read as Discover's
   twin: same 60px box, icon centred in it. Without this it kept the open-state
   geometry — 44px wide with the icon shoved to the trailing edge, which is only
   right when there is placeholder text for it to sit against. Next to Discover
   that was a narrower box with an off-centre icon in it.

   The two collapsed cases are written out separately rather than shared,
   because they are collapsed for different reasons and one of them can be
   re-opened: below 861px the pill is closed until someone taps it, and above
   861px it is closed only while a panel is covering the map. */
@media (max-width: 860px) {
  .map-search:not(.is-open) { padding-right: 0; }
  .map-search:not(.is-open) .map-search__toggle {
    width: 60px;
    padding-right: 0;
    justify-content: center;
  }

  .map-search__input {
    width: 0;
    padding: 0;   /* or the 32px reserve alone keeps the collapsed pill wide */
    opacity: 0;
    pointer-events: none;
  }
  .map-search.is-open { flex: 1; }
  .map-search.is-open .map-search__input {
    width: auto;
    flex: 1;
    padding: 0 32px 0 0;
    opacity: 1;
    pointer-events: auto;
  }

  /* The bar has to be able to grow across the row before the field has anywhere
     to expand into. Below 641px it already spans; between 641 and 861 it hugs
     its content, so it still needs this.

     `max-width` ALONE WAS NEVER ENOUGH, AND THE PLACE-COLLAPSE FIX ABOVE IS
     WHAT EXPOSED IT (2026-09-28, reported directly: "the search bar should
     not shrink... keep it the same length as the main header"). `.map-nav`
     is `width: fit-content` at rest (invariant 15) — a cap only stops it
     growing PAST a size, it cannot make a shrink-to-fit box grow TO that
     size. While the place segment still contributed real width this went
     unnoticed, because search + both dividers + place's natural content
     happened to land close to the cap anyway. Now that place is genuinely
     0, the bar's fit-content sum is just the field's own preferred width —
     measured 250px against the 343px cap at 375px wide — so it visibly
     shrank into a shorter pill instead of filling the header's usual span.
     `width`, not just `max-width`, forces it to actually claim that space. */
  .map-view--searching .map-nav { width: calc(100% - 32px); max-width: calc(100% - 32px); }

  /* THE PLACE SEGMENT STANDS DOWN WHILE THE FIELD IS OPEN, AND IT HAS TO.
     Truncating instead was tried first, on 2026-09-17, because it is the nicer
     idea — one bar whose contents give way gracefully. It does not fit, and
     the failure is arithmetic rather than taste:

         Discover 60 + divider 1 + toggle 44 + a typeable field 140
         + divider 1 + the clock 93 + padding 38          = 377px
         available at 375px wide                          = 343px

     34px short with the place NAME ALREADY AT ZERO. Measured live, the shrink
     put the name at 0px and pushed the clock to x=373 on a 375px screen —
     entirely off it. That is invariant 10's exact failure: an unreadable string
     is a fair trade, an unreachable control is not, and the clock cannot shrink
     because it is the control.

     `visibility`, not `display`, so it leaves the accessibility tree rather
     than merely going invisible. Above 861px nothing collapses and this state
     never applies — there the field and the chip coexist, which is the whole
     point of the breakpoint.

     STANDING DOWN USED TO STOP AT OPACITY, AND THAT WAS THE BUG (2026-09-28,
     reported directly: an empty grey section sits in the header when the
     field is open). `opacity`/`visibility` hide the segment but do nothing
     to its LAYOUT — border-box still reserves the full 93px-ish box (its own
     padding plus its now-invisible dot/name/divider/clock), so the field's
     `flex: 1` only ever had the space AROUND that reservation to grow into,
     never the reservation itself. `max-width: 0` plus `padding: 0` is what
     actually frees it — `overflow: hidden` clips the now-orphaned children so
     nothing they contain can peek out of a box collapsing out from under
     them mid-transition. Transitioned alongside opacity/visibility so the
     collapse reads as one motion, not a fade followed by a jump. */
  .map-view--searching .map-place {
    opacity: 0;
    visibility: hidden;
    max-width: 0;
    padding: 0;
    overflow: hidden;
  }
  .map-place {
    transition: opacity 200ms ease, visibility 200ms, max-width 200ms ease, padding 200ms ease;
  }

  /* The OUTER divider (a direct child of .map-nav, between the field and the
     place segment) isn't inside `.map-place`, so collapsing that segment
     above does nothing to it — left alone it strands a 1px line at the end
     of the now fully-expanded field with nothing left to divide. `>` is
     deliberate: it must not also match `.map-place__divider`, the SECOND
     `.map-bar__divider` nested inside `.map-place` itself (invariant 36),
     which is already handled by the collapse above. */
  .map-view--searching .map-nav > .map-bar__divider { display: none; }

  /* THE "STRANGE RECTANGULAR PIECE" WAS THIS SURFACE'S SQUARE RIGHT CORNERS,
     EXPOSED THE SAME WAY THE WIDTH BUG ABOVE WAS (reported in the same
     message, same screenshot). `.map-search::before`'s base rule (further up
     this file) is `border-radius: 100px 0 0 100px` — rounded on the left,
     square on the right — because on every OTHER breakpoint something
     always continues the pill to its right (the place segment, at rest;
     desktop, always). Here, with place truly gone and the bar forced to
     its full width by the fix just above, this surface's own box is flush
     with `.map-nav`'s right edge — but square where the outer pill is
     rounded, so its corner pokes out past the curve instead of following
     it. Rounding both ends only in this exact state (search open, mobile,
     nothing left of it to butt against) is safe precisely because it's the
     only state where this surface is ever the WHOLE bar. */
  .map-view--searching .map-search::before { border-radius: 100px; }
}

/* Above this the row fits both, so nothing ever collapses and the toggle is
   just the magnifier at the head of a field that is always open. */
@media (min-width: 861px) {
  .map-search__toggle { cursor: default; }

  /* A fixed 120px (2026-09-27), so the time segment stops growing/shrinking
     with whatever the clock happens to say — the real widest case, measured
     directly rather than guessed, is 12-hour format with a two-digit hour
     plus AM/PM ("12:59 PM"), 114.4px; 24-hour tops out far lower. 120 clears
     that with a small (5.6px) margin for font-rendering variance, on the
     nearest clean, 4-point-grid number.
     `justify-content: flex-end` has to travel with it: without it the clock
     button (this element's only visible child — the "Local time" label
     beside it is visually-hidden and position:absolute, so it takes no part
     in this flex row) would hug the LEFT edge of the new, wider box, and the
     caret would drift away from `.clock-menu`'s `right: 0`, which anchors to
     THIS element, not to the button — the dropdown would end up hanging in
     empty space instead of under the control that opens it. Right-aligning
     keeps the button pinned to the same edge the menu anchors to and puts
     the slack on the left instead, which reads as more breathing room after
     the divider rather than as something misplaced.
     One pre-existing quirk survives unchanged, not introduced here: the
     clock's own negative margin (below, "padding cancelled by an equal
     negative margin") already overflows this element's box by 6px on each
     side — true before this fix too, verified by measuring both states —
     so the caret and the menu's right edge sit 6px apart, same as they
     always did. Fixing THAT would mean touching the clock's own box model,
     not this width/alignment change, and it reads fine on screen as is.
     Desktop only, deliberately: below this breakpoint the clock's own
     font-size shrinks and its natural content width is already tighter than
     120px (measured ~93px in the collapsed-search arithmetic above), and
     mobile's treatment of this bar is a separate, not-yet-answered question —
     see the search input's own width note just above. */
  .map-place__time {
    width: 120px;
    justify-content: flex-end;
  }
}

/* --- scrollbars ---
   The panels are dark and the browser's default scrollbar is not: a white
   track with a grey thumb cut straight through the card.

   Both syntaxes on purpose. `scrollbar-width`/`scrollbar-color` is the standard
   one (Firefox, and Chrome from 121); the `::-webkit-scrollbar` block covers
   older WebKit/Blink and is what allows the rounded, inset thumb. A browser
   that understands neither simply keeps its default, which is why nothing here
   is load-bearing.

   #707070 is the lightest the thumb can be while staying a scrollbar rather
   than a stripe, and it is chosen to clear WCAG 1.4.11's 3:1 for a UI component
   against BOTH surfaces it appears on — 3.92:1 on the drop panel's #0d0d0d and
   3.06:1 on the card's #262626. Anything darker fails the card. */
.card__scroll,
.drop__scroll,
.drop__textarea {
  scrollbar-width: thin;
  scrollbar-color: #707070 transparent;
}

.card__scroll::-webkit-scrollbar,
.drop__scroll::-webkit-scrollbar,
.drop__textarea::-webkit-scrollbar {
  width: 10px;
  height: 10px;
}

/* Transparent, so the track is whatever surface it sits on — #0d0d0d in the
   drop panel, #262626 in the card — without naming either colour twice. */
.card__scroll::-webkit-scrollbar-track,
.drop__scroll::-webkit-scrollbar-track,
.drop__textarea::-webkit-scrollbar-track {
  background: transparent;
}

/* The transparent border plus background-clip is what insets the thumb from the
   edges: padding on a scrollbar thumb is ignored, a border is not. */
.card__scroll::-webkit-scrollbar-thumb,
.drop__scroll::-webkit-scrollbar-thumb,
.drop__textarea::-webkit-scrollbar-thumb {
  background: #707070;
  border: 2px solid transparent;
  background-clip: padding-box;
  border-radius: 999px;
}

.card__scroll::-webkit-scrollbar-thumb:hover,
.drop__scroll::-webkit-scrollbar-thumb:hover,
.drop__textarea::-webkit-scrollbar-thumb:hover {
  background: #8a8a8a;
  background-clip: padding-box;
}

/* Where the two bars would meet. Left as the surface rather than the default
   light square. */
.card__scroll::-webkit-scrollbar-corner,
.drop__scroll::-webkit-scrollbar-corner,
.drop__textarea::-webkit-scrollbar-corner {
  background: transparent;
}

/* --- Phosphor icons ---
   Every icon is an <svg><use href="#ph-*"> against the sprite inlined at the top
   of index.html, and every path in that sprite is fill="currentColor". So an
   icon is coloured by setting `color` on it or on anything above it — no filter
   hacks, no per-colour asset. Sizing stays on the width/height attributes so an
   icon occupies its box before CSS loads. */
.icon {
  display: block;
  flex: none;
  fill: currentColor;
}

/* --- place-name chip, top-centre --- */

/* Right-anchored, not centred — at every width. It was centred above 640px and
   right-anchored below, and the reason for the mobile rule was a collision with
   the controls at top-left. Adding the search field brought that collision up
   to the desktop: the nav is now 324px wide, so a centred chip has its left
   edge 2px off the search pill at 1120px and straight through it below 1000px.
   Reserving space on both sides of a centred chip would need
   `max-width: calc(100% - 728px)`, which is 133px of chip at 861px — unusable.
   One rule for both breakpoints, and the same reasoning that already justified
   the mobile one. */
.map-place {
  /* IN FLOW, as a segment of the bar (2026-09-17). Everything that used to be
     here — `left: 352px`, `max-width: calc(100% - 376px)`, `top: 52px`,
     `transform: translateY(-50%)`, and the three panel/breakpoint overrides
     that followed it — is GONE, not retuned. Those were invariant 15's three
     measured reserves and two hand-derived breakpoints (1025 and 1177), and
     every one of them existed to keep an absolutely positioned chip clear of
     controls it could not see. A flex child cannot collide with its siblings,
     so the arithmetic has no job left.

     `min-width: 0` is the one thing that MUST survive: without it the name
     refuses to shrink below its content and pushes the clock off the bar,
     which is invariant 10's "an unreadable string beats an unreachable
     control" failing in the other direction.

     THIS SEGMENT IS THE ONE THAT GIVES WAY FIRST when the bar runs out of
     room — it is the only one that can, the other two being an icon button and
     a field with a minimum usable width. */
  min-width: 0;
  /* The full-name popover is positioned against this, not against the name —
     the name is overflow: hidden and would clip it. */
  position: relative;
  /* THESE TWO ARE WRITTEN DOWN ONCE AND THE SUMS ARE EXPRESSED IN THEM
     (2026-09-18), the same rule `--panel-w` and `--sheet-h` follow. The time's
     pressed surface has to reach back over BOTH — over the gap to touch the
     divider, and over the right padding to land on the pill's cap — so a
     literal `-20px` in that rule would be a hand-copied duplicate of a number
     that changes at the narrow breakpoint. It did exactly that here once: the
     padding drops to 16px below 861px, and a hardcoded surface would have hung
     4px past the pill onto the map at phone width only.
     CHANGE THE VARIABLE, NEVER THE SUMS. */
  --place-gap: 8px;
  --place-pad-r: 20px;
  /* SHRINK BUT DO NOT GROW. At `1 1 auto` this segment expanded to fill
     whatever the bar's max-width allowed and dragged the bar to 924px across a
     1047px window — a header spanning the whole screen for a name that needed
     343px. `0 1 auto` lets the bar hug its content and still lets this be the
     thing that gives way when the field opens. */
  flex: 0 1 auto;
  display: flex;
  align-items: center;
  gap: var(--place-gap);
  margin: 0;
  padding: 0 var(--place-pad-r) 0 16px;
  /* No surface of its own: the bar carries fill, radius and shadow. */
  background: none;
  color: #ffffff;
  /* TRIAL, 2026-09-11, kept as the bar's PRIMARY on the user's call
     (2026-09-17). Bungee has no lowercase, so this renders as caps whatever
     the source string says; the uppercase is set explicitly so a fallback does
     the same rather than switching case when the webfont fails. It is a
     display face and much wider than Inter at the same size, which is why this
     segment truncates early. Revert by deleting these three lines. */
  font-family: "Bungee", "Inter", sans-serif;
  text-transform: uppercase;
  font-size: var(--size-body);
  font-weight: 400;
  line-height: 20px;
  white-space: nowrap;
}

/* --- ONLY THE TIME PRESSES IN (2026-09-18, revised same day) ---
 *
 * The press was briefly on the WHOLE place segment, name included. It is now
 * on the time alone, which is what the user asked for and is also the truer
 * reading of the control: the dropdown is the button, the name is a label that
 * happens to be readable in full. A press covering both said the name was a
 * button too.
 * The name's own triggers went with it. Clicking a truncated name still opens
 * its popover (invariant 31); it just no longer presses anything, because
 * nothing there is a button.
 *
 * Everything else is copied from `.map-search::before` deliberately — same
 * ink, same two inset shadows, same 130ms down / 260ms up. Read that rule
 * before retuning anything here, and do not let the two drift.
 *
 * THE TWO NEGATIVE INSETS ARE THE ONLY NEW GEOMETRY, and both are reaches back
 * over space this element does not own:
 *   right — `.map-place` pads 20px (16px narrow), so the wrapper stops short
 *           of the pill. Reaching over it lands the cap exactly on the pill's,
 *           the same job `-4px` does on the search side.
 *   left  — the 8px flex gap to the divider. Without it the press starts 8px
 *           clear of the rule and floats; the search press runs right up to
 *           its own divider, and these two have to match.
 * BOTH COME FROM THE VARIABLES ON `.map-place`, never from literals — see the
 * note there for the breakpoint this would otherwise get wrong.
 */
.map-place__time::before {
  content: '';
  position: absolute;
  /* BEHIND THE CONTENT. An absolutely positioned pseudo-element is a POSITIONED
     DESCENDANT and positioned descendants paint AFTER in-flow content, so
     without this the surface lies over the digits — white text under
     `rgba(8, 8, 8, 0.55)` composites to #777, which is the five-round
     grey-text bug on `.map-search__input` reproduced exactly. Verified here
     with a red probe, not with `getComputedStyle`, which cannot see a veil.
     Never give this a positive z-index, and never remove the stacking context
     from `.map-place__time`. */
  z-index: -1;
  inset: 0 calc(-1 * var(--place-pad-r)) 0 calc(-1 * var(--place-gap));
  /* The pill's right cap. Square on the left, where it meets the divider. */
  border-radius: 0 100px 100px 0;
  background-color: transparent;
  pointer-events: none;
  /* THE RELEASE, slower than the press on purpose. */
  transition: background-color 260ms cubic-bezier(0.4, 0, 0.2, 1),
              box-shadow 260ms cubic-bezier(0.4, 0, 0.2, 1);
}

/* The dropdown being OPEN is the active state — the state that lasts as long
   as you are using the control, which is what the search field's focus is. */
.map-place__time:has(.map-place__clock[aria-expanded="true"])::before {
  background-color: rgba(8, 8, 8, 0.55);
  box-shadow: inset 0 2px 5px rgba(0, 0, 0, 0.75),
              inset 0 -1px 0 rgba(255, 255, 255, 0.09);
  /* THE PRESS, twice as fast as the release. */
  transition-duration: 130ms;
}

/* THE DOT ONLY MEANS "YOU ARE HERE" WHEN THE CHIP IS NAMING YOUR OWN LOCATION,
   AND UNTIL 2026-09-19 IT CLAIMED IT ALWAYS. It was a flat green circle with no
   JS behind it, so it sat there unchanged while Discover or a search moved the
   chip to a city on the far side of the world. Harmless as decoration; a lie
   the moment it started signifying anything, which is invariant 22's bug
   arriving through the chip instead of through a dropped note.
   So the pulse is gated on `.is-here`, written by `setPlaceIsHere()` in map.js
   and by nothing else. The resting appearance below is EXACTLY what it was —
   0.53 opacity, same green, no halo — so a place you have flown to looks today
   precisely as it always did, and only the true case gained a signal. */
.map-place__dot {
  width: 8px;
  height: 8px;
  border-radius: 50%;
  background: #22c55e;
  opacity: 0.53;
  flex: none;
  /* The halo is an absolutely positioned child of this. */
  position: relative;
  /* THE CYCLE, AND THE ONLY PLACE IT IS WRITTEN DOWN — same rule as
     `--panel-w`, `--sheet-h` and `--pulse-s`. Deliberately NOT shared with the
     map marker's `--pulse-s` (3.6s, invariant 30): that one is two staggered
     300px rings tuned to read as quiet breathing behind a live map, and this is
     an 8px status dot in a header, where 3.6s reads as barely moving. Different
     jobs, different rhythms, and they are far enough apart on screen — and the
     marker's pulse quiet enough — that the two do not beat against each other.
     If they are ever to match, promote --pulse-s to :root and use it here;
     do not copy the number. */
  --dot-pulse-s: 2s;
}

/* Live, so it goes to full strength: a signal that is both quiet AND
   intermittent is neither. */
.map-place.is-here .map-place__dot { opacity: 1; }

/* THE HALO IS A PSEUDO-ELEMENT, SO IT CANNOT BE CLIPPED BY THE NAME BESIDE IT.
   `.map-place__name` is `overflow: hidden` (that is what drives the truncation
   affordance, invariant 31) — this hangs off the DOT, which does not clip.
   It reaches 2.5x of 8px = 20px, i.e. 6px beyond the dot on each side, and the
   gap to the name is `--place-gap` at 8px (invariant 36), so it expands into
   space that is already empty and never touches the text. */
.map-place.is-here .map-place__dot::after {
  content: '';
  position: absolute;
  left: 50%;
  top: 50%;
  width: 100%;
  height: 100%;
  border-radius: 50%;
  background: #22c55e;
  /* Decoration over a control's label; it must never take a pointer. */
  pointer-events: none;
  transform: translate(-50%, -50%);
  animation: place-dot-pulse var(--dot-pulse-s) ease-out infinite;
}

/* THE KEYFRAMES MUST REPEAT `translate(-50%, -50%)`. The rule above centres
   this with a transform, and an animation's transform REPLACES it wholesale
   rather than composing with it — drop the translate and the halo leaves the
   dot and pulses out of its top-left corner. Exactly the collision invariants
   28 and 30 both record, and the third place in this file it applies.
   TRANSFORM AND OPACITY ONLY, never width/height or a redrawn radius, so this
   composites instead of repainting a bar that sits over a live map every
   frame. No `will-change`: a transform/opacity animation is already promoted,
   and invariant 35 is explicit about not leaving compositor hints around
   without a measured reason.
   THE MIDDLE STOP IS THE POINT. A plain two-stop fade spends its opacity far
   faster than its distance — measured on the map marker, that ring is already
   half gone 1.4px into its travel (invariant 30). Holding 0.18 at 70% keeps
   the halo legible while it is actually separating from the dot, which is the
   part that reads as a pulse. If this ever needs more presence, lengthen the
   hold before reaching for more alpha. */
@keyframes place-dot-pulse {
  0%   { transform: translate(-50%, -50%) scale(1);   opacity: 0.6; }
  70%  { transform: translate(-50%, -50%) scale(2.1); opacity: 0.18; }
  100% { transform: translate(-50%, -50%) scale(2.5); opacity: 0; }
}

/* The dot stays, at full strength, and only the motion goes — the same call as
   the map marker's pulse (invariant 30), and for the same reason: the static
   mark is what actually carries the meaning, the animation only draws the eye
   to it. */
@media (prefers-reduced-motion: reduce) {
  .map-place.is-here .map-place__dot::after { animation: none; opacity: 0; }
}

/* The chip is capped on mobile (max-width below) and nowrap, so a long
   Nominatim name — "Kathmandu Metropolitan City, Nepal" — used to spill the
   clock clean off a 375px screen. The NAME is the variable part, so it is the
   part that shrinks and ellipses; the dot and the clock are fixed-width and
   never give ground. This matters more now the clock is a button: text that
   overflows is merely unreadable, a control that overflows is unreachable. */
/* `overflow: hidden` clips at the PADDING box, and this element had none while
   its line-height (20px) exactly matched its font-size (20px) — so the line box
   had no room for anything below the baseline and the 2px of descender was
   cropped. Measured: clientHeight 20, scrollHeight 22. That is what was eating
   the tails off g, y, p and the comma in "gmina Szczecinek, Poland".

   The padding buys clipping room and the negative margin gives it straight back
   to the layout, so the chip is the same 36px it always was and the clock beside
   it does not move — the same trick .map-place__clock uses two rules down, for
   the same reason. Raising line-height instead would grow the chip and shift
   the clock, which invariant 10 in CLAUDE.md exists to prevent. */
.map-place__name {
  padding-block: 3px;
  margin-block: -3px;
  min-width: 0;             /* a flex item will not shrink below its text without this */
  overflow: hidden;
  text-overflow: ellipsis;
}

/* Only a CLIPPED name becomes something you can point at. `is-cut` is set from
   JS by measuring scrollWidth against clientWidth, because CSS cannot ask
   whether `text-overflow` actually fired — and a "see the full name" affordance
   on a name you can already read in full is worse than none at all. */
.map-place__name.is-cut { cursor: pointer; }
.map-place__name.is-cut:focus-visible { outline: 2px solid var(--fg); outline-offset: 2px; }

/* THE POPOVER HANGS OFF `.map-place`, NOT OFF THE NAME. The name is
   `overflow: hidden` — that is what draws the ellipsis — so a child of it would
   be clipped by the very rule that makes this necessary. Positioned against the
   segment instead, which stretches to the bar's full height, so `100%` is the
   bar's bottom edge and the 12px gap matches the clock menu's exactly.
   Same surface as that menu, deliberately: it is the second thing in this app
   to open below the bar and they should read as one idea. */
.map-place__full {
  /* ONE hiding mechanism, not two. This started with a `hidden` attribute as
     well, which meant the UA's `[hidden] { display: none }` and these rules were
     both deciding visibility and either could win depending on specificity.
     Display is the only switch now; JS toggles `.is-open` and never `.hidden`. */
  display: none;
  position: absolute;
  z-index: 3;
  top: calc(100% + 12px);
  left: 16px;               /* the segment's own left padding: under the dot */
  max-width: min(380px, calc(100vw - 48px));
  padding: 8px 12px;
  border: 1px solid rgba(255, 255, 255, 0.1);
  border-radius: 12px;
  /* Opaque, like the clock menu and for the same reason: a place name over
     moving map tiles at any alpha stops being legible. */
  background: #262626;
  box-shadow: 0 16px 32px -8px rgba(0, 0, 0, 0.7);
  color: #fafafa;
  /* THE APP'S BODY TEXT, EXACTLY (set 2026-09-18). The chip's display face is
     what made this reveal necessary, so it is set in the UI face and WRAPS
     rather than truncating — a truncated reveal would be a joke. It was 13px
     on an 18px line, which matched nothing else in the app; body copy here is
     Inter 400 at 14px on a 21px line, the same treatment `.card__comment-text`
     and `.card__artist` use. Note `--size-body` (20px) is NOT this: that token
     is the landing page's hero paragraph and is responsive, which is wrong for
     a small overlay.
     The colour stays #fafafa rather than the comment's
     `rgba(255,255,255,0.85)`: this exists solely to be read, and it is the
     only place a clipped name can be read at all. 14.5:1 against the #262626
     surface, against 11.3:1 at 0.85. */
  font-family: "Inter", sans-serif;
  text-transform: none;
  font-size: 14px;
  line-height: 21px;
  font-weight: 400;
  white-space: normal;
  overflow-wrap: anywhere;
  animation: clock-menu-in 140ms cubic-bezier(0.4, 0, 0.2, 1);
  transform-origin: top left;
}

/* WCAG 1.4.13, "Content on Hover or Focus", applies to this and drives both of
   the odd-looking rules below.
   HOVERABLE (b): the pointer must be able to move ONTO the popover without it
   vanishing. Hover lives on the NAME, and a sibling cannot keep itself open, so
   the trigger is lifted to `.map-place` with `:has()` — either the name or the
   popover being hovered keeps it up. The ::before below bridges the 12px gap so
   the journey between them never drops hover.
   DISMISSIBLE (a): Escape must close it WITHOUT moving focus or pointer, which
   a plain hover/focus rule cannot express — focus is still on the name, so the
   rule would just re-open it. `is-dismissed` is JS's way of saying "suppressed
   until you leave and come back"; it is cleared on blur and pointerleave. */
.map-place:has(.map-place__name.is-cut:not(.is-dismissed):hover) .map-place__full,
.map-place:has(.map-place__name.is-cut:not(.is-dismissed):focus-visible) .map-place__full,
.map-place:has(.map-place__full:hover) .map-place__full,
.map-place__name.is-cut.is-open:not(.is-dismissed) ~ .map-place__full { display: block; }

/* The bridge. Transparent, and it spans exactly the 12px gap between the bar's
   lower edge and the popover, so a pointer travelling from the name to the
   popover is never over neither. Without it, requirement (b) above fails on the
   way there rather than on arrival. */
.map-place__full::before {
  content: '';
  position: absolute;
  left: 0;
  right: 0;
  top: -12px;
  height: 12px;
}

@media (prefers-reduced-motion: reduce) {
  .map-place__full { animation: none; }
}

/* --- local time --- */

.map-place__time {
  position: relative;      /* the dropdown anchors to this */
  /* CREATES A STACKING CONTEXT, which is load-bearing: the pressed surface is
     `z-index: -1`, and without a context here that -1 escapes and sinks behind
     `.map-nav`'s own fill — which does not mis-stack the press, it makes it
     INVISIBLE. Same device as `.map-search { z-index: 0 }`. */
  z-index: 0;
  display: flex;
  align-items: center;
  gap: 8px;
  flex: none;
  /* STRETCHED TO THE BAR'S FULL HEIGHT, and that is what positions the
     dropdown. The menu is `top: calc(100% + 12px)` against this element, so
     `100%` has to mean the bar's height or the menu opens inside the bar:
     measured at 24px tall, the menu's top landed at y=74 against a bar bottom
     of 80 and overlapped it by 6px. Stretching makes `100%` the bar's own
     bottom edge, so the 12px gap is measured from where it looks like it
     should be — and it stays right if the segment's font-size changes, which
     it does at the narrow breakpoint. The digits stay centred because this
     element centres its own contents. */
  align-self: stretch;
}

/* The clock is a button (12/24-hour toggle) dressed as the text it replaced.
   Its 2px/6px padding is cancelled by an equal negative margin, so the digits
   sit exactly where they did before and the chip's own padding is untouched —
   only the hover pill is bigger than the glyphs. */
.map-place__clock {
  position: relative;
  /* inline-flex with an explicit gap, so the caret is centred against the
     digits and spaced on purpose — inline layout would space it by whatever
     whitespace the markup happens to contain and sit it on the baseline. */
  display: inline-flex;
  align-items: center;
  /* 6px, matching `.map-search__toggle`'s 6px between the magnifier and the
     placeholder — the bar now has ONE icon-to-text gap, used at both ends.
     Off the 4-point grid on purpose and listed with the other exceptions at the
     top of this file; see invariant 34 for why a derived value may be off-grid
     when a snapped one may not. */
  gap: 6px;
  font: inherit;
  /* Tabular figures so the minute changing does not shuffle the chip's width
     every sixty seconds. */
  font-variant-numeric: tabular-nums;
  color: inherit;
  opacity: 0.8;
  background: none;
  border: 0;
  padding: 2px 6px;
  margin: -2px -6px;
  border-radius: 100px;
  cursor: pointer;
  -webkit-tap-highlight-color: transparent;
  /* Opacity only. This carried `background-color 150ms` for the hover wash and
     the open fill, and both are gone — see the [aria-expanded] rule below. */
  transition: opacity 150ms ease;
}

/* The visible pill stays tight to the digits; the TAP target is this invisible
   box, 44px tall. Padding cannot do both jobs at once — growing it to 44px
   would drag a 44px hover pill out of a 36px chip. */
.map-place__clock::before {
  content: '';
  position: absolute;
  inset: -10px -4px;
}

/* NO BACKGROUND ON HOVER (2026-09-19, the user's call: it did not help the
   visuals). It was a `rgba(255,255,255,0.14)` pill, and it was the same
   generic panel that got deleted from the four map buttons — a wash says
   "something is here", which you already know, while the icons say what the
   control DOES (invariant 35). The caret's dip below carries the hover now.
   Removing it also un-muddies the OPEN state: hover and open painted the same
   wash and were told apart only by the recessed surface underneath, so the
   loudest part of the interaction was the part carrying no information. The
   wash now appears in exactly one state and means exactly one thing.
   The lift to full opacity STAYS — it is the same 0.8 -> 1 the whole bar's
   text makes while the field is being typed in, so the clock brightening under
   the pointer is consistent rather than decorative. */
.map-place__clock:hover {
  opacity: 1;
}

.map-place__clock:focus-visible {
  opacity: 1;
  outline: 2px solid #ffffff;
  outline-offset: 2px;
}

/* NO FILL WHILE THE MENU IS OPEN EITHER (2026-09-19, the user's call, a day
   after the hover wash went the same way). It was a `rgba(255,255,255,0.14)`
   pill hugging the digits, and it sat INSIDE the segment's recessed surface —
   a light shape on top of a dark one, so a state meant to read as pressed in
   was lit up instead, against the darker-never-lighter rule the rest of this
   bar follows (invariants 15 and 37).
   THE OPEN STATE STILL HAS THREE SIGNALS WITHOUT IT, which is why this is safe
   to delete rather than replace: the segment's recessed surface (invariant 36,
   and explicitly kept — the user asked only for the fill around the digits to
   go), the caret's full 180deg flip, and the digits coming up to opacity 1.
   Nothing sets a background on this button any more — not rest, not hover, not
   focus, not open — so `background-color` has been dropped from the base rule's
   transition list as well. Put a fill back here and that transition has to come
   back with it, or it will snap. */
.map-place__clock[aria-expanded="true"] {
  opacity: 1;
}

/* The affordance. Sized down and set below full opacity so it reads as a hint
   attached to the time rather than a second piece of content beside it. */
.map-place__caret {
  flex: none;
  opacity: 0.75;
  transition: transform 200ms cubic-bezier(0.4, 0, 0.2, 1), opacity 150ms ease;
}

/* THE CARET LEANS TOWARDS WHERE THE MENU WILL OPEN (2026-09-19). 2px down on
   hover, then the full 180deg flip when the menu is actually open — one
   continuous gesture rather than two unrelated states, and the direction is the
   information: this thing drops downward.
   `:not([aria-expanded="true"])` IS NOT DECORATION. Both rules set `transform`
   on the same element and they are the same specificity (0,3,0) without it, so
   which one won would be decided by source order alone — the fragile kind of
   rule that breaks the first time somebody moves a block. Excluding the open
   state makes it explicit, and it is also correct behaviour: once the menu is
   open the caret points UP at it, and dipping from there would be backwards.
   The bounce is on the way in only; the base rule keeps the plain curve for
   the return, and the same curve still carries the 180deg flip. */
@media (hover: hover) {
  .map-place__clock:not([aria-expanded="true"]):hover .map-place__caret {
    transform: translateY(2px);
    transition: transform 260ms cubic-bezier(0.34, 1.4, 0.64, 1),
                opacity 150ms ease;
  }
}

.map-place__clock[aria-expanded="true"] .map-place__caret { transform: rotate(180deg); }

/* WHILE THE FIELD IS BEING TYPED IN, THE REST OF THE BAR'S TEXT COMES UP TO
   FULL WHITE TOO (asked for 2026-09-18).
   The place NAME was already `#ffffff` at opacity 1 and needed nothing. What
   read as dim beside a lit search segment was everything around it: the clock
   at 0.8, the `·` at 0.65 and the caret at 0.75 — all of them full white
   knocked back by opacity, which is exactly why raising them is safe. Opacity
   only ever ADDS contrast here; none of the tuned values in invariant 12 are
   being undercut, they are being temporarily suspended.
   THE TRIGGER IS THE INPUT'S FOCUS, hung off the BAR rather than the segment
   because the place chip is the search form's SIBLING — `.map-search:has(...)`
   cannot reach it. It is still the input's own focus and not `:focus-within`,
   so the toggle and the clear button still do not fire it (invariant 15).
   150ms, matching the clock's own hover transition rather than the segment's
   130/260 press split: these three already move together on that timing when
   you hover the clock, and giving the same elements two different speeds
   depending on which thing woke them would read as a fault.
   Below 861px this is inert by construction — the place segment stands down
   entirely while the field is open, so there is nothing left to light. */
/* The `·` used to be lifted here too. It is gone (2026-09-18) — replaced by
   the rule that now divides the name from the time, which is a fixed
   `rgba(255,255,255,0.14)` and deliberately does NOT brighten: a divider that
   responds to focus reads as a control. */
.map-nav:has(.map-search__input:focus) .map-place__clock,
.map-nav:has(.map-search__input:focus) .map-place__caret {
  opacity: 1;
}

/* AND THE CLOCK AND ITS CARET COME UP WHILE THE DROPDOWN IS OPEN
   (2026-09-18). "Copy the search input bar" is not only the pressed surface:
   the other half of that state is the segment's own text going to full white,
   so it reads as one lit object rather than a dark well with dim writing in
   it. Both are full white knocked back by OPACITY, so raising them only ever
   ADDS contrast — invariant 12's tuned values are suspended, never undercut,
   and the pressed ground is darker than the bar so the numbers improve twice.
   The place NAME is untouched: it is outside the press now, and it was already
   #ffffff at opacity 1 in any case.
   No pseudo-element in this list, which is the only reason it may be grouped
   at all (invariant 15). */
.map-place__time:has(.map-place__clock[aria-expanded="true"]) .map-place__clock,
.map-place__time:has(.map-place__clock[aria-expanded="true"]) .map-place__caret {
  opacity: 1;
}

/* --- time-format dropdown --- */

/* Anchored to the time wrapper's right edge, which — because the button's
   padding is cancelled by an equal negative margin — is the right edge of the
   caret. So the menu lines up under the control it belongs to at every chip
   width, on a centred desktop chip and a right-anchored mobile one alike. */
.clock-menu {
  position: absolute;
  z-index: 3;
  top: calc(100% + 12px);
  right: 0;
  display: flex;
  flex-direction: column;
  gap: 4px;
  min-width: 184px;
  padding: 8px;
  border: 1px solid rgba(255, 255, 255, 0.1);
  border-radius: 16px;
  /* Opaque, unlike the chip: rows of text over moving map tiles at 0.7 alpha
     is where a translucent surface stops being legible. */
  background: #262626;
  box-shadow: 0 16px 32px -8px rgba(0, 0, 0, 0.7);
  text-align: left;
  animation: clock-menu-in 140ms cubic-bezier(0.4, 0, 0.2, 1);
  transform-origin: top right;
}

@keyframes clock-menu-in {
  from { opacity: 0; transform: translateY(-6px) scale(0.96); }
  to   { opacity: 1; transform: none; }
}

.clock-menu__item {
  display: flex;
  align-items: center;
  gap: 8px;
  width: 100%;
  padding: 8px 12px;
  border: 0;
  border-radius: 10px;
  background: none;
  color: var(--fg);
  font: inherit;
  font-size: var(--size-label);
  font-weight: 600;
  line-height: 20px;
  text-align: left;
  cursor: pointer;
  transition: background-color 150ms ease;
}

.clock-menu__item:hover { background: #3a3a3a; }

.clock-menu__item:focus-visible {
  background: #3a3a3a;
  outline: 2px solid var(--fg);
  outline-offset: -2px;
}

/* The tick keeps its 12px column whether or not it is showing, so the two rows
   stay aligned and the menu does not twitch sideways as the choice moves. */
.clock-menu__tick {
  flex: none;
  color: var(--cta);
  visibility: hidden;
}

.clock-menu__item[aria-checked="true"] .clock-menu__tick { visibility: visible; }
.clock-menu__item[aria-checked="true"] { font-weight: 700; }

.clock-menu__label { flex: 1 1 auto; }

/* The live preview of each format — the row's evidence, so it is muted and
   tabular like the clock it is previewing. */
.clock-menu__eg {
  flex: none;
  font-variant-numeric: tabular-nums;
  font-weight: 400;
  opacity: 0.6;
}

@media (max-width: 640px) {
  .clock-menu { min-width: 172px; }
  /* 12px + 20px line + 12px = a 44px row. The desktop 38px is fine for a
     pointer and short for a thumb. */
  .clock-menu__item { padding: 12px; font-size: 16px; }
}

@media (prefers-reduced-motion: reduce) {
  .map-place__clock,
  .map-place__caret,
  .clock-menu__item { transition: none; }
  .clock-menu { animation: none; }
}

/* THE HOVER MOTION IS DECORATIVE, SO IT IS REMOVED RATHER THAN MERELY
   UNTIMED (2026-09-19). Killing the transition alone would leave the lens, the
   X and the caret JUMPING to their hovered positions instantly, which is more
   jarring than the eased version, not less — the same conclusion
   `.map-pin:hover .map-pin__inner { transform: none }` reached (invariant 28).
   This is the opposite call from the countdown ring, which keeps updating under
   reduced motion and only loses its smoothing, because that ring carries
   information and these three carry none.
   The segment's pressed surface is NOT listed: it is a colour and a shadow
   rather than travel, it is the only thing saying the segment is one control,
   and the existing `.map-search::before { transition: none }` above already
   takes its easing away. */
@media (prefers-reduced-motion: reduce) {
  .map-search__toggle:hover .icon { --tgl-s: 1; }
  .map-search__clear:hover .icon { transform: none; }
  .map-search__clear .icon { transition: none; }
  .map-place__clock:not([aria-expanded="true"]):hover .map-place__caret {
    transform: none;
  }
}

/* MapLibre's attribution sets a colour on its links but not on the text around
   them, so that text INHERITED this app's white and landed on MapLibre's
   near-white box — effectively invisible over a light basemap. This is the ODbL
   credit (invariant 1); it has to be readable, not merely present. */
.maplibregl-ctrl-attrib-inner,
.maplibregl-ctrl-attrib-inner a { color: rgba(0, 0, 0, 0.75); }

/* MapLibre sets `font: 12px/20px Helvetica Neue, Arial, ...` on
   `.maplibregl-map` itself, so EVERYTHING it owns inherited that face: the
   ODbL credit, which was the only visible text in the app in neither Inter nor
   Bungee, and every control button inside the map.
   **Set on `.maplibregl-map`, not on the attribution alone, and that is the
   point.** Overriding only the credit fixed the visible half and left the four
   map buttons inheriting Helvetica Neue — which is what happened on the first
   pass, and only showed up because the audit was re-run afterwards. Fixing the
   face at the container is the one place that covers both.
   It costs 15.7px of credit width (316.2 -> 331.9 measured) because Inter is
   the wider face; that is bottom-right above the zoom stack, with room for it.
   `font-family` only — MapLibre's 12px/20px sizing is left alone.
   This is CSS on MapLibre's DOM, not a change to the basemap STYLE; invariant
   29 is about layers in the style document and is untouched. The credit stays
   visible and readable, which is the licence obligation (invariant 1); only
   its typeface changes. */
.maplibregl-map { font-family: "Inter", sans-serif; }

/* --- recentre control ---
   It sits in MapLibre's own control stack and wears MapLibre's classes, so the
   white pill, the corner margins, the hover wash and the blue focus ring all
   come for free and match the +/- above which it sits. Only two things are
   ours: centring a 20px icon in the 29px button, and the disabled state —
   MapLibre dims `.maplibregl-ctrl-icon`, and this is a plain <img>. */
/* The selector has to match MapLibre's own shape, not just name our class.
   MapLibre ships `.maplibregl-ctrl-group button { display: block }` at (0,1,1),
   which outranks a bare `.map-recentre` at (0,1,0) — so a plain class rule here
   is silently ignored and the flex centring does nothing. The icon then sat
   flush against the left edge (0px left, 9px right) while looking vertically
   fine, because a button's UA styling centres its content box on its own.
   Adding our class to MapLibre's selector takes this to (0,2,1). Do not
   "simplify" it back to `.map-recentre`. */
.maplibregl-ctrl-group button.map-recentre {
  display: flex;
  align-items: center;
  justify-content: center;
}

.map-recentre .icon { color: #0d0d0d; }

.map-recentre:disabled .icon { opacity: 0.25; }

/* --- Discover, as a map control (2026-09-18) ---
   Moved out of the header bar to sit above the crosshair, handing its 60px plus
   a divider back to the search field and the place name.
   The same (0,2,1) selector shape as .map-recentre above, and for the identical
   reason: MapLibre's `.maplibregl-ctrl-group button` is (0,1,1) and silently
   outranks a bare class, leaving the icon flush left while looking vertically
   fine. Do not shorten it. */
.maplibregl-ctrl-group button.map-discover {
  display: flex;
  align-items: center;
  justify-content: center;
  /* The label is absolutely positioned OUTSIDE this 29px box, so the button
     must not clip it. MapLibre's group has no overflow of its own. */
  overflow: visible;
  position: relative;
}

.map-discover .icon { color: #0d0d0d; }

/* DISCOVER IS GOLD, AND ON HOVER IT GROWS INTO A LABELLED PILL (2026-10-02,
   asked for directly after user feedback that the button "is not very
   clear"). At rest: the app's own accent (`--cta`, the "Locate me" gold) on
   the whole control group, the only coloured button in the stack, with the
   dark globe (12.9:1). On hover / keyboard focus: the gold reaches out to the
   LEFT of the button into a pill that reads "Discover", and the globe still
   hops (the hop rules below are untouched).
   The pill is `.map-discover__label`, a child of the button (so hovering it
   IS hovering the button — WCAG 1.4.13 hoverable, by construction). It is
   absolutely positioned and anchored to the button's RIGHT edge, its own
   padding-right reserving the button's 29px, so its right end sits under the
   globe and the two read as one object. It never takes layout space: the
   control stack does not reflow or shift while it opens.
   The reveal is a clip-path wipe from the button outwards, not a width
   animation — width would relayout the text on every frame. The group's
   corners round to match the pill at the same time, so the square becomes
   the pill's rounded right end rather than a square glued onto a pill.
   Not this colour: the play button's orange-red, which is the "you are
   here" circle's colour and would read as the same thing. */
.maplibregl-ctrl-group.map-discover-group {
  background: var(--cta);
  transition: border-radius 220ms cubic-bezier(0.4, 0, 0.2, 1);
}
/* MapLibre darkens a hovered button with a 5% black wash; on gold that reads
   as a grubby square inside the pill. The pill itself is the hover answer. */
.maplibregl-ctrl-group.map-discover-group button.map-discover:hover { background-color: transparent; }

.map-discover__label {
  position: absolute;
  top: 0;
  right: 0;
  height: 100%;
  display: flex;
  align-items: center;
  /* 29px reserves the button itself; 12px of air before the word. */
  padding: 0 29px 0 12px;
  border-radius: 999px;
  background: var(--cta);
  color: #0d0d0d;
  font-family: "Inter", sans-serif;
  font-size: 12px;
  line-height: 16px;
  font-weight: 600;
  white-space: nowrap;
  /* Behind the globe: the pill's right end sits under the button. */
  z-index: -1;
  /* THE OUTLINE ONLY EXISTS WHILE THE PILL IS OPEN (2026-10-02). Open, the
     pill carries MapLibre's own 2px 10% ring so the outline wraps the WHOLE
     pill, matching the other buttons (the group's own ring is switched off
     then, or it stopped short at the square). Closing, the ring fades out
     in 100ms, before the pill has shrunk, because a ring left on the
     shrinking pill read as a "drop shadow" inside the square. */
  box-shadow: 0 0 0 2px rgba(0, 0, 0, 0);
  /* Closed: clipped down to the button's own 29px AND invisible. The clip
     alone left the pill's rounded end and its 2px ring showing INSIDE the
     gold square as a "strange rounded drop shadow" (reported 2026-10-02).
     Opacity hides it completely; it fades in at the START of the wipe and
     out only after the wipe has closed (the 200ms delay on this base rule),
     so it is never visible as a stub under the button. */
  opacity: 0;
  clip-path: inset(-3px -3px -3px calc(100% - 29px) round 999px);
  pointer-events: none;
  transition: clip-path 240ms cubic-bezier(0.4, 0, 0.2, 1),
              opacity 60ms linear 200ms,
              box-shadow 100ms linear;
}
/* The button needs a stacking context so the label's -1 stays above the
   group's gold rather than sinking under it. */
.maplibregl-ctrl-group button.map-discover { z-index: 0; }

/* `is-labelled` is set on first hover or focus so the pill cannot animate in
   on page load; `is-dismissed` is Escape's suppression, cleared on leaving —
   the dismissible half of 1.4.13, which a hover rule cannot express because
   focus is still on the button and would re-show it on the same frame. */
.map-discover.is-labelled:not(.is-dismissed):hover .map-discover__label,
.map-discover.is-labelled:not(.is-dismissed):focus-visible .map-discover__label {
  opacity: 1;
  clip-path: inset(-3px round 999px);
  pointer-events: auto;
  box-shadow: 0 0 0 2px rgba(0, 0, 0, 0.1);
  transition: clip-path 240ms cubic-bezier(0.4, 0, 0.2, 1), opacity 60ms linear,
              box-shadow 0s;
}
.maplibregl-ctrl-group.map-discover-group:has(.map-discover.is-labelled:not(.is-dismissed):hover),
.maplibregl-ctrl-group.map-discover-group:has(.map-discover.is-labelled:not(.is-dismissed):focus-visible) {
  border-radius: 0 15px 15px 0;
  /* The pill draws the outline now; the square's own ring would stop short. */
  box-shadow: none;
}

@media (prefers-reduced-motion: reduce) {
  .map-discover__label { transition: none; }
  .maplibregl-ctrl-group.map-discover-group { transition: none; }
}
}

/* --- admin control (2026-09-25, changed to a plain text link 2026-09-27) ---
   Bottom-LEFT, deliberately: bottom-right already carries Discover, the
   crosshair and the +/- (invariant 11), and a fifth control crowded in there
   would put "Admin" right next to the controls a visitor actually uses.
   The attribution control shares this corner too now (2026-09-28) — see the
   note beside the `addControl` calls in map.js for why and in what order.
   Same (0,2,1) selector shape as .map-recentre/.map-discover above, for the
   same reason: MapLibre's `.maplibregl-ctrl-group button` is (0,1,1) and
   silently outranks a bare class.
   Deliberately NOT part of "the buttons answer a hover" language just below —
   that treatment says "this does something fun", and the point of this
   control is the opposite. It only dims in from a muted grey to near-black,
   gated on (hover: hover) so a tap on touch can't leave it stuck darkened.

   NO LONGER A GEAR ICON IN A WHITE 29x29 SQUARE — a plain word, asked for
   directly ("don't make this a 'setting' icon, just make it a text button
   like on the home page"), i.e. `.owner-link`'s own quiet-text treatment.
   MapLibre's `.maplibregl-ctrl-group` (the button's own parent div, added by
   `AdminControl.onAdd` in map.js) ships a fixed white pill background built
   for a 29x29 icon glyph — keeping it would have put the word "Admin" inside
   a small white box that still reads as an icon-button, the opposite of what
   was asked. `:has()` strips it for exactly this one group (scoped to
   bottom-left, where AdminControl is the only member, so nothing else in the
   `.maplibregl-ctrl-group` family anywhere else on the map is touched) rather
   than touching the shared MapLibre class itself.
   Dark ink, not `.owner-link`'s pale white — that link sits on the dark
   landing artwork, this sits over a light basemap beside white icon
   buttons — but the same muted-at-rest, legible-on-hover-or-focus idiom
   either way. Font comes from the existing `.maplibregl-map { font-family:
   "Inter" }` override (invariant 33) for free; nothing new needed for that.
   The blue MapLibre focus ring is left alone, same as every other control in
   this stack — none of them override it, so this doesn't invent a new
   idiom just for itself. */
.maplibregl-ctrl-bottom-left .maplibregl-ctrl-group:has(.map-admin) {
  background: none;
  box-shadow: none;
}

.maplibregl-ctrl-group button.map-admin {
  display: block;
  width: auto;
  height: auto;
  padding: 6px 8px;
  font-size: 13px;
  font-weight: 500;
  line-height: 1;
  white-space: nowrap;
  color: rgba(13, 13, 13, 0.45);
}

@media (hover: hover) {
  .map-admin:hover { color: rgba(13, 13, 13, 0.85); }
}

.map-admin:focus-visible { color: rgba(13, 13, 13, 0.85); }

/* THE OVERLAP WITH THE ATTRIBUTION TEXT IS FIXED IN map.js, NOT HERE, AND
   NOT WITH A GUESSED MARGIN (2026-09-28) — supersedes a same-day attempt at
   a real footer strip below a shrunk canvas, reverted a message later: "I
   don't want a black bar for the admin button. I want it to be on the map
   just like the openfreemap text is." No canvas shrink, no solid
   background, no second button — this is still the one control from
   2026-09-25, unchanged here.
   A fixed CSS margin was tried first and measured wrong: the ODbL credit
   (never MapLibre's compact "i" icon — invariant 1) is a single 20px line
   at 375px wide but WRAPS TO TWO LINES, 40px tall, at 320px — so any margin
   tuned for one width undershoots the other. The actual fix is in map.js:
   the attribution control is now added to this SAME 'bottom-left' corner,
   after AdminControl, so MapLibre's own float+clear stacking (the same
   mechanism the bottom-right Discover/crosshair/+/- column already uses,
   invariant 11) keeps the two apart automatically, however many lines the
   credit wraps to at any width — nothing to retune here if that ever
   changes again. */

/* --- the buttons answer a hover ON THE ICON, not with a ring (2026-09-18) ---
 *
 * A press ring and a hover ring were both built and both removed on the user's
 * call. Each button now says what it DOES when you hover it: + grows, - shrinks,
 * the crosshair turns, the globe hops. The gesture is the button's own function
 * performed on its own glyph, which a ring — identical on all four — could
 * never say.
 *
 * THE GATE IS `(hover: hover)` AND IT IS LOAD-BEARING, not tidiness. On a
 * touchscreen `:hover` STICKS after a tap, so an ungated rule would leave a
 * tapped + permanently enlarged until something else was touched. Same gate,
 * same reason, as `.card__close`'s focus restore (invariant 26).
 *
 * THE ZOOM PAIR ARE NOT OUR `.icon` SVGs. MapLibre draws them as a background
 * image on its own `.maplibregl-ctrl-icon` span, so the transform goes on that
 * span — a transform scales everything the element paints, background image
 * included. Do not look for an `<svg>` here; there isn't one.
 *
 * TRANSITIONS, NOT ANIMATIONS, because these are STATES that hold for as long
 * as the pointer is there and reverse when it leaves. An animation would play
 * once and hand the glyph back. The globe's hop is the deliberate exception:
 * it is a one-shot greeting, so it stays a keyframe animation.
 */
@media (hover: hover) {
  /* SMOOTHED 2026-09-18, AND THE CURVE WAS THE PROBLEM, NOT THE FRAME RATE.
     This was `160ms cubic-bezier(0, 0, 0.2, 1)`, and that curve has its
     control point at the origin, which means it STARTS AT MAXIMUM VELOCITY —
     the initial slope is 1 / 0.2 = 5, five times the average rate. The glyph
     therefore jumped the instant the pointer arrived and then eased into
     place: all deceleration, no acceleration, which reads as a snap rather
     than as movement.
     `cubic-bezier(0.4, 0, 0.2, 1)` has its first control point at x = 0.4, so
     the initial slope is 0 / 0.4 = 0 and the glyph STARTS FROM REST. That one
     change is most of what "smoother" was asking for.
     MEASURED FIRST, so this is not a guess at a performance problem: across a
     full transition the frame deltas were 8.3ms median, 9.2ms worst, ZERO
     frames over 20ms on a 120Hz display. Nothing was being dropped. Do not
     reach for `will-change` here — it would buy nothing measurable and would
     leave a compositor hint on idle controls, which is the thing the removed
     hover ring was careful about.
     Nor is this a rasterisation problem: the zoom pair are a background-image
     SVG, and scaled to 6x it renders perfectly crisp, so the browser
     re-renders it at size rather than stretching a bitmap.
     ENTER AND LEAVE ARE DIFFERENT SPEEDS, the same idiom as the search
     segment's 130 / 260 press split: it answers the pointer arriving promptly
     and relaxes more slowly when it goes. The slow value lives here on the
     base rule and the quick one on the hover rules below, so no JS swaps
     anything. */
  .maplibregl-ctrl-group button.maplibregl-ctrl-zoom-in .maplibregl-ctrl-icon,
  .maplibregl-ctrl-group button.maplibregl-ctrl-zoom-out .maplibregl-ctrl-icon,
  .map-recentre .icon {
    transition: transform 280ms cubic-bezier(0.4, 0, 0.2, 1);
  }

  /* The glyph itself is about 12px inside a 29px span, so 1.3 takes it to
     ~15.6px and 0.75 to ~9px — both comfortably inside the button, nothing to
     clip and no effect on the neighbour below. The pair is deliberately
     ASYMMETRIC about 1: a matched 1.25/0.8 read as the same amount of movement
     twice, where the point is that these two do opposite things. */
  .maplibregl-ctrl-group button.maplibregl-ctrl-zoom-in:hover .maplibregl-ctrl-icon {
    transform: scale(1.3);
    /* THE ARRIVAL, quicker than the release above. */
    transition-duration: 200ms;
  }

  .maplibregl-ctrl-group button.maplibregl-ctrl-zoom-out:hover .maplibregl-ctrl-icon {
    transform: scale(0.75);
    /* THE ARRIVAL, quicker than the release above. */
    transition-duration: 200ms;
  }

  /* 45deg, AND A QUARTER TURN WOULD BE INVISIBLE. Phosphor's crosshair has its
     ticks at top, right, bottom and left — four-fold symmetry — so 90, 180 and
     270 all land on a shape identical to 0deg and read as nothing happening.
     45 is the only rotation that shows, and it sits the ticks on the diagonal
     like a reticle coming into alignment. Checked against the sprite's own
     path, not assumed.
     It HOLDS while hovered and unwinds on leave, which is why this is a
     transition: a one-shot spin here would be the globe's gesture on a second
     button. */
  .map-recentre:hover:not(:disabled) .icon {
    transform: rotate(45deg);
    /* THE ARRIVAL, quicker than the release above. */
    transition-duration: 200ms;
  }

  /* A disabled crosshair must not answer — it is disabled for the whole of
     browse mode (invariant 25) and there is nowhere to recentre to. */
  .map-recentre:disabled .icon {
    transform: none;
  }
}

/* No hover transforms at all under reduced motion. These are the only feedback
   the four buttons have left, so this genuinely removes it — MapLibre's own
   hover wash and focus ring are what remain. Correct trade: none of these
   carries information, they only acknowledge.
   Three plain class selectors, no pseudo-element among them, so grouping is
   safe here (invariant 15). */
@media (prefers-reduced-motion: reduce) {
  .maplibregl-ctrl-group button.maplibregl-ctrl-zoom-in:hover .maplibregl-ctrl-icon,
  .maplibregl-ctrl-group button.maplibregl-ctrl-zoom-out:hover .maplibregl-ctrl-icon,
  .map-recentre:hover .icon {
    transform: none;
    transition: none;
  }
}

/* --- the Discover globe: a hop on hover, a spin on press (2026-09-18) ---
 *
 * TWO ELEMENTS, ONE ICON, AND THAT IS THE WHOLE POINT. Both effects are
 * transforms, and invariant 28 records what happens when two animations want
 * the same property on one node — the later silently deletes the earlier, with
 * nothing in the computed style to show for it. So the WRAPPER SPAN turns and
 * the SVG INSIDE IT hops. Never move either onto the other.
 */
.map-discover__globe {
  display: flex;
  /* The span must not become a layout of its own between the flex-centred
     button and the icon it wraps. */
  align-items: center;
  justify-content: center;
}

/* One quick revolution. 550ms is "a little quickly" — fast enough to read as a
   flick of the wrist, slow enough that the continents are not a blur. The curve
   is the material standard accelerate-decelerate, so it starts and lands softly
   instead of strobing. Not infinite: map.js clears the class on animationend. */
.map-discover__globe.is-spinning {
  animation: map-discover-spin 550ms cubic-bezier(0.4, 0, 0.2, 1);
}

@keyframes map-discover-spin {
  from { transform: rotate(0deg); }
  to   { transform: rotate(360deg); }
}

/* A single hop on hover, 3px up. It runs ONCE per pointer entry because a CSS
   animation restarts only when the rule starts matching again — no JS, and no
   `infinite`, which is what keeps it a greeting rather than a fidget.
   Gated on `(hover: hover)` for the same reason as the ring above: a sticky
   touch `:hover` would leave it mid-hop.
   The second, smaller bounce at 85% is what makes it read as weight settling
   rather than a slide up and back. */
@media (hover: hover) {
  /* `linear` is not the motion — every keyframe below sets its own easing. */
  .map-discover:hover .icon {
    animation: map-discover-hop 460ms linear;
  }
}

/* SMOOTHED 2026-09-18: THE LEGS NOW HAVE GRAVITY, WHICH THEY DID NOT.
   One curve governed the whole hop, and `animation-timing-function` applies
   between EACH pair of keyframes — so every leg, up AND down, decelerated into
   its endpoint. A thing that slows down as it falls is not falling, and that
   is what made this read as mechanical: it stalled at the apex, drifted back
   down, stalled again.
   Real weight does the opposite on the way down. Each rise now uses an
   ease-OUT (leaving the ground fast, slowing toward the apex) and each fall an
   ease-IN (accelerating into the landing). The amplitudes are unchanged at
   -3px and -1px — this is the same hop, moving correctly.
   460ms rather than 420 gives the extra air the new curves need to read;
   shorter and the acceleration has no room to show. */
@keyframes map-discover-hop {
  0% {
    transform: translateY(0);
    animation-timing-function: cubic-bezier(0.22, 0.61, 0.36, 1);
  }
  38% {
    transform: translateY(-3px);
    animation-timing-function: cubic-bezier(0.55, 0.06, 0.68, 0.19);
  }
  64% {
    transform: translateY(0);
    animation-timing-function: cubic-bezier(0.22, 0.61, 0.36, 1);
  }
  82% {
    transform: translateY(-1px);
    animation-timing-function: cubic-bezier(0.55, 0.06, 0.68, 0.19);
  }
  100% {
    transform: translateY(0);
  }
}

/* The hop and the spin stand down under reduced motion, and nothing replaces
   them: with the rings gone (2026-09-18) these two ARE the button feedback, so
   a user who has asked for less movement is left with MapLibre's own hover
   wash and focus ring and nothing else. That is the correct trade — neither of
   these carries information, they only acknowledge.
   `.map-discover__globe` and `.map-discover .icon` may share a rule because
   NEITHER IS A PSEUDO-ELEMENT. If any selector in a comma-separated list is
   not understood by an engine the whole rule is discarded, declarations and
   all, which shipped once and took three reports to find (invariant 15). */
@media (prefers-reduced-motion: reduce) {
  /* map.js checks the same query before it adds `is-spinning`, so this is the
     second lock rather than the only one — a CSS rule can hide a class's
     effect but cannot stop the class being added. */
  .map-discover__globe.is-spinning,
  .map-discover:hover .icon {
    animation: none;
  }
}

/* --- you are here --- */

/* Both halves are centred on the marker's own anchor point, so the halo stays
   concentric with the dot at any zoom. The halo is a fixed pixel size, which
   means it does NOT represent a real distance on the ground — if it should be
   a true radius it has to become a MapLibre circle layer measured in metres. */
.map-me { position: relative; width: 0; height: 0; }

.map-me__halo,
.map-me__dot,
.map-me__pulse {
  color: #ffffff;   /* Phosphor ink: was fill="white" on the + inside the circle */
  position: absolute;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
  border-radius: 50%;
}

/* THE RING CARRIES THE BOUNDARY NOW, NOT THE FILL (2026-09-17).
   The fill was 0.3 and the border 0.2 — a flood of red with a boundary too
   faint to find, which made "you are here" the loudest object on a map whose
   entire subject is the notes. Inverted: the fill drops to 0.10 and the border
   goes to FULL opacity, so the circle is legible as an edge rather than an
   area. Same hue throughout (#f1472f), so nothing about its identity changes.

   The coloured drop shadow that used to sit under this is GONE. It existed to
   lift a solid fill off the basemap; under a 0.10 fill it was just red haze
   around the ring, competing with the edge it was meant to support. */
.map-me__halo {
  /* Desktop only — the narrow breakpoint below keeps 140px, because 300 would
     be 80% of a 375px screen. Radius follows from this: border-radius is 50%,
     so the circle is always half the width, currently 150px. */
  width: 300px;
  height: 300px;
  background: rgba(241, 71, 47, 0.10);
  /* 0.7, not full strength (2026-09-17, second pass). At 1.0 the ring read as
     a hard boundary — an enclosure drawn on the map rather than a soft "about
     here". It still carries the edge, which is the whole point of the fill
     being only 0.10, so this is as far as it goes: much below 0.6 and the
     boundary starts depending on the fill again and the inversion is undone. */
  border: 2px solid rgba(241, 71, 47, 0.7);
}

/* The pulse is a SEPARATE element, layered behind the halo, and it is inert.
   Two reasons, both load-bearing:

   1. `pointer-events: none` — the halo is the tap target ("Drop a music note
      at your location"), and an animating element over it would hand some of
      those taps to a moving edge. The handlers live on the `.map-me` wrapper,
      so anything that bubbles counts as a tap; this element must never bubble.
   2. It animates TRANSFORM AND OPACITY ONLY, never width/height or a redrawn
      radius, so it composites instead of repainting the map on every frame —
      the same rule the panel reveal follows. `will-change: transform` goes
      here and nowhere else in this component.

   THE KEYFRAMES MUST REPEAT `translate(-50%, -50%)`. The base rule centres
   this element with a transform, and an animation's transform REPLACES it
   wholesale rather than adding to it — drop the translate from the keyframes
   and the ring leaves the marker and pulses from its top-left corner. This is
   the same collision as the hover spin on the map pins (invariant 28). */
.map-me__pulse {
  /* --pulse-s IS THE CYCLE AND THE ONLY PLACE IT IS WRITTEN DOWN. The second
     ring's stagger is DERIVED from it below, because "half a cycle" stops
     being half a cycle the moment someone retunes the duration and misses the
     delay — the two rings then bunch up and the continuity the second ring
     exists for is silently gone. Same rule as --panel-w and --sheet-h. */
  --pulse-s: 3.6s;
  width: 300px;
  height: 300px;
  border: 2px solid rgb(241, 71, 47);
  pointer-events: none;
  will-change: transform;
  animation: map-me-pulse var(--pulse-s) ease-out infinite;
}

/* TWO RINGS, HALF A CYCLE APART — and the stagger is the entire point of the
   second one. A single ring spends most of its 2s faded out, so the marker sat
   still for over a second between breaths; offset by 1s there is always one
   ring in flight and the motion reads as continuous rather than as a blink.

   THE DELAY IS NEGATIVE ON PURPOSE. A positive 1s delay would leave this ring
   invisible for the first second after the map opens — the exact moment the
   user is looking at it. A negative delay starts it already mid-flight, so
   both rings are live from the first frame.

   It keeps the `.map-me__pulse` class, so the reduced-motion rule and the
   `pointer-events: none` both cover it without being restated. */
.map-me__pulse--2 { animation-delay: calc(var(--pulse-s) / -2); }

/* GENTLER, 2026-09-17 (third pass): the cycle went 2s -> 3.6s and the peak
   0.6 -> 0.42. With two rings a 2s cycle launched one every second, which read
   as an insistent heartbeat rather than a marker quietly breathing. The TRAVEL
   is untouched at 1.06 — it is only 9px on desktop and 4px on mobile, and
   taking that down is what would push it back to invisible. Slow and dim are
   the gentleness knobs here; distance is not. */
@keyframes map-me-pulse {
  from { transform: translate(-50%, -50%) scale(1);    opacity: 0.42; }
  to   { transform: translate(-50%, -50%) scale(1.06); opacity: 0;    }
}

/* The dot is 36px against the notes' 60px — it has to read as "you are here",
   not as the most prominent thing on screen, and at 50px it was barely smaller
   than a note while being far louder in colour. THE ORANGE IS UNCHANGED
   (#f1472f, the user's call): size does the work, not a muted fill.
   Shrinking it costs nothing in reachability, because the 300px halo is the
   tap target and this sits inside it. */
.map-me__dot {
  display: flex;
  align-items: center;
  justify-content: center;
  width: 36px;
  height: 36px;
  background: #f1472f;
}

/* NIGHT DEEPENS THE ORANGE (2026-09-30, asked for directly: "almost feels a
   little harsh" at night). Against the night dim's slate (~#7d8494) the
   daytime #f1472f measures 1.01:1 — the SAME brightness, opposite hue — and a
   hue-only edge vibrates. So as the map dims, the marker blends toward a
   deeper burnt orange #ad301d (~1.8:1 on the slate, and a better ground for
   the white glyph). `--night` is written on the map container by
   updateNight() in map.js, the same 0..1 that drives `.map-night`. Daytime
   (--night 0) is byte-identical to before. Inside @supports so a browser
   without color-mix keeps the plain daytime rules above. */
@supports (color: color-mix(in srgb, red 50%, blue)) {
  .maplibregl-map { --me: color-mix(in srgb, #ad301d calc(var(--night, 0) * 100%), #f1472f); }
  .map-me__halo {
    background: color-mix(in srgb, var(--me) 10%, transparent);
    border-color: color-mix(in srgb, var(--me) 70%, transparent);
  }
  .map-me__pulse { border-color: var(--me); }
  .map-me__dot { background: var(--me); }
  .map-me__halo, .map-me__pulse, .map-me__dot {
    transition: background-color 1200ms ease, border-color 1200ms ease;
  }
}
@media (prefers-reduced-motion: reduce) {
  .map-me__halo, .map-me__pulse, .map-me__dot { transition: none; }
}

/* --- music pins (simulated; see map.js) --- */

.map-pin { width: 60px; height: 60px; cursor: pointer; }

/* --- a note on the map is a mini record (2026-09-16) ---
   Drawn in CSS, not sprite art. The `#pin-*` symbols baked colour, grooves and
   an arc into four exports that had to be kept in step by hand; this is one
   element whose colour comes from `data-status`.

   COLOUR STILL MEANS AGE — the whole disc is tinted, which is what the previous
   pins did too, so the 48h scale reads exactly as before. The label is the same
   hue stepped down, which is what makes it read as a record rather than a
   coin, and it also gives the white glyph a DARKER ground than the old flat
   disc did: every status gains contrast rather than losing it. */
.map-pin__disc {
  position: relative;
  display: block;
  width: 100%;
  height: 100%;
  border-radius: 50%;
  background:
    /* grooves: dark rings with a faint highlight, tight enough to read as
       vinyl at 60px but not so tight they alias into a flat wash */
    repeating-radial-gradient(
      circle at 50% 50%,
      /* Retuned for a BLACK disc: the highlight carries the groove now. On the
         tinted version the dark ring did the work, and at 0.22 on near-black it
         is simply invisible. */
      rgba(255, 255, 255, 0.14) 0px,
      rgba(255, 255, 255, 0.14) 0.5px,
      rgba(0, 0, 0, 0.45) 0.5px,
      rgba(0, 0, 0, 0.45) 1.4px,
      rgba(0, 0, 0, 0) 1.4px,
      rgba(0, 0, 0, 0) 3px
    ),
    /* a single sheen sweep, the same trick the big record uses: concentric
       grooves cannot show light on their own */
    conic-gradient(
      from 210deg at 50% 50%,
      rgba(255, 255, 255, 0) 0deg,
      rgba(255, 255, 255, 0.16) 38deg,
      rgba(255, 255, 255, 0) 88deg,
      rgba(255, 255, 255, 0) 360deg
    ),
    radial-gradient(circle at 50% 50%, var(--pin-disc) 0%, var(--pin-disc) 62%, var(--pin-edge-tint) 100%);
  /* The thin rim. Inset so it traces the disc's own edge rather than adding a
     halo, and light enough to read against a pale basemap without becoming a
     second ring of colour. */
  box-shadow:
    inset 0 0 0 1px rgba(255, 255, 255, 0.32),
    0 2px 6px rgba(0, 0, 0, 0.35);
}

.map-pin__label {
  position: absolute;
  left: 50%;
  top: 50%;
  width: 46%;
  height: 46%;
  transform: translate(-50%, -50%);
  border-radius: 50%;
  display: flex;
  align-items: center;
  justify-content: center;
  background: var(--pin-label);
  /* A dark seat rather than a light one: against a black disc a pale ring would
     read as a second rim. */
  box-shadow: inset 0 0 0 1px rgba(0, 0, 0, 0.35);
}

/* --- BLACK DISC, COLOURED LABEL (2026-09-16, being compared) ---
   The disc is vinyl black for every age and the LABEL carries the colour, which
   is how a real record is built. The first version tinted the whole disc; that
   read as a coloured coin with grooves rather than a record. Both are one line
   per status apart — the tinted set is kept directly below, commented, so the
   two can be swapped back and forth while this is judged.

   The age colours are the measured ones from invariant 17, unchanged, so the
   white glyph sits on exactly the grounds those numbers were taken against. */
.map-pin { --pin-disc: #1f1f1f; --pin-edge-tint: #050505; }
.map-pin[data-status="green"]  { --pin-label: #17A34A; }
.map-pin[data-status="yellow"] { --pin-label: #BE8A04; }
/* #C62842, not the #9C1C31 the tinted disc used. That red was darkened
   specifically so a white glyph would sit on it, which is exactly what makes it
   vanish against a black disc: measured 2.06:1, so an expiring note read as a
   plain black record with a faint centre — on the one state that most needs to
   be read. #C62842 is the balance: 2.97:1 against the disc and still 5.55:1
   under the glyph. Lightening the DISC does not help — red's luminance sits
   between #1f1f1f and #333, so #2a2a2a makes it worse, not better (1.79:1). */
.map-pin[data-status="red"]    { --pin-label: #C62842; }

/* The tinted-disc version, for comparison. Restore by deleting the four rules
   above and uncommenting these three:
.map-pin[data-status="green"]  { --pin-disc: #17A34A; --pin-label: #0C6B2E; --pin-edge-tint: #0E7C38; }
.map-pin[data-status="yellow"] { --pin-disc: #BE8A04; --pin-label: #7C5A02; --pin-edge-tint: #916A03; }
.map-pin[data-status="red"]    { --pin-disc: #9C1C31; --pin-label: #6A1121; --pin-edge-tint: #7E1627; }
*/
/* The pin is an inline <svg><use> now, not an <img>. `color` is the NOTE's ink
   and nothing else — the disc keeps the status colour baked into the art — so
   this is the one knob for theming marker glyphs. Override per status with
   .map-pin[data-status="red"] { color: ... } if you ever want that. */
/* The note, sized against its LABEL. This used to be `.map-pin svg { width:
   100% }` for the old full-bleed sprite; left alone it blew the glyph up to the
   label's full 27.6px with no margin at all. The selector needs both classes —
   `.map-pin svg` is (0,1,1) and outranks a bare `.map-pin__note`. */
.map-pin .map-pin__note { display: block; width: 52%; height: 52%; }

/* --- the countdown ring (2026-09-18) ---
 *
 * A printed detail on the label's edge, not a widget laid over the marker: two
 * segments of one stroked circle, bright for the time a note has left and
 * near-black for the time it has spent. It adds nothing to the 60px footprint —
 * its outer edge sits exactly on the label's rim, covering the 1px dark seat
 * below rather than ringing it.
 *
 * EVERY NUMBER HERE IS REAL PIXELS. map.js gives the svg `viewBox="0 0 60 60"`
 * over a 60px box, so one user unit is one pixel; that is what lets the stroke
 * be written as a plain 2 and still scale correctly with the hover's 1.22.
 *
 * WHY IT IS NOT INSIDE THE DISC: the disc spins on hover (invariant 28) and
 * every child turns with it. Grooves are concentric and a centred glyph is
 * meant to turn, but an arc that starts at 12 o'clock is only readable if 12
 * o'clock stays where it is. So the svg is the disc's SIBLING.
 */
.map-pin__ring {
  position: absolute;
  inset: 0;
  display: block;
  width: 100%;
  height: 100%;
  /* The whole marker is one tap target on .map-pin; this must not intercept
     the click or, worse, the pointerenter that drives the spin. */
  pointer-events: none;
}

/* THE BAND'S WEIGHT IS `RING_W` IN map.js AND IS NOT DECLARED HERE. It was a
   `stroke-width: 3` in this rule until round caps arrived (2026-09-18); three
   separate things are derived from it now — the radius that seats the ring
   flush on the label's rim, and the two cap corrections that keep an arc's
   painted length honest — so a tweak made here would have left all three
   silently wrong rather than visibly wrong. Change it there.
   It is 3px, measured on screen rather than chosen: at one groove (0.9px) and
   at 2px the ring is not there at 60px — rendered at true size, 100% remaining
   and 60% remaining could not be told apart, at any darkness. 4px read better
   still and was rejected for turning the coloured label into a ring around a
   small centre, and that solid colour is the primary age cue. */
.map-pin__ring-track,
.map-pin__ring-fill {
  fill: none;
}

/* ELAPSED. The grooves' own darkest ink, solid rather than translucent. It was
   `rgba(6,6,6,0.66)` first, on the reasoning that letting the label's hue show
   through would help it recede — but at 60px "receding" and "absent" are the
   same thing, and the spent segment is half of what this ring says. Solid, it
   reads as a bite taken out of the label showing the vinyl underneath, which is
   the recessive reading the translucent version was after. */
.map-pin__ring-track { stroke: var(--pin-ring-dim); }

/* REMAINING. `100 100` with a negative offset, never a bare `100` with a
   positive one: both give an arc of the right length, only this starts it at 12
   o'clock. map.js writes the offset and nothing else.
   300ms so a tick is a slide rather than a jump — there is no animation loop
   here, just a transition between two resting values 30s apart. */
/* REMAINING. Both ends are rounded, so the arc has no corners at any length —
   at the 4% floor it is a single rounded dot rather than a sliver with two
   sharp edges. The cap is a half-disc of the stroke's own radius, which makes
   every arc 3.88% longer than it is drawn; map.js shortens the dash by exactly
   that and pushes it forward by one cap, so the painted extent still equals the
   real percentage and still starts on 12 o'clock.
   THE ARC IS THE DASH, so the length lives in `stroke-dasharray` and that is
   what transitions; the offset is a fixed one-cap nudge and never moves. 300ms
   so a tick is a slide rather than a jump — there is no animation loop here,
   just a transition between two resting values 30s apart. */
.map-pin__ring-fill {
  stroke: var(--pin-ring);
  stroke-linecap: round;
  transition: stroke-dasharray 300ms ease;
}

/* THE RING IS INFORMATION, SO REDUCED MOTION TAKES THE SMOOTHING AND NOTHING
   ELSE. It keeps its colours, its geometry and its 30-second updates; only the
   300ms slide between two values goes. Hiding it would remove the very thing
   that stops remaining life being carried by colour alone. */
@media (prefers-reduced-motion: reduce) {
  .map-pin__ring-fill { transition: none; }
}

/* The track is a closed circle and never has an end to cap, so it is left with
   the default. Stated rather than left to chance: give it `round` as well and
   nothing changes, which is exactly how a pointless declaration survives. */

/* The bright end of each status's own hue, never a fourth colour: green 145deg
   -> 142, yellow 43 -> 48, red 350 -> 351. The label's solid fill underneath is
   untouched, so the category signal is exactly what it was.
 *
 * MEASURED, remaining arc against the spent track, which is the one comparison
 * the whole reading depends on:
 *     green   #4ADE80   11.3:1
 *     yellow  #FACC15   11.1:1
 *     red     #FB7185    7.3:1
 * And the spent track against the label it bites into, which is what makes the
 * boundary findable:  green 6.0:1, yellow 6.4:1, red 3.6:1.
 * All three separate on BRIGHTNESS rather than hue, which is what makes the
 * ring readable in greyscale and to a colourblind viewer — WCAG 1.4.1. Red is
 * the tightest of the three and the one to re-measure if the palette moves.
 */
.map-pin { --pin-ring-dim: #0b0b0b; --pin-ring: #4ADE80; }
.map-pin[data-status="green"]  { --pin-ring: #4ADE80; }
.map-pin[data-status="yellow"] { --pin-ring: #FACC15; }
.map-pin[data-status="red"]    { --pin-ring: #FB7185; }
/* PAST NOTES (2026-10-07, invariant 43): a grey centre and no countdown ring,
   since there is no time left to count. #737373 keeps the white glyph at
   4.7:1 and still separates from the #1f1f1f disc at 3.4:1. */
.map-pin[data-status="old"] { --pin-label: #737373; }
.map-pin[data-status="old"] .map-pin__ring { display: none; }
/* And the whole record sits back at 80% (asked for 2026-10-08; first 70%), so live notes
   read first. On the DISC, not .map-pin__inner: the inner's pin-pop entry
   animates opacity and would overwrite it, and the marker element's own
   style is MapLibre's. The disc's hover spin only animates transform. */
.map-pin[data-status="old"] .map-pin__disc { opacity: 0.8; }
/* One white glyph for all three statuses, so the note reads the same whatever
   the disc behind it is doing. It was #0d0d0d, with red alone overridden to
   white after the #9C1C31 recolour dropped that pairing to 2.4:1.

   MEASURED against each disc, white gives:
       red    #9C1C31  8.0:1   comfortable
       yellow #BE8A04  3.1:1   and this is as light as the yellow can go. It
                               was #EAB308 (white at 1.9:1, far too light for a
                               white glyph) and then #A16207, which passed at
                               4.9:1 but read as brown. #BE8A04 is the lightest
                               value that still clears the floor — anything
                               lighter and yellow's glyph has to go back to dark
       green  #17A34A  3.3:1   over the 3:1 WCAG 1.4.11 floor, but the tightest
                               of the three — green is the one to watch if the
                               palette moves again.
   Darkening the DISC is how a failing pair gets fixed here, never lightening
   the glyph: the glyph is the one thing that is the same on all three. */
.map-pin { color: var(--fg); }

/* Pins are added to the DOM as they come into view, so a plain entry animation
   fires exactly once per pin with no JS bookkeeping. transform-origin is the
   bottom tip because these are pins pointing at a spot on the ground — scaling
   from the centre made them slide off their location as they grew.
 
   The animation is on .map-pin__inner, NOT on .map-pin. MapLibre positions the
   marker element itself with an inline transform, and a CSS animation beats
   inline styles: with fill-mode `both` the final keyframe (`scale(1)`, no
   translate) stuck permanently and every note collapsed into the map's
   top-left corner. Anything that animates transform here has to go on the
   inner element. */
@keyframes pin-pop {
  from { opacity: 0; transform: scale(0.4); }
  60%  { opacity: 1; transform: scale(1.08); }
  to   { opacity: 1; transform: scale(1); }
}

.map-pin__inner {
  display: block;
  /* The countdown ring is absolutely positioned against this box. It already
     becomes a containing block whenever a transform is running, but at rest —
     the pop is `backwards`, so it holds nothing — `transform` computes to
     `none` and the ring would escape to the map pane. */
  position: relative;
  width: 100%;
  height: 100%;
  /* CENTRE, not the bottom tip. These used to be teardrops that pointed at a
     spot, so they had to grow from their point or they slid off their location.
     A record is a circle that sits ON the spot, and scaling it from the bottom
     would make it climb. */
  transform-origin: 50% 50%;
  /* `backwards`, NOT `both`. Backwards covers the frame before the animation
     starts so there is no flash of an un-popped note; `both` would also hold
     the final keyframe forever, and animation styles beat ordinary rules — the
     hover transform below would never apply. */
  animation: pin-pop 320ms cubic-bezier(0.34, 1.4, 0.64, 1) backwards;
  transition: transform 160ms cubic-bezier(0.34, 1.4, 0.64, 1), filter 160ms ease;
}

/* Hover and keyboard focus both say "this opens something". The transform goes
   on the inner element for the same reason the animation does — touching the
   marker root's transform would unpin it from the map. */
.map-pin:hover .map-pin__inner,
.map-pin:focus-visible .map-pin__inner {
  transform: scale(1.22);
  filter: drop-shadow(0 6px 12px rgba(0, 0, 0, 0.5));
}

.map-pin:active .map-pin__inner { transform: scale(1.08); }

/* --- the record spins while you hover it (2026-09-17) ---
 *
 * Paced off a recording the user supplied: that reference measured 5.00s a
 * revolution, clockwise, dead linear (14.39 deg per 0.2s, +/- 0.7 over 22
 * frames). This is deliberately slower at 6.5s.
 *
 * IT LIVES ON `.map-pin__disc`, AND IT HAS TO. `.map-pin__inner` already owns
 * transform twice over — the pop animation and the hover `scale(1.22)` — and an
 * animation's transform beats an ordinary rule's, so a spin declared up there
 * would silently delete the hover scale. That is the same collision the
 * `backwards`-not-`both` note above is about. The disc had no transform of its
 * own, which is why it is free to take this one.
 *
 * What makes it READABLE is the conic sheen. The grooves are concentric, so
 * they are invisible under rotation — exactly as on the big record. The sheen
 * sweep and the note glyph are the whole of the effect.
 *
 * The angle is a custom property so the animation can START anywhere. Plain
 * keyframes always begin at 0deg, so re-entering a disc that was still coasting
 * would snap it upright first. `--pin-angle` is written by map.js at the moment
 * the class goes on, and the spin-down reads the angle back out of the matrix.
 */
@keyframes pin-spin {
  from { transform: rotate(var(--pin-angle, 0deg)); }
  to   { transform: rotate(calc(var(--pin-angle, 0deg) + 360deg)); }
}

/* Desktop only, by request. `hover: hover` keeps it off touch, where
   pointerenter fires on the tap that is already opening the card. */
@media (hover: hover) {
  .map-pin__disc.is-spinning { animation: pin-spin 6.5s linear infinite; }
}

/* No spin at all, and map.js checks the same query before it binds anything —
   the coast is a JS-driven transition, so CSS alone could not stop it. */
@media (prefers-reduced-motion: reduce) {
  .map-pin__disc.is-spinning { animation: none; }
}

/* --- floating notes on hover (2026-09-25) ---
 *
 * Two music-note glyphs peel off the disc, drift straight up and fade — the
 * cartoon shorthand for "sound is coming from here", paired with the spin as
 * the same gesture.
 *
 * SIBLINGS OF THE DISC, CHILDREN OF `.map-pin__inner`, for the exact reason
 * the countdown ring already is: the disc spins on hover and everything
 * INSIDE it turns too, which would spiral a note rather than let it rise.
 * Being a child of `.map-pin__inner` instead gives it the hover's 1.22 scale
 * for free without inheriting the rotation.
 *
 * PURE CSS, UNLIKE THE SPIN. The spin needs JS because dropping it mid-turn
 * has to hand off to a coasting transition rather than snap back to 0deg
 * (invariant 28) — there is state to preserve. A note fading out partway
 * through its rise has none, so a plain `:hover`/`:focus-visible` starting
 * and stopping the loop is enough.
 *
 * THE KEYFRAMES REPEAT `translate(-50%, -50%)` AT EVERY STEP, never left on a
 * separate base rule — an animation's `transform` replaces the base rule's
 * rather than composing with it, the same collision invariants 28/30/38 all
 * warn about. `--pin-float-x` is set per note in map.js so the two drift in
 * opposite directions instead of stacking on the way up.
 */
.map-pin__float {
  position: absolute;
  top: 50%;
  left: 50%;
  color: var(--pin-label);
  opacity: 0;
  /* The marker is one tap target; this must never steal the click or the
     pointerenter that drives the spin (the ring's own rule, invariant 17b). */
  pointer-events: none;
}

@media (hover: hover) {
  .map-pin:hover .map-pin__float,
  .map-pin:focus-visible .map-pin__float {
    animation: pin-note-float var(--pin-float-s, 2.2s) ease-out infinite;
    animation-delay: var(--pin-float-delay, 0s);
  }
}

@keyframes pin-note-float {
  0%   { opacity: 0;    transform: translate(-50%, -50%) translate(0, 0) scale(0.55); }
  14%  { opacity: 1; }
  65%  { opacity: 0.8; }
  100% { opacity: 0;    transform: translate(-50%, -50%) translate(var(--pin-float-x, 8px), -30px) scale(1.05); }
}

/* HOVER-ONLY, MATCHING THE SPIN, ON PURPOSE — a phone can never trigger
   either, and that is accepted rather than worked around (invariant 28 makes
   the same call for the spin itself; asked and confirmed again here,
   2026-09-25). */
@media (prefers-reduced-motion: reduce) {
  .map-pin:hover .map-pin__float,
  .map-pin:focus-visible .map-pin__float { animation: none; }
}

.map-pin:focus-visible {
  outline: 2px solid var(--fg);
  outline-offset: 2px;
  border-radius: 50%;
}

@media (prefers-reduced-motion: reduce) {
  .map-pin__inner { transition: filter 160ms ease; }
  .map-pin:hover .map-pin__inner,
  .map-pin:focus-visible .map-pin__inner { transform: none; }
}

@media (prefers-reduced-motion: reduce) {
  .map-view { transition: opacity 1ms linear, visibility 0s; }
  .map-pin__inner { animation: none; }
}

/* The artwork behind the map keeps animating otherwise: a paused-looking page
   under a fade is cheaper and stops the globe fighting the map for GPU. */
@media (max-width: 640px) {
  /* Anchored right, not centred. Centred it collided with the view switcher at
     top-left, which forced it onto two lines and pushed it under the buttons.
     Nav left / chip right splits the header cleanly and leaves it on one line:
     it needs ~190px and there are ~243px going spare. */
  /* Only the type steps down now. The `top`/`left`/`max-width` that used to be
     here were the chip's own positioning; in the bar it has none. */
  /* The right padding moves through the VARIABLE so the time's pressed surface
     follows it. Setting `padding` directly here is what would leave that
     surface reaching 20px over a 16px padding and hanging past the pill. */
  .map-place { font-size: var(--size-label); --place-pad-r: 16px; padding-left: 12px; }
  /* 250px on phones (2026-09-30, the user's call; was 140, desktop is 300). */
  .map-me__halo,
  .map-me__pulse { width: 250px; height: 250px; }
}

/* ---------- Music card (Figma "Open Pin", 117:886) ---------- */

/* Two shapes, one component. Below 861px it is a bottom sheet, which is what
   the Figma draws; above that it becomes a fixed-width panel down the left,
   and the map dims behind it at every width (the desktop exemption this
   comment used to describe was removed 2026-09-16 — invariant 26).
   The scrim is `#121212` at 0.6 (2026-09-24, the user's call); it was
   `rgba(38, 38, 38, 0.4)`, which left the light basemap a mid-grey rather
   than properly receding behind the record and the sleeve. */

.map-scrim {
  position: absolute;
  inset: 0;
  z-index: 4;
  background: rgba(18, 18, 18, 0.6);
  opacity: 0;
  visibility: hidden;
  transition: opacity 300ms ease, visibility 0s linear 300ms;
}

.map-view--card .map-scrim {
  opacity: 1;
  visibility: visible;
  transition: opacity 300ms ease, visibility 0s;
}

.card {
  position: absolute;
  z-index: 5;
  left: 0;
  right: 0;
  bottom: 0;
  max-height: 88%;
  overflow-y: auto;
  -webkit-overflow-scrolling: touch;
  background: #262626;
  border-radius: 24px 24px 0 0;
  box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
  /* Hidden by visibility so the sheet keeps its layout box; the media element
     inside is measured by the YouTube player. */
  visibility: hidden;
  /* The phone sheet comes UP FROM THE BOTTOM on the same spring as the desktop
     record, and on `transform` alone for the same compositor reason. No tilt:
     a bottom sheet that rotates reads as skewed, not hinged. It used to be a
     16px nudge plus a fade, which is a panel appearing rather than an object
     arriving.

     Note the overshoot lifts the sheet ~9.8% of its travel ABOVE its resting
     place at the top of the spring, so the bottom edge briefly leaves the
     screen edge. The sheet's own background covers it because it is anchored
     bottom: 0 and taller than the gap. */
  opacity: 1;
  transform: translateY(100%);
  transition: transform 400ms cubic-bezier(0.4, 0, 1, 1),
              visibility 0s linear 400ms;
}

.card--in {
  visibility: visible;
  transform: translateY(0);
  transition: transform 600ms cubic-bezier(0.34, 1.56, 0.64, 1), visibility 0s;
}

/* THE PANELS TAKE FOCUS WHEN THEY OPEN, AND MUST NOT DRAW A RING FOR IT
   (2026-09-18).
   Both carry `tabindex="-1"` and both are focused programmatically on open, so
   a screen reader announces the panel rather than "Close button". Without this
   rule the browser then paints its OWN focus ring on the panel: measured here
   as `outline-style: auto`, 1px, `rgb(229, 151, 0)` — an ORANGE line down the
   record's right edge and across the top and bottom. That was traded in by
   accident while removing the white ring from the X, and it is worse: bigger,
   brighter and in a colour that appears nowhere else in this app.
   NOTE IT WAS ALSO LATENT ON THE PHONE since 2026-09-17, where the card has
   focused the panel all along; the sheet's `clip-path` trims the outline,
   which is why nobody ever saw it there.

   SUPPRESSING IT COSTS NOTHING ACCESSIBLY, and that is the only reason it is
   allowed. `tabindex="-1"` means neither panel is keyboard-REACHABLE — no Tab
   can ever land here, so there is no keyboard user to strand and WCAG 2.4.7
   has nothing to say about it. The only focus these elements ever receive is
   the programmatic one on open. Every CONTROL inside keeps its own ring,
   including `.card__close:focus-visible` below, which is what a real Tab still
   shows.
   `:focus`, not `:focus-visible`, so it cannot come back through whatever
   heuristic a future engine applies. Neither selector is a pseudo-element, so
   they may share a rule (invariant 15). */
.card:focus,
.drop:focus {
  outline: none;
}

.card__close {
  color: #ffffff;   /* Phosphor ink: was stroke="white" */
  position: absolute;
  /* 20px from the top and the right, which is `.drop__head`'s padding — so the
     two panels put their close button in the same place relative to their own
     corner. It was 12/16 here and 20/20 there, which read as two controls
     rather than one. Moving this DOWN means `.card__media`'s top margin has to
     follow it (48 -> 56) or the button's box lands on the video again; see the
     note there. */
  top: 20px;
  right: 20px;
  z-index: 1;
  display: flex;
  align-items: center;
  justify-content: center;
  /* 32 -> 40 (2026-09-25, WCAG 2.5.5 touch-target audit) — `top`/`right` stay
     put, so the box grows toward the panel's interior; `.card__media`'s
     desktop margin-top follows the same way it did for the 12->20 move
     (56 -> 64, same 4px clearance). Mobile needs nothing: `.card__close` is
     clipped to 1x1 there regardless (it hides in favour of tap-outside). */
  width: 40px;
  height: 40px;
  padding: 0;
  border: none;
  border-radius: 50%;
  /* NO DISC ANY MORE (2026-09-24) — the 0.1/0.2-alpha white fill this
     shared with `.drop__close` (see the note there) read as a pale smudge
     on the record's own dark surface, whatever its alpha. Dropped entirely
     in favour of the SLEEVE close button's own language: a bare icon that
     answers hover with a swell, not a background (invariants 35 and 37 —
     the map buttons and the bar already speak this way; the disc was the
     odd one out). This BREAKS the "change one and change the other"
     pairing with `.drop__close` on purpose, the same way `.sleeve__close`
     already does for the same reason: the drop form's panel is a flat
     surface, not vinyl, and keeps its disc. */
  background: none;
  cursor: pointer;
}

/* `will-change: transform` (2026-09-24): reported directly — the icon
   looked like it briefly thickened mid-swell, then resolved once the
   transition settled. That is consistent with the browser re-rasterizing a
   small vector shape while `transform` is actively animating rather than
   holding a stable layer for it; promoting the icon to its own compositor
   layer up front is the standard fix. Scoped to just these two close-button
   icons rather than added as a blanket rule — invariant 35 elsewhere in
   this file deliberately AVOIDS `will-change` on idle chrome with no
   measured need, and that reasoning still holds for controls that are not
   reported as looking wrong. */
.card__close .icon { transition: transform 280ms cubic-bezier(0.4, 0, 0.2, 1); will-change: transform; }
.card__close:focus-visible { outline: 2px solid var(--fg); outline-offset: 2px; }
@media (hover: hover) {
  .card__close:hover .icon {
    transform: scale(1.2);
    transition-duration: 200ms;
  }
}
@media (prefers-reduced-motion: reduce) {
  .card__close .icon { transition: none; }
  .card__close:hover .icon { transform: none; }
}

/* THE SLEEVE'S OWN CLOSE BUTTON (2026-09-24) — A SEPARATE ELEMENT NOW, NOT
   `.card__close` RESTYLED. It used to be one shared button toggled by
   `.card--sleeve`, and changing its colour AND its position in the same
   instant the class flipped made it visibly snap sideways while the sleeve
   was still sliding in — reported directly. Splitting it into two buttons
   (`.card__close` unconditional, `.sleeve__close` here, living inside
   `.sleeve` in index.html) means neither ever changes its own styling: the
   record's X sits still and gets covered by the advancing sleeve exactly
   like the rest of the record does (DOM order puts `.card__close` before
   `.sleeve`, so their tied `z-index: 1` resolves in the sleeve's favour),
   and the sleeve's X simply travels with the paper because it is part of
   it.
   BARE DARK INK, NO DISC (kept from the original decision) — the white
   disc was built for black vinyl; on kraft it read as a pale blot. This
   also breaks the "change one and change the other" pairing `.card__close`
   has with `.drop__close`, on purpose: the drop form never sits on paper.
   FLAT ON BOTH BREAKPOINTS, ALWAYS — the sleeve carries no dome ever (its
   own invariant, restored the same day it was briefly shared with the
   record's), so unlike `.card__close` this needs no rim/dome-clearance
   variants at all. Hover answers ON THE ICON, the language the map buttons
   and the bar speak (invariants 35 and 37) — a small swell, gated on
   `(hover: hover)` so it cannot stick after a tap. Not a rotation: an X is
   four-fold symmetric, so a quarter turn is invisible and 45deg makes a
   plus (invariant 37). The focus ring is the sleeve's own ink; a white
   ring on kraft is ~1.9:1 against it.
   20px icon, matching every other icon on the sleeve (Phosphor Regular's
   line is 1/16 of the icon's size, so 16/18/20 drew three different
   weights — the user noticed).
   `top: 13px`, NOT 20 (2026-09-28, reported directly: "the X doesn't look
   centre aligned with this content"). It was 20px, dead flush with
   `.sleeve__head`'s own padding-top — fine while the header was a single
   row that filled the whole padded box, but wrong since `.sleeve__head`
   became a column (this file, the Bungee "Comments" title change): the
   title ROW is now only the top 26px slice of a taller header, with the
   (conditionally shown) hint below it, and centering a 40px button on the
   box's edge is not the same as centering it on that row. Measured, not
   guessed: `.sleeve__head-row` computes to y 20-46 (centre 33), the button
   was y 20-60 (centre 40) — 7px low. `top: 13px` puts its centre back on
   33 (13 + 20 half-height). Only the row's own height feeds this number,
   which does not change between breakpoints or with the hint's visibility
   (the hint sits below the row, never inside it), so one flat value covers
   both here — but this is NOT the only place this button's `top` is
   written. The narrow-desktop-window keyboard restore, further down this
   file (`.sleeve__close:focus-visible` inside `@media (max-width: 860px)`),
   is a SEPARATE hardcoded copy, sized 32px instead of 40, and needed its
   own `top: 17px` — missed on the first pass through this fix and caught
   only by grepping every `.sleeve__close` rule in the file afterward, not
   by assuming this was the one place it lived. */
.sleeve__close {
  position: absolute;
  top: 13px;
  right: 20px;
  z-index: 1;
  display: flex;
  align-items: center;
  justify-content: center;
  /* 32 -> 40 (2026-09-25, WCAG touch-target audit) — same move as
     `.card__close`; nothing else on the sleeve's flat header sits close
     enough to this corner to need a matching clearance adjustment. */
  width: 40px;
  height: 40px;
  padding: 0;
  border: none;
  border-radius: 50%;
  background: none;
  color: var(--sleeve-ink);
  cursor: pointer;
}
.sleeve__close .icon { width: 20px; height: 20px; transition: transform 280ms cubic-bezier(0.4, 0, 0.2, 1); will-change: transform; }
.sleeve__close:focus-visible { outline: 2px solid var(--sleeve-ink); outline-offset: 2px; }
@media (hover: hover) {
  .sleeve__close:hover .icon {
    transform: scale(1.2);
    transition-duration: 200ms;
  }
}
@media (prefers-reduced-motion: reduce) {
  .sleeve__close .icon { transition: none; }
  .sleeve__close:hover .icon { transform: none; }
}

/* --- media --- */

.card__media {
  position: relative;
  /* 48, not 40, and the 8 it gained is the only thing holding the close button
     off the video. `.card__close` is absolutely positioned at `top: 12px` and is
     32px tall, so it ends at y=44 — against a 40px margin its 32x32 hit box
     OVERLAPPED the video's top-right corner by 4px, and `elementFromPoint` at
     that corner returned the close button rather than the player. The x glyph
     inside it is 16px and ended at y=36, so all anyone could see was a 4px gap.
     At 48 the glyph cleared by 12 and the box by 4. The close button then moved
     from top 12 to top 20 to match the drop form's header, which pushed its box
     to y=52 — so this went 48 -> 56 to keep exactly those two clearances.
     Move either value and check BOTH: the visible glyph and the hit box. */
  /* 56 -> 64 (2026-09-25): `.card__close` grew 32 -> 40 for the WCAG touch-
     target audit, so its box now ends at y=60 (20 top + 40) instead of 52 —
     64 keeps the same 4px clearance the 56 value always protected. */
  margin: 64px 16px 0;
  border-radius: 16px;
  overflow: hidden;
  /* 358 x 221 in the Figma. As a ratio it survives the panel being a different
     width on desktop. */
  aspect-ratio: 358 / 221;
  background: linear-gradient(148.31deg, rgba(22, 163, 74, 0.2) 0%, rgba(22, 163, 74, 0.6) 100%);
}

.card__thumb,
.card__embed,
.card__embed iframe {
  position: absolute;
  inset: 0;
  width: 100%;
  height: 100%;
  border: 0;
}

.card__thumb { object-fit: cover; }

/* THE PLAYER IS BUILT WHEN THE CARD OPENS (2026-10-01) so a tap can start it
   inside the gesture — see PLAYBACK in card.js. Until it is actually playing
   it stays invisible and untouchable, so the card shows its own thumbnail
   rather than YouTube's chrome. card.js adds `card--video` on PLAYING, or
   after 2.5s if a press was refused, which brings YouTube's own play button
   up as the way out. */
.card__embed { opacity: 0; pointer-events: none; }
.card--video .card__embed { opacity: 1; pointer-events: auto; }

/* --- body --- */

.card__body {
  display: flex;
  flex-direction: column;
  gap: 8px;
  padding: 16px 20px 20px;
}

.card__head {
  display: flex;
  align-items: flex-start;
  justify-content: space-between;
  gap: 12px;
}

.card__titles { min-width: 0; }

.card__title {
  margin: 0;
  font-family: "Bungee", "Inter", sans-serif;
  font-weight: 400;
  font-size: 20px;
  line-height: 26px;
  color: var(--fg);
  /* Bungee has no lowercase, so the Figma's lowercase source string renders as
     caps anyway. Set explicitly so a fallback font does the same thing. */
  text-transform: uppercase;
}

.card__artist {
  margin: 0;
  font-size: 14px;
  line-height: 21px;
  letter-spacing: -0.15px;
  color: rgba(255, 255, 255, 0.6);
}

.card__tools { display: flex; flex: none; }

.card__tool {
  position: relative;   /* anchors `.card__copy-ghost` below */
  display: flex;
  align-items: center;
  justify-content: center;
  width: 40px;
  height: 40px;
  padding: 0;
  border: none;
  border-radius: 50%;
  background: transparent;
  color: #a1a1a1;   /* Phosphor ink: was fill="#A1A1A1" baked into visit + like.
                     `inherit` would take the card's white and brighten them. */
  cursor: pointer;
}

.card__tool:focus-visible { outline: 2px solid var(--fg); outline-offset: 2px; }

/* NO BACKGROUND WASH ON EITHER TOOL ANY MORE (2026-09-25) — the shared
   `rgba(255,255,255,0.08)` circle was the same generic panel invariants 35
   and 37 already retired everywhere else (the map buttons, the bar, both
   close buttons): a ring that says only "this is a button" rather than what
   the button DOES. Replaced with one motion per action, each matching its
   own verb rather than sharing a language.

   VISIT: leans toward the corner and holds. `ph-arrow-square-out`'s own
   arrow already points up-right, so the WHOLE icon nudges that way and
   stays shifted for as long as the pointer is there — "ready to step out"
   — then eases back on leave. Same held-swell idiom and timing as
   `.card__close`/`.sleeve__close` (200ms in, 280ms out), just diagonal
   instead of a scale. */
.card__visit .icon { transition: transform 280ms cubic-bezier(0.4, 0, 0.2, 1); }
@media (hover: hover) {
  .card__visit:hover .icon {
    transform: translate(2px, -2px);
    transition-duration: 200ms;
  }
}
@media (prefers-reduced-motion: reduce) {
  .card__visit .icon { transition: none; }
  .card__visit:hover .icon { transform: none; }
}

/* COPY: the icon peeks out from behind itself and settles back — a literal
   "making a copy" motion, since Phosphor's `ph-copy` glyph is already two
   overlapping pages baked into one flattened path (so the two pages
   themselves cannot be animated apart; a second, purely decorative `<use>`
   of the same symbol stands in for the "back page" instead).
   `.card__copy-ghost` sits exactly on top of the real icon at rest
   (`top/left: 8px` centres a 24px icon in the 40px button, the same maths
   `.card__tool`'s flex-centering already does for its siblings), invisible
   until hovered.
   HELD, NOT ONE-SHOT (revised 2026-09-25) — this was a `@keyframes` peek
   that played once and settled back even while still hovered, matching the
   sleeve's arrow nudge; reported directly as inconsistent with Visit and
   the close buttons, which stay shifted for the whole hover. Switched to
   the same plain `:hover`-driven transition those use (200ms in, 280ms
   out), so the ghost now holds its peeked position for as long as the
   pointer is there and only eases back on leave — one language across all
   three tools' hover feedback, not two. */
.card__copy-ghost {
  position: absolute;
  top: 8px;
  left: 8px;
  opacity: 0;
  transform: translate(0, 0);
  transition: opacity 280ms cubic-bezier(0.4, 0, 0.2, 1), transform 280ms cubic-bezier(0.4, 0, 0.2, 1);
  pointer-events: none;
}
@media (hover: hover) {
  /* Not while `.is-copied` — the real icon is a checkmark then, and a
     duplicate of the copy glyph peeking out behind it would read as a
     leftover rather than a confirmation. */
  .card__copy:not(.is-copied):hover .card__copy-ghost {
    opacity: 0.6;
    transform: translate(4px, -4px);
    transition-duration: 200ms;
  }
}
@media (prefers-reduced-motion: reduce) {
  .card__copy-ghost { transition: none; }
  .card__copy:hover .card__copy-ghost { opacity: 0; transform: none; }
}

/* Copy link. The two glyphs are stacked on one class rather than swapped in the
   DOM, so there is no frame where neither is drawn and nothing to re-measure.
   Same 40px box as Visit — they are a pair and must not be two sizes. */
.card__copied-icon { display: none; }
.card__copy.is-copied .card__copy-icon { display: none; }
.card__copy.is-copied .card__copied-icon { display: block; }

/* Green only while it is confirming, then back to the pair's resting grey. It
   is the one moment in the card that reports success, so it gets to be loud. */
.card__copy.is-copied { color: #4ade80; }

/* ---------- reporting a note (2026-09-29, BACKEND-PLAN.md Phase 5) ----------
 * `.card__report-wrap` exists purely so the popover has something to anchor
 * to — `.card__report` itself is already `position: relative` (it inherits
 * `.card__tool`'s rule), but the menu is that button's SIBLING, not its
 * child, so the containing block has to sit one level up. */
.card__report-wrap { position: relative; display: flex; }

/* Same held-swell idiom as Visit/Copy above — one motion per verb, this one
   a plain scale since "flag" has no natural direction to lean in. */
.card__report .icon { transition: transform 200ms cubic-bezier(0.4, 0, 0.2, 1); }
@media (hover: hover) {
  .card__report:not(.is-reported):hover .icon { transform: scale(1.15); }
}
@media (prefers-reduced-motion: reduce) {
  .card__report .icon { transition: none; }
  .card__report:hover .icon { transform: none; }
}

/* Reported. Same stacked-glyph device as Copy's checkmark swap above — one
   class, two icons, never a frame with neither drawn. */
.card__reported-icon { display: none; }
.card__report.is-reported .card__report-icon { display: none; }
.card__report.is-reported .card__reported-icon { display: block; }
.card__report.is-reported { color: #4ade80; cursor: default; }

/* ---------- the report-reason popover, shared by a note and a comment ----------
 * Visually identical to `.clock-menu` (map.js's time-format dropdown) —
 * same surface, same row treatment — reused rather than invented twice.
 * `.report-menu__item` differs from `.clock-menu__item` only in having no
 * tick column or live-preview text: a reason is an ACTION (picking one
 * reports immediately), not a persisted radio choice. */
.report-menu {
  z-index: 3;
  display: flex;
  flex-direction: column;
  gap: 4px;
  min-width: 220px;
  padding: 8px;
  border: 1px solid rgba(255, 255, 255, 0.1);
  border-radius: 16px;
  background: #262626;
  box-shadow: 0 16px 32px -8px rgba(0, 0, 0, 0.7);
  text-align: left;
  animation: clock-menu-in 140ms cubic-bezier(0.4, 0, 0.2, 1);
}

/* The note's own instance is a fixed popover off a fixed button — CSS alone
   anchors it, the same way `.clock-menu` anchors off the clock. The
   sticker's instance (`.report-menu--sticker`) is positioned in JS instead
   (card.js), because a sticker can be anywhere on the board; see its own
   comment there for why. */
.card__report-wrap .report-menu {
  position: absolute;
  top: calc(100% + 12px);
  right: 0;
  transform-origin: top right;
}
.report-menu--sticker {
  position: absolute;
  /* Has to clear TWO things it can sit near in `.sleeve`'s own stacking
     context: `.sleeve__close` (z-index 1) and, more importantly, the very
     sticker it belongs to — the report button only ever shows on an OPEN
     sticker (`.sticker.is-open.can-report .sticker__report`), and
     `.sticker.is-open` is z-index 4. At 2 the menu painted BEHIND that
     sticker whenever the two overlapped, which they usually do since the
     menu opens from a button on the sticker's own corner — reported
     directly, with a screenshot showing the menu's text sliced off behind
     the circle. 5 clears the open sticker (4) and the dragging one (3). */
  z-index: 5;
  transform-origin: top left;
}

.report-menu__item {
  width: 100%;
  padding: 8px 12px;
  border: 0;
  border-radius: 10px;
  background: none;
  color: var(--fg);
  font: inherit;
  /* 14px, the app's UI-text size (was --size-label, 18px — that token is for
     the landing page's labels and read oversized in a small menu). */
  font-size: 14px;
  font-weight: 600;
  line-height: 20px;
  text-align: left;
  cursor: pointer;
  transition: background-color 150ms ease;
}
/* Hover was #2d2d2d on the menu's #262626 — a 7-level step, near invisible.
   #3a3a3a is clearly a lit row while the text stays well above 4.5:1. */
.report-menu__item:hover { background: #3a3a3a; }
.report-menu__item:focus-visible {
  background: #3a3a3a;
  outline: 2px solid var(--fg);
  outline-offset: -2px;
}

@media (max-width: 640px) {
  .report-menu__item { padding: 12px; font-size: 14px; }
}

@media (prefers-reduced-motion: reduce) {
  .report-menu { animation: none; }
  .report-menu__item { transition: none; }
}

/* The sticker's own flag icon — opposite corner from `.sticker__delete`,
   same 24px badge, same open-only gating (a report target sitting live on
   a 60px collapsed sticker would be too easy to hit by mistake while
   dragging, same reasoning as delete). Never shown on your own sticker —
   see `.can-report`, set in card.js only when `s.ownerId !== mine`. */
.sticker__report {
  display: none;
  position: absolute;
  top: -6px;
  left: -6px;
  width: 24px;
  height: 24px;
  border: none;
  border-radius: 50%;
  background: #1a1a1a;
  color: #fafafa;
  align-items: center;
  justify-content: center;
  cursor: pointer;
  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.4);
}
.sticker.is-open.can-report .sticker__report { display: flex; }
.sticker__report:focus-visible { outline: 2px solid var(--fg); outline-offset: 2px; }

/* Reported. No second icon to swap here (unlike the note's own check-swap
   above) — a colour change alone is enough on a badge this small. */
.sticker__report.is-reported { background: #14532d; color: #4ade80; cursor: default; }

/* The heart is a flat SVG, so "liked" is expressed by tinting the whole glyph
   rather than by swapping in a filled variant. aria-pressed carries the state
   for anyone not seeing the colour. */
/* Was a brightness/sepia/hue-rotate filter chain re-tinting a fixed-colour
   asset. With currentColor it is one declaration, and the liked state swaps to
   the filled heart rather than recolouring the outline. */

/* --- genres --- */

.card__genres {
  display: flex;
  flex-wrap: wrap;
  gap: 8px;
  margin: 0;
  padding: 0;
  list-style: none;
}

.card__genre {
  padding: 4px 8px;
  border-radius: 50px;
  background: #9a2713;
  font-size: 12px;
  font-weight: 700;
  line-height: 18px;
  letter-spacing: 0.6px;
  text-transform: uppercase;
  color: var(--fg);
}

/* --- who dropped it --- */

.card__poster {
  display: flex;
  align-items: center;
  gap: 8px;
  margin: 4px 0 0;
  font-size: 12px;
  line-height: 18px;
  color: rgba(255, 255, 255, 0.5);
}

.card__avatar {
  display: flex;
  align-items: center;
  justify-content: center;
  flex: none;
  width: 28px;
  height: 28px;
  border-radius: 50%;
  overflow: hidden;
  background: rgba(138, 43, 232, 0.3);
}

/* Set only when the note carries a real dropper's chosen avatar id
   (card.js's setAvatar()) — the generic icon on a purple wash is what a
   simulated note keeps, since it was never anyone's real choice. `--swatch`
   is read from that same id's `.drop__avatar` button, never duplicated here,
   and now sits behind the same Procreate art `.drop__avatar-face` shows. */
.card__avatar--picked {
  background: var(--swatch);
}
.card__avatar--picked .card__avatar-fallback {
  display: none;
}
.card__avatar-art {
  display: none;
  width: 78%;
  height: 78%;
  object-fit: contain;
}
.card__avatar--picked .card__avatar-art {
  display: block;
}

/* --- transport --- */

.card__transport {
  display: flex;
  align-items: center;
  gap: 8px;
  padding: 16px 0 0;
}

.card__play {
  display: flex;
  align-items: center;
  justify-content: center;
  flex: none;
  width: 48px;
  height: 48px;
  padding: 0;
  border: none;
  border-radius: 50%;
  background: #f1472f;
  /* The glyphs are `fill="currentColor"` Phosphor symbols and this element set
     no colour, so they inherited their way to black. White measures 3.7:1 on
     #f1472f — over the 3:1 WCAG 1.4.11 floor, though black was in fact the
     higher-contrast choice at 5.3:1. White is the deliberate call. */
  color: var(--fg);
  cursor: pointer;
  transition: transform 200ms cubic-bezier(0.4, 0, 0.2, 1);
}

/* `card--playing` was already toggled by card.js in five places and styled
   nowhere — this is what it was waiting for. The two glyphs swap on the class;
   the accessible name is swapped in JS alongside it, by the same function, so
   the icon and the label cannot end up disagreeing. */
.card__pause-icon { display: none; }
.card--playing .card__play-icon { display: none; }
.card--playing .card__pause-icon { display: block; }

.card__play:hover { transform: scale(1.06); }
.card__play:focus-visible { outline: 2px solid var(--fg); outline-offset: 4px; }
/* Only once play has been PRESSED: the player now loads on every card open
   (card.js, PLAYBACK), and a dimmed button on open would read as disabled. */
.card--loading.card--spinning .card__play { opacity: 0.6; }

/* The failure state finally has a face. `.card--error` was being toggled in two
   places in card.js and matched by no rule at all, so a blocked YouTube was
   indistinguishable from a dead button. Amber, like the form's warnings: it is
   not our error and there is a way out of it, which the Visit link already
   provides. */
.card__playerror {
  display: none;
  margin: 12px 0 0;
  font-size: 13px;
  line-height: 18px;
  color: var(--cta);
}

.card--error .card__playerror { display: block; }

/* A transport that cannot transport anything should not look ready. */
.card--error .card__play { opacity: 0.5; cursor: not-allowed; }

/* The two bar rows sit exactly on top of each other; the coloured one is
   clipped to the played fraction. clip-path rather than width, because the
   inner row has to keep its full width or the bars would squeeze together as
   the track plays instead of filling left to right. */
.card__wave {
  position: relative;
  flex: 1 1 auto;
  min-width: 0;
  height: 36px;
  cursor: pointer;
  touch-action: none;   /* we own the drag; do not let the page scroll instead */
}

.card__wave-row {
  display: flex;
  align-items: center;
  gap: 2px;
  height: 100%;
}

.card__wave-fill {
  position: absolute;
  inset: 0;
  clip-path: inset(0 calc(100% - var(--p, 0) * 100%) 0 0);
}

.card__bar {
  flex: 1 1 0;
  min-width: 0;
  border-radius: 50px;
  background: rgba(255, 255, 255, 0.13);
}

.card__wave-fill .card__bar { background: #f1472f; }

.card__wave:focus-visible { outline: 2px solid var(--fg); outline-offset: 4px; border-radius: 4px; }

@media (prefers-reduced-motion: reduce) {
  .card { transition: opacity 1ms linear, visibility 0s; transform: none; }
  .card__play { transition: none; }
  .card__play:hover { transform: none; }
}

/* ---------- Desktop: the card becomes a left panel ---------- */

@media (min-width: 861px) {
  .card {
    top: 0;
    right: auto;
    width: var(--panel-w);
    max-height: none;
    height: 100%;
    border-radius: 0;
    box-shadow: 0 0 40px rgba(0, 0, 0, 0.5);
    transform: translateX(-16px);
  }

  .card--in { transform: none; }

  /* THE VIDEO'S RIGHT EDGE NOW MATCHES THE REST OF THE CARD ON DESKTOP
     (2026-09-28), asked for directly. `.card__media` and `.card__body` are
     the only two things in this panel that set their own side inset
     (invariant 34's mobile fix already made this pairing explicit for
     mobile) — `.card__body`'s desktop padding is 20px each side, but
     `.card__media`'s base rule margin was still 16px, a leftover from before
     that pairing was ever audited. Mobile is untouched: both the ≤640px and
     641-860px breakpoints already set their OWN explicit margin/padding pair
     that agrees (16px/16px), so this desktop-only override cannot reach
     them. */
  .card__media { margin-left: 20px; margin-right: 20px; }

  /* REVERSED 2026-09-16. This used to read "the map stays usable beside the
     panel, so nothing dims it" and switched the scrim off at this breakpoint.
     The record is now the focus and the map behind it is dimmed, the same way
     the phone layout has always done it — so the rule is simply gone and the
     base `.map-view--card .map-scrim` applies here too.

     Two consequences, both deliberate. The map is no longer pannable while a
     panel is open: the scrim is a real element over it, not a tint. And a click
     on the dimmed map closes the CARD (card.js wires the scrim to its close),
     while the drop form stays put — dismissing a half-typed form by clicking
     outside it would throw the input away. */

  /* Clear the panel so the switcher stays reachable. The chip is anchored to
     the right edge now, so it was never over the panel and must NOT be pushed
     another 400px — that walks it off the screen.

     Briefly gated on `(max-height: 700px)` while the record was a vertically
     centred 500px lens that never reached the header. The panel is full height
     again, so it covers the nav at every viewport and the shift is
     unconditional once more. If the panel ever stops being full height, gate it
     again: the threshold is where the panel's top clears the nav's 80px bottom
     plus a 16px gap. */
  .map-nav { transition: transform 300ms cubic-bezier(0.4, 0, 0.2, 1); }

  /* Clear the panel, and stay centred in what is left of the map.
     HALF the panel width, not the whole of it. The bar is centred on the
     viewport now, so the space it has to live in runs from the panel's right
     edge to the window's right edge — whose midpoint sits at
     `50% + var(--panel-w) / 2`. Shifting by the full width would clear the
     panel and then overshoot by another half, crowding the bar against the
     right edge. This is still expressed in terms of `--panel-w` (invariant
     15a): change the variable, not the sum. */
  .map-view--card .map-nav { transform: translateX(calc(var(--panel-w) / 2)); }

  /* Sliding by the panel width does not shorten the bar, so its max-width has
     to pay for the panel too or a long place name runs off the right edge.
     The place segment is the one that gives way (min-width: 0 on it). */
  .map-view--card .map-nav,
  .map-view--drop .map-nav { max-width: calc(100% - var(--panel-w) - 48px); }

  /* The panel leaves only 341px of map at this breakpoint, and 324px of
     controls plus a chip does not fit in it. While a panel is open the field
     steps back to its icon — the same collapse the phone layout uses, for the
     same reason. */
  .map-view--card .map-search__input,
  .map-view--drop .map-search__input { width: 0; padding: 0; opacity: 0; pointer-events: none; }

  /* ...and the pill becomes Discover's twin while it is closed: same 60px box,
     icon centred. See the note by the phone-layout collapse. */
  .map-view--card .map-search,
  .map-view--drop .map-search { padding-right: 0; }
  .map-view--card .map-search__toggle,
  .map-view--drop .map-search__toggle {
    width: 60px;
    padding-right: 0;
    justify-content: center;
  }

}

/* THE CHIP'S POSITIONING ARITHMETIC LIVED HERE AND IS GONE (2026-09-17).
 *
 * Two blocks used to sit at this point: a centred rule from 1025px, and a
 * panel-aware centred rule from 1177px, each with its own hand-derived reserve
 * (`100% - 704px` and `100% - (var(--panel-w) + 336px)`). They existed because
 * the chip was absolutely positioned and therefore could not see the controls
 * it had to avoid — so its clearance had to be restated as arithmetic, by
 * hand, at every breakpoint, and re-derived whenever `--panel-w` changed. That
 * is what invariant 15 and 15a were about, and what bit three times: the
 * collapsed pill going 48 -> 60px, the panel going 400 -> 520px, and the
 * 1025-1177 dead band where `Mohol, India` rendered as `M...`.
 *
 * The chip is now a flex child of the bar. A flex child cannot collide with
 * its siblings, so none of it is needed — deleted rather than retuned. If the
 * bar ever needs to be centred in the view again, centre THE BAR, and let the
 * segments stay in flow inside it.
 */
/* The label used to be hidden here: two labelled buttons plus the place chip
   did not fit across 375px. With Home gone there is one button, and it fits —
   measured at 375px, the nav ends at x=76 while the chip is held at
   `max-width: calc(100% - 140px)` with `right: 16px`, so its left edge cannot
   come in past x=124 however long the place name is. 48px of clearance in the
   worst case.

   It is kept visible rather than reclaimed as space on purpose: a lone globe
   icon reads as "go to the globe", which is what this button used to do and is
   now exactly what it does not. The word is the only thing saying otherwise. */
@media (max-width: 640px) {
  /* Hugs its content here too, just with a tighter top inset and a tighter
     max-width — the centring is inherited from the base rule and needs no
     restating. It does not stretch to
     the row: a stretched bar has to give the leftover width to some segment,
     and every candidate is wrong — a wider Discover, a field nobody has opened,
     or a place segment padded out with empty space. The max-width is what
     stops it overflowing instead. */
  .map-nav { top: 16px; max-width: calc(100% - 32px); }
  /* Side margin 16px, not 12 (2026-09-28) — see the shared note beside the
     `@media (max-width: 860px)` block further down, where the matching
     841-860px fix lives; both are explained together there. Top is 56 here
     but effectively 40 once the wider mobile block below overrides it —
     unchanged by this edit, which only touches the sides. */
  .card__media { margin: 56px 16px 0; }
  .card__body { padding: 16px; }
}

/* ---------- Drop form (Figma 211:2 empty / 211:127 ready) ---------- */

/* Shares the card's surface exactly — bottom sheet on mobile, 400px left panel
   from 861px up — so the two are styled from one set of rules and only one can
   be open at a time. */
.drop {
  position: absolute;
  z-index: 6;
  left: 0;
  right: 0;
  bottom: 0;
  max-height: 88%;
  overflow-y: auto;
  -webkit-overflow-scrolling: touch;
  background: var(--bg);
  border-radius: 24px 24px 0 0;
  box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
  visibility: hidden;
  /* The phone sheet comes UP FROM THE BOTTOM on the same spring as the desktop
     record, and on `transform` alone for the same compositor reason. No tilt:
     a bottom sheet that rotates reads as skewed, not hinged. It used to be a
     16px nudge plus a fade, which is a panel appearing rather than an object
     arriving.

     Note the overshoot lifts the sheet ~9.8% of its travel ABOVE its resting
     place at the top of the spring, so the bottom edge briefly leaves the
     screen edge. The sheet's own background covers it because it is anchored
     bottom: 0 and taller than the gap. */
  opacity: 1;
  transform: translateY(100%);
  transition: transform 400ms cubic-bezier(0.4, 0, 1, 1),
              visibility 0s linear 400ms;
}

.drop--in {
  visibility: visible;
  transform: translateY(0);
  transition: transform 600ms cubic-bezier(0.34, 1.56, 0.64, 1), visibility 0s;
}

.map-view--drop .map-scrim { opacity: 1; visibility: visible; transition: opacity 300ms ease, visibility 0s; }

/* Sticky, because .drop is itself the scroll container (overflow-y: auto) and
   the header is its direct child — so the title and the way out stay put while
   the form scrolls under them. It needs its own OPAQUE background: without one
   the fields would show through as they pass beneath. The existing bottom
   border doubles as the scrolled-under edge. */
.drop__head {
  /* Was `position: sticky` inside `.drop__scroll`. It is a direct child of the
     flex-column panel now, ABOVE the scroller, so it holds the top without
     needing to stick to anything — and the content can no longer reach its
     pixels at all, which is the whole point (see the note in index.html).
     `flex: none` so it keeps its height when the form is long. */
  flex: none;
  z-index: 1;
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: 12px;
  padding: 20px;
  background: var(--bg);
  border-bottom: 1px solid rgba(255, 255, 255, 0.1);
}

.drop__title {
  margin: 0;
  font-family: "Bungee", "Inter", sans-serif;
  font-weight: 400;
  font-size: 24px;
  line-height: 30px;
  color: var(--fg);
  text-transform: uppercase;
}

/* NO DISC (2026-09-25), same move as `.card__close` — reported directly on
   this exact button. The comment this replaced claimed "the drop form's
   panel is a flat surface, not vinyl" as the reason to keep the disc, and
   that was WRONG: the drop form has its own `.vinyl` record behind it,
   same as the card (invariant 26 in CLAUDE.md — `.drop__close` has always
   needed the rim-inset clearance a flat surface would never require). It
   was the SLEEVE, not the drop form, that is flat paper and diverges from
   this. Since both panels ARE vinyl, both close buttons now speak the same
   language: bare icon, swell on hover, no background. */
.drop__close {
  color: #ffffff;   /* Phosphor ink: was stroke="white" */
  display: flex;
  align-items: center;
  justify-content: center;
  flex: none;
  /* 32 -> 40 (2026-09-25, WCAG touch-target audit). It is a flex CHILD of
     `.drop__head`, not absolutely positioned, so this costs nothing beyond
     its own box — no clearance math elsewhere depends on its size. */
  width: 40px;
  height: 40px;
  padding: 0;
  border: none;
  border-radius: 50%;
  background: none;
  cursor: pointer;
}

.drop__close .icon { transition: transform 280ms cubic-bezier(0.4, 0, 0.2, 1); will-change: transform; }
.drop__close:focus-visible { outline: 2px solid var(--fg); outline-offset: 2px; }
@media (hover: hover) {
  .drop__close:hover .icon {
    transform: scale(1.2);
    transition-duration: 200ms;
  }
}
@media (prefers-reduced-motion: reduce) {
  .drop__close .icon { transition: none; }
  .drop__close:hover .icon { transform: none; }
}

.drop__body {
  display: flex;
  flex-direction: column;
  gap: 24px;
  padding: 20px;
}

/* --- the one-time username step (2026-09-25) --- */

/* Same shell as `.drop__body` — it takes that element's place in
   `.drop__scroll` while the form itself is `hidden`, so it needs the exact
   same padding and gap or the panel visibly resizes when the two swap.
   `min-height: 100%` (2026-09-25) is what lets "Continue" anchor to the
   bottom below — this step is one short field, so left to its own content
   height it stopped a little past two-thirds down the panel with a stretch
   of empty space under it. Percentage heights on a flex item's child are
   normally unreliable, but `.drop__scroll` gets a DEFINITE height from
   being a flex item itself (`flex: 1 1 auto` in `.drop`'s column), which is
   what makes the percentage here resolve rather than collapse. */
.drop__username {
  display: flex;
  flex-direction: column;
  min-height: 100%;
  gap: 24px;
  padding: 20px;
}


.drop__username-help {
  margin: 0;
  font-size: 15px;
  line-height: 22px;
  color: rgba(255, 255, 255, 0.6);
}

/* Error only — this step has no neutral hint state, unlike `.drop__status`,
   so it is always the warning colour rather than switching to it. Shared by
   both halves of this step (username AND avatar) rather than each getting
   its own status line — only one thing can block "Continue" at a time, so
   one paragraph is enough; see drop.js's commitUsername. */
/* "That name is taken" (2026-09-30): the field shakes once, ~6px each way,
   decaying. Transform only, on the input's wrapper. Skipped entirely under
   reduced motion — the message and aria-invalid still say it. */
.drop__input.is-shaking { animation: username-shake 380ms cubic-bezier(0.36, 0.07, 0.19, 0.97); }
@keyframes username-shake {
  10%, 90% { transform: translateX(-2px); }
  20%, 80% { transform: translateX(4px); }
  30%, 50%, 70% { transform: translateX(-6px); }
  40%, 60% { transform: translateX(6px); }
}
@media (prefers-reduced-motion: reduce) {
  .drop__input.is-shaking { animation: none; }
}
.drop__username-status { margin: 0; font-size: 12px; color: var(--cta); }
.drop__username-status:not(:empty) { margin-top: 8px; }
/* 14px on a phone (2026-09-30, asked for) — 12px was small to read there. */
@media (max-width: 860px) {
  .drop__username-status { font-size: 14px; line-height: 20px; }
}

/* --- avatar picker, real Procreate art (2026-09-28) ---
   `margin-top: 8px` on the row matches `.drop__label`'s own gap to whatever
   it labels everywhere else in this form. */
.drop__avatars {
  display: flex;
  gap: 12px;
  margin-top: 8px;
}

.drop__avatar {
  position: relative;   /* anchors the invisible hit-area ::after below */
  display: flex;
  align-items: center;
  justify-content: center;
  width: 50px;
  height: 50px;
  flex: none;
  padding: 0;
  border: none;
  border-radius: 50%;
  background: var(--swatch);
  cursor: pointer;
}

/* Same trick as `.sleeve__color-btn::after` — a bigger invisible hit target
   without a bigger visible circle. 50px + 2*8px = 66px, comfortably past the
   44px minimum (invariant 10/34). A separate inner wrapper (rather than
   `overflow: hidden` on `.drop__avatar` itself) is what clips the art to the
   circle without also clipping this pseudo-element's -8px reach. */
.drop__avatar::after {
  content: "";
  position: absolute;
  inset: -8px;
}

.drop__avatar-face {
  width: 100%;
  height: 100%;
  border-radius: 50%;
  overflow: hidden;
  display: flex;
  align-items: center;
  justify-content: center;
}

.drop__avatar-face img {
  width: 78%;
  height: 78%;
  object-fit: contain;
  pointer-events: none;
}

.drop__avatar[aria-pressed="true"] {
  box-shadow: 0 0 0 2px var(--bg), 0 0 0 4px var(--fg);
}

.drop__avatar:focus-visible { outline: 2px solid var(--fg); outline-offset: 4px; }

/* Desktop only (2026-09-28, asked for directly) — 60px against the 50px
   base/mobile size (also raised the same session, from an original 40px).
   `.drop__avatar-face` and its `img` are both percentage-sized off
   `.drop__avatar` itself, so they scale up for free; nothing here needs
   restating for them. */
@media (min-width: 861px) {
  .drop__avatar { width: 60px; height: 60px; }
}

/* A little bounce on hover (2026-09-28, asked for directly: "the same one
   the globe uses") — reuses `map-discover-hop` verbatim, the exact keyframes
   the Discover control's globe icon hops with, rather than a second
   near-identical animation. Applied to the WHOLE button rather than split
   across a wrapper/icon pair the way the globe is: nothing else here ever
   sets a transform on `.drop__avatar` for this to collide with, so the
   two-element trick invariant 28/35 need for the globe isn't needed here.
   Gated on `(hover: hover)` alone, matching every other hover
   micro-interaction in this file — touch has no hover to stick. */
@media (hover: hover) {
  .drop__avatar:hover {
    animation: map-discover-hop 460ms linear;
  }
}

@media (prefers-reduced-motion: reduce) {
  .drop__avatar:hover {
    animation: none;
  }
}

/* --- "Posting as", at the top of the real form (2026-09-25) --- */

.drop__poster {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: 12px;
}

.drop__poster-text { font-size: 14px; color: rgba(255, 255, 255, 0.5); }
.drop__poster-name { color: var(--fg); font-weight: 600; }

.drop__poster-edit {
  /* Padding 8 -> 12, margin follows (2026-09-25, WCAG touch-target audit):
     ~31.5px tall -> ~40px. Same invisible-hit-area trick as
     `.sleeve__back` — the negative margin matches the padding exactly, so
     the VISIBLE "Edit" text stays exactly where it was in the row; only
     the tappable area around it grows. */
  margin: -12px -12px;
  padding: 12px 12px;
  border: none;
  border-radius: 8px;
  background: none;
  color: rgba(255, 255, 255, 0.6);
  font: inherit;
  font-size: 13px;
  font-weight: 600;
  cursor: pointer;
}
@media (hover: hover) {
  .drop__poster-edit:hover { color: var(--fg); }
}
.drop__poster-edit:focus-visible { outline: 2px solid var(--fg); outline-offset: 2px; }

/* --- where it lands --- */

.drop__at {
  display: flex;
  align-items: center;
  gap: 12px;
  padding: 16px;
  border-radius: 16px;
  background: #262626;
}

.drop__at-icon {
  color: #bd7aff;   /* Phosphor ink: was stroke="#BD7AFF" */
  display: flex;
  align-items: center;
  justify-content: center;
  flex: none;
  width: 40px;
  height: 40px;
  border-radius: 50%;
  background: rgba(138, 43, 232, 0.3);
}

.drop__at-text { display: flex; flex-direction: column; gap: 4px; min-width: 0; }
/* 0.4 measured 3.67:1 on the #262626 at-block — under WCAG 1.4.3 AA. 0.5 is 4.89:1. */
.drop__at-label { font-size: 14px; color: rgba(255, 255, 255, 0.5); }
.drop__at-place { font-size: 16px; font-weight: 500; color: var(--fg); }

/* Amber rather than red: the drop is still allowed, it just may not land where
   you think. `--cta` is the same amber the form's own warnings use, and it
   measures 13.9:1 on this panel. */
.drop__at-accuracy {
  font-size: 13px;
  line-height: 18px;
  color: var(--cta);
}

/* --- fields --- */

.drop__field { display: flex; flex-direction: column; }

.drop__label {
  font-size: 14px;
  font-weight: 500;
  color: rgba(255, 255, 255, 0.5);
}

/* 0.3 measured 2.63:1 on the panel's #0d0d0d — well under AA. 0.5 is 5.34:1. */
.drop__help { margin: 8px 0 0; font-size: 16px; color: rgba(255, 255, 255, 0.5); }
/* 8px, not the old 4px: the 4 was the gap under the help line that used to sit
   above this. With that line gone the fineprint follows the label directly, and
   every other field puts 8px between its label and its content. */
.drop__fineprint { margin: 8px 0 0; font-size: 12px; color: rgba(255, 255, 255, 0.5); }

.drop__input {
  display: flex;
  align-items: center;
  gap: 12px;
  margin-top: 8px;
  padding: 0 16px;
  height: 48px;
  border-radius: 16px;
  background: #262626;
}

.drop__input input {
  flex: 1 1 auto;
  min-width: 0;
  border: 0;
  background: transparent;
  color: var(--fg);
  font: inherit;
  font-size: 16px;   /* below 16px iOS zooms the page on focus */
}

/* 0.25 measured 2.27:1 on the #262626 field — placeholder text is text, and it
   owes the same 4.5:1 as anything else. 0.5 is 4.89:1. */
.drop__input input::placeholder { color: rgba(255, 255, 255, 0.5); }

/* A rejected link. Inset, so it composes with the :focus-within outline rather
   than fighting it — the two are visible at once. Never colour alone: the
   status line below says it in words and the input carries aria-invalid. */
.drop__input--error { box-shadow: inset 0 0 0 2px var(--cta); }
.drop__input input:focus { outline: none; }
/* The ring goes on the container, since that is the visible control. */
.drop__input:focus-within { outline: 2px solid var(--fg); outline-offset: 2px; }

/* No reserved box when there is nothing to say, so every field sits exactly one
   .drop__body gap from the next — the YouTube field used to run 26px looser
   than the rest (8px margin + 18px held-empty min-height) purely to stop the
   form shifting when a message appeared. The gap is the ask; the trade is that
   the fields below now move down when a message does appear. It stays in the
   DOM rather than being display:none'd, so the aria-live region keeps
   announcing. */
.drop__status { margin: 0; font-size: 12px; color: rgba(255, 255, 255, 0.5); }
.drop__status:not(:empty) { margin-top: 8px; }
.drop__status--error { color: var(--cta); }

/* The 5-note cap notice (2026-09-28) — a banner, not a status line, because
   it has to survive the URL field's own `.drop__status` traffic rather than
   being the next thing to overwrite it. Same amber the rest of this form
   already uses for a warning (`.drop__status--error`, `.drop__username-status`),
   just given its own boxed weight since it has to stay put rather than flash
   past. */
.drop__limit {
  margin: 0 0 20px;
  padding: 12px 14px;
  border-radius: 12px;
  background: rgba(var(--cta-rgb), 0.12);
  border: 1px solid rgba(var(--cta-rgb), 0.35);
  color: var(--cta);
  font-size: 13px;
  line-height: 18px;
}

/* --- genres --- */

.drop__genres {
  display: flex;
  flex-wrap: wrap;
  align-items: center;
  gap: 8px;
  margin-top: 8px;
}

/* Vertical padding 8 -> 11 (2026-09-25, WCAG touch-target audit): ~30.5px
   tall -> ~36px. Stopped short of the fuller 40/44px this session's other
   controls moved to — this is a dense wrapped grid of 20 base genres plus
   whatever custom ones get added, and pushing every chip past ~36px starts
   costing real vertical space across the whole list rather than being
   free. 36px still clears WCAG's enforceable 24px minimum by a wide margin;
   it is the "recommended" 44px tier that stays traded off here, on
   purpose, for chip density. */
.drop__genre {
  padding: 11px 12px;
  border: none;
  border-radius: 50px;
  background: #2d2d2d;
  color: var(--fg);
  font: inherit;
  font-size: 12px;
  font-weight: 700;
  letter-spacing: 0.5px;
  text-transform: uppercase;
  cursor: pointer;
  transition: background-color 200ms ease;
}

/* Selected uses the Figma's 1px border, so the chip grows by 2px; the padding
   drops by 1 to keep the outer size identical and stop the row reflowing as
   chips are toggled. */
.drop__genre[aria-pressed="true"] {
  /* 10/11, not 11/12: OFF-GRID BY DERIVATION, which is the sanctioned kind
     (updated 2026-09-25 alongside the base rule's 8 -> 11). The 1px border
     below must not change the chip's outer size or the row reflows as
     chips are toggled, so this is always the base padding MINUS ONE. Snap
     the base, never this. */
  padding: 10px 11px;
  border: 1px solid #a872df;
  background: #8a2be8;
}

/* --- removable custom genres ---
   Only the ones someone typed can go; the Figma list is fixed. The chip stays
   exactly the pill it was — the "x" is a SIBLING button positioned over extra
   right-padding, because a chip is already a <button> and a second button
   cannot be nested inside one.

   These two rules must sit AFTER `.drop__genre[aria-pressed="true"]` and match
   its weight. That rule is (0,2,0) and sets the `padding` shorthand, so a bare
   `.drop__genre--custom` at (0,1,0) loses the moment a chip is selected and the
   x would sit on top of the last letter. The pressed value drops by 1 for the
   same reason the base rule does: the 1px border must not change the outer
   size, or the row reflows as chips are toggled. */
.drop__genre--custom { padding-right: 36px; }
.drop__genre--custom[aria-pressed="true"] { padding-right: 35px; }

.drop__chip {
  position: relative;
  display: inline-flex;
}

.drop__genre-del {
  position: absolute;
  top: 50%;
  right: 5px;
  transform: translateY(-50%);
  display: flex;
  align-items: center;
  justify-content: center;
  width: 22px;
  height: 22px;
  padding: 0;
  border: 0;
  border-radius: 50%;
  /* A resting background, not just a hover one. Without it the x reads as part
     of the word at a glance — and on touch there is no hover to reveal that it
     is a control at all. */
  background: rgba(255, 255, 255, 0.14);
  color: rgba(255, 255, 255, 0.85);
  cursor: pointer;
  transition: background-color 150ms ease, color 150ms ease;
}

/* The tap target, enlarged — but NOT to the left.
   A symmetric `inset: -6px` overlapped the label by 3px, so tapping the last
   letter of a genre deleted it instead of toggling it. It now grows right, up
   and down freely and only 4px leftward, which still stops 5px clear of the
   text. Never make this symmetric again: the two controls share one pill and
   the label is the bigger, more likely target. */
.drop__genre-del::before {
  content: '';
  position: absolute;
  inset: -9px -5px -9px -4px;
}

.drop__genre-del:hover {
  background: rgba(255, 255, 255, 0.3);
  color: #ffffff;
}

.drop__genre-del:focus-visible {
  color: #ffffff;
  outline: 2px solid var(--fg);
  outline-offset: 1px;
}

@media (prefers-reduced-motion: reduce) {
  .drop__genre-del { transition: none; }
}

.drop__genre:focus-visible,
.drop__genre-add:focus-visible { outline: 2px solid var(--fg); outline-offset: 2px; }

.drop__genre-add {
  color: #ffffff;   /* Phosphor ink: was fill="white" */
  display: flex;
  align-items: center;
  justify-content: center;
  width: 32px;
  height: 32px;
  padding: 0;
  border: none;
  border-radius: 100px;
  background: #8a2be8;
  cursor: pointer;
}

.drop__custom { display: flex; align-items: center; gap: 8px; margin-top: 12px; }
.drop__custom .drop__input { flex: 1 1 auto; margin-top: 0; }

/* Outlined, not filled: a solid button here competed with "Share Music note"
   for primary. Saving a genre is a step inside the form, not the form's action,
   so it reads as secondary now.

   The border and label are #a872df, NOT the #8a2be8 the fill used — that purple
   measures only 3.32:1 as TEXT on the panel and would fail WCAG the moment it
   stopped being a background. #a872df is 5.68:1 and is already the palette's
   lighter purple (it is the selected genre chip's border). The 2px border keeps
   the button's outer size identical to the filled version, so nothing reflows. */
.drop__custom-save {
  flex: none;
  height: 48px;
  padding: 0 16px;
  border: 2px solid #a872df;
  border-radius: 16px;
  background: transparent;
  color: #a872df;
  font: inherit;
  font-weight: 600;
  cursor: pointer;
  transition: background-color 200ms ease, color 200ms ease;
}

.drop__custom-save:hover {
  background: rgba(168, 114, 223, 0.16);
  color: #c4a2ef;
}

@media (prefers-reduced-motion: reduce) {
  .drop__custom-save { transition: none; }
}

.drop__custom-save:focus-visible { outline: 2px solid var(--fg); outline-offset: 2px; }

/* --- the optional comment --- */

/* "(optional)" is dimmer than the label but still carries its own weight — at
   14px on the #0d0d0d panel this measures 5.34:1, the same as the label. It is
   inside the <label>, so a screen reader reads "Why this song? (optional)" as
   one name rather than announcing a stray word after it. */
.drop__optional {
  color: rgba(255, 255, 255, 0.5);
  font-weight: 400;
}

.drop__textarea {
  margin-top: 8px;
  padding: 12px 16px;
  min-height: 92px;
  border: 0;
  border-radius: 16px;
  background: #262626;
  color: var(--fg);
  font: inherit;
  font-size: 16px;   /* below 16px iOS zooms the page on focus */
  line-height: 22px;
  /* Vertical only: horizontal resize would break out of the 400px panel. */
  resize: vertical;
}

.drop__textarea::placeholder { color: rgba(255, 255, 255, 0.5); }
.drop__textarea:focus { outline: none; }
.drop__textarea:focus-visible,
.drop__textarea:focus { outline: 2px solid var(--fg); outline-offset: 2px; }

/* Always visible, counting down, as asked — not a warning that appears late.
   Weight 500 rather than 400: at 12px this is the smallest text in the form, and
   a little more stroke costs nothing and reads better at low vision. */
.drop__count {
  margin: 8px 0 0;
  font-size: 12px;
  font-weight: 500;
  color: rgba(255, 255, 255, 0.5);
  font-variant-numeric: tabular-nums;
  text-align: right;
}

/* The last stretch, so running out is visible before it bites. Colour alone is
   never the signal (WCAG 1.4.1) — the weight jumps to 700 with it, so the
   warning is legible to anyone who cannot separate amber from grey. --cta on
   the panel is 10.05:1. */
.drop__count--low {
  color: var(--cta);
  font-weight: 700;
}

/* --- the comment, on the card --- */

.card__comment {
  /* 8 from .card__body's shared gap, 8 from here: 16 in all. The gap alone was
     8px, which is the spacing between a title and its artist — too tight for
     the break between the transport and someone else's words, which is the
     biggest change of register on the card. The margin is here rather than in
     the body's `gap` because that gap sets the spacing between EVERY child, and
     only this one pair needed opening up. */
  margin: 8px 0 0;
  padding: 16px;
  border-radius: 16px;
  background: #2d2d2d;
}

/* A blockquote, because it is someone's words and not the app's. The quotation
   marks are drawn in CSS so they never end up in the copied text. */
.card__comment-text {
  margin: 0;
  font-size: 14px;
  line-height: 21px;
  color: rgba(255, 255, 255, 0.85);
  overflow-wrap: anywhere;
  /* Clamped to three lines. The -webkit- prefixed form is not legacy here: it
     is the one every current browser implements, Firefox included. The closing
     quotation mark below is part of the text flow, so a clamped comment ends on
     the clamp's own ellipsis with no closing quote — which is correct, because
     the sentence has not finished. */
  display: -webkit-box;
  -webkit-box-orient: vertical;
  -webkit-line-clamp: 3;
  overflow: hidden;
}

/* Expanded. `display: block` rather than raising the clamp, because the clamp
   only applies to -webkit-box and this is the one value that reliably turns it
   off everywhere. */
.card__comment--open .card__comment-text {
  display: block;
  overflow: visible;
}

.card__comment-text::before { content: '\201C'; }
.card__comment-text::after  { content: '\201D'; }

/* The negative side margin lets the button carry real padding — so it is a
   comfortable target rather than a 13px word — while its text still lines up
   with the comment above it. Measured 35px tall, which is under the 44px
   guideline; it is a secondary control inside a panel and the same trade the
   genre chip's x already makes. Extending it upward with a transparent
   ::before would have reached 44, but that overlays the comment text and this
   is the one block on the card people actually select and copy. */
.card__comment-toggle {
  /* The negative left margin still cancels the left padding exactly, so the
     label's text stays flush with the comment above it — both moved 10 -> 8 as
     a PAIR. Vertical padding is unchanged, so the measured 35px height in the
     note above still holds. */
  margin: 8px 0 -4px -8px;
  padding: 8px;
  border: none;
  border-radius: 8px;
  background: none;
  color: #ffffff;
  font: inherit;
  font-size: 13px;
  line-height: 19px;
  font-weight: 600;
  cursor: pointer;
}

.card__comment-toggle:hover { text-decoration: underline; }
.card__comment-toggle:focus-visible { outline: 2px solid var(--fg); outline-offset: 2px; }

/* ============================================================
   THE COMMENT SLEEVE (2026-09-22)

   A second face for the card panel. The record disappears into a square
   kraft sleeve and the sleeve takes its place — not a rectangle laid over
   the record, the record's whole face swapped for a flat one. Tapping a
   pin still opens the record first; the sleeve is one tap further in, and
   playback stops the moment it opens (card.js).

   WHY A SLEEVE RATHER THAN A PANEL ON THE RECORD: the record's every edge
   IS the panel's edge (invariant 26) — the desktop rim bulges past the
   content column and the phone sheet is domed to the disc's own curve.
   Neither has a flat surface a sticker could sit on convincingly. A square
   sleeve does, and it is what a real sleeve looks like next to a record,
   which is the whole reference for this feature.

   THIS IS A LOCAL PROTOTYPE, LIKE EVERYTHING ELSE ON THIS BRANCH. Notes are
   simulated and comments live in localStorage (card.js), so "anyone can
   move anybody's sticker" is true only within one browser today. Real
   sharing needs Phase 1's backend (BACKEND-PLAN.md) — a `comments` table
   next to `notes`, and this CSS does not change when that lands.
   ============================================================ */

/* THE SLEEVE COVERS THE RECORD; IT NO LONGER REPLACES IT (2026-09-24,
   reversing the original "the sleeve replaces the record outright"
   decision — asked for directly: the motion has to read as a physical
   sleeve sliding over a vinyl, which means the vinyl has to still be
   there to be covered). Neither `.card__scroll` nor `.vinyl` is hidden by
   `card--sleeve` any more — both stay rendered, in the same place, and the
   sleeve slides on top of them (see `.sleeve` and `.card--sleeve .sleeve`
   below). This falls out of stacking order that already existed for a
   different reason: `.sleeve` carries `z-index: 1` and `.vinyl` carries
   `z-index: -1` (invariant 26), so once both are simply left on screen
   `.sleeve` already paints above both without anything new being added
   here. `card.js` pairs the class with `inert` on whichever face is
   currently covered, so the hidden one drops out of the tab order and the
   accessibility tree without needing `display: none` to do it — which
   would have made a slide impossible to animate. */

/* --- the door: always visible, reads as both "read" and "write" --- */

.card__comments-toggle {
  display: flex;
  align-items: center;
  gap: 8px;
  align-self: flex-start;
  margin: 16px 0 0;
  /* Vertical padding 8 -> 11 (2026-09-25, WCAG touch-target audit): 34px
     tall -> 40px. It has a visible pill background, so this grows the
     control for real rather than through an invisible hit area — matching
     how it already reads as a bigger, primary "door" into the sleeve. */
  padding: 11px 14px 11px 10px;
  border: none;
  border-radius: 999px;
  background: rgba(255, 255, 255, 0.08);
  color: var(--fg);
  font: inherit;
  font-size: 13px;
  font-weight: 600;
  line-height: 18px;
  cursor: pointer;
  transition: background-color 150ms ease;
}

.card__comments-toggle:hover { background: rgba(255, 255, 255, 0.14); }
.card__comments-toggle:focus-visible { outline: 2px solid var(--fg); outline-offset: 2px; }

/* --- the sleeve itself: a plain rectangle, deliberately --- */

:root {
  /* Kraft paper, the cardboard stock a real sleeve is cut from. Darkened
     2026-09-24 from a pale `#d8c9a8` toward the user's two references — a
     plain kraft sleeve (sampled ~#c89060) and Jungle's brown cover
     (~#4a200c) — then eased back to `#cfa074` when `#bd8555` read as too dark. Contrast
     below was measured at `#bd8555`; the lighter paper only improves it. Darker paper costs
     the ink contrast, so the ink went darker with it and SOFT INK IS NOW
     0.95, not 0.62. JUDGED AT THE DARKEST POINT OF THE TEXTURE, not the flat
     colour: the mottling below darkens the paper by up to 0.12 (measured
     from the rendered tile), and inside the board's extra 5% shade that is
     where soft ink is weakest — 4.55:1 there, `--sleeve-ink` 4.7:1, both
     higher everywhere else. (The old 0.62 soft ink was 3.7:1 on the old
     beige, i.e. already failing.) So the MOTTLE DEPTH AND THE INK ARE ONE
     DECISION: deepen the mottle (its alpha row, `0.26 -0.09`) or darken the
     paper and soft ink drops under 4.5 — at 0.18 it measured 4.2. Sticker
     swatches are unaffected: a shadow,
     not contrast with the kraft, separates a sticker from the paper — see
     `.sticker`. */
  --sleeve-bg: #cfa074;
  --sleeve-ink: #120a02;
  --sleeve-ink-soft: rgba(18, 10, 2, 0.95);
  --sleeve-line: rgba(18, 10, 2, 0.22);
  /* The paper's texture, generated rather than photographed — inline SVG
     data URIs, so no fetch and nothing to vendor. Modelled on the user's
     THIRD reference (2026-09-24), a worn paper inner sleeve: what reads as
     "record-sleeve paper" is SOFT CREASES AND HANDLED EDGES, not specks.
     Two dotted passes were rejected before that — hard dark flecks read as
     sandpaper, and even sparse drawn fibres were "too dotted". Don't add
     dots back.
     `--sleeve-creases` is noise LIT from the top-left (feDiffuseLighting),
     which turns it into gentle folds, then re-centred so flat paper is
     exactly mid-grey and applied with `soft-light` — it only adds light and
     shade, never shifts the brown. Strength is the `slope`/`intercept` pair
     (flat paper lights to 0.87, so intercept = 0.5 - 0.87 x slope); 1.4
     read as crumpled leather, 0.8 vanished. THE TILE IS 1600px ON PURPOSE:
     lighting cannot wrap at a tile edge, so at 760px a seam showed where it
     repeated — the tile has to be bigger than any panel.
     `--sleeve-paper` underneath is a faint, balanced light/dark grain (so it
     does not move the average colour) and a broad soft mottle. */
  --sleeve-creases:
    url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='1600' height='1600'%3E%3Cfilter id='c' x='0' y='0' width='100%25' height='100%25'%3E%3CfeTurbulence type='turbulence' baseFrequency='0.004 0.006' numOctaves='4' seed='19' stitchTiles='stitch'/%3E%3CfeDiffuseLighting surfaceScale='2.5' lighting-color='%23fff' diffuseConstant='1'%3E%3CfeDistantLight azimuth='225' elevation='55'/%3E%3C/feDiffuseLighting%3E%3CfeComponentTransfer%3E%3CfeFuncR type='linear' slope='1.1' intercept='-0.46'/%3E%3CfeFuncG type='linear' slope='1.1' intercept='-0.46'/%3E%3CfeFuncB type='linear' slope='1.1' intercept='-0.46'/%3E%3C/feComponentTransfer%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23c)'/%3E%3C/svg%3E");
  --sleeve-paper:
    url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='240' height='240'%3E%3Cfilter id='k'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.6' numOctaves='3' seed='3' stitchTiles='stitch'/%3E%3CfeColorMatrix values='0 0 0 0 1  0 0 0 0 0.9  0 0 0 0 0.75  0 0 0 0.22 -0.1'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23k)'/%3E%3C/svg%3E"),
    url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='240' height='240'%3E%3Cfilter id='g'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.6' numOctaves='3' seed='3' stitchTiles='stitch'/%3E%3CfeColorMatrix values='0 0 0 0 0.35  0 0 0 0 0.2  0 0 0 0 0.08  0 0 0 -0.22 0.11'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23g)'/%3E%3C/svg%3E"),
    url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='480' height='480'%3E%3Cfilter id='m'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.008' numOctaves='2' seed='5' stitchTiles='stitch'/%3E%3CfeColorMatrix values='0 0 0 0 0.2  0 0 0 0 0.1  0 0 0 0 0.03  0 0 0 0.26 -0.09'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23m)'/%3E%3C/svg%3E");
}

.sleeve {
  /* Absolutely positioned and INSET TO THE PANEL'S OWN EDGE, not to its
     padding. `.card`'s padding-right is `--rim-inset` (invariant 26, desktop
     only) so the record's content clears the rim — but `inset: 0` is
     measured against the padding BOX, which runs to the panel's actual
     border, past that padding. That is the whole trick: this element never
     has to know `--rim-inset` exists. On desktop it also shares `.card`'s
     own clip-path (the rim circle) for free, same as any other child of
     `.card`. On mobile it does NOT — see the mobile media query further
     down, where the dome clip-path lives on `.vinyl`/`.card__scroll`
     directly rather than on `.card` itself (2026-09-25, fixing a bug where
     toggling it on `.card` also reshaped the record underneath), so
     `.sleeve` was never clipped by anything there to begin with. */
  position: absolute;
  inset: 0;
  z-index: 1;
  display: flex;
  flex-direction: column;
  /* THE SLEEVE SLIDES ON, IT DOES NOT POP ON (2026-09-24). This used to be a
     `hidden`-attribute swap with `.card__scroll`/`.vinyl` — instant, no
     transition, because the two faces could never coexist. Now that the
     record stays rendered underneath (see the note above
     `.card--sleeve .card__scroll` further up), the sleeve is free to slide
     across it like a real cover instead of a face flipping over. Sliding
     ACROSS rather than the record's own down-then-tilt entrance (invariant
     26) or a top-down drop — asked for directly: a sleeve goes onto a
     record from one open edge, not from above.
     `translateX(-100%)` clears the sleeve's OWN width, so it works at any
     panel size without knowing one — off past the panel's LEFT edge at
     rest (the user's call, 2026-09-24, after a first pass entered from the
     right), sliding right to cover. `visibility` follows the same
     delayed-flip idiom `.card`/`.card--in` already use (this file,
     invariant on the panel reveal): hidden only once the CLOSING transition
     has actually finished, so a screen reader and the tab order never lose
     the covered face mid-slide, and `inert` (card.js) is what actually
     pulls whichever face is covered out of interaction — visibility alone
     does not block a click. */
  visibility: hidden;
  will-change: transform;
  transform: translateX(-100%);
  transition: transform 320ms cubic-bezier(0.4, 0, 1, 1),
              visibility 0s linear 320ms;
  /* Creases first, BLENDED soft-light so they only add light and shade to
     the brown beneath rather than painting grey over it; the rest normal.
     The blend list needs one entry PER LAYER — a short list repeats, and
     would soft-light the grain too. The inset shadow is the
     aged edge the user's crumpled-sleeve reference has — paper darkens
     where it is handled. */
  background: var(--sleeve-creases), var(--sleeve-paper), var(--sleeve-bg);
  background-blend-mode: soft-light, normal, normal, normal;
  box-shadow: inset 0 0 70px rgba(70, 35, 10, 0.35);
  color: var(--sleeve-ink);
}

/* The state it slides TO — 400ms, a touch slower than the 320ms it leaves
   on, same asymmetry as the record's own panel (600ms in / 400ms out): an
   object arriving settles, one leaving departs. easeOutQuint again, the
   project's one curve for "something arriving" (the panel reveal, the map
   buttons' hover) — no bounce, since this is a cover sliding into place on
   top of an already-open panel, not a panel arriving from off-screen. */
.card--sleeve .sleeve {
  visibility: visible;
  transform: translateX(0);
  transition: transform 400ms cubic-bezier(0.22, 1, 0.36, 1), visibility 0s;
}

@media (prefers-reduced-motion: reduce) {
  .sleeve { transition: visibility 0s; }
  .card--sleeve .sleeve { transition: visibility 0s; }
}

/* A COLUMN now (2026-09-28), not a single row — the title row sits on top
   and the hint, when it shows at all, sits below it. `.sleeve__head-row` is
   what used to be this element's own flex row (the back button + whatever
   text sat beside it); this element now only stacks that row above the
   hint. */
.sleeve__head {
  display: flex;
  flex-direction: column;
  gap: 8px;
  flex: none;
  /* Right padding is 68px, not 20 — `.sleeve__close` is absolutely
     positioned (`top: 20px; right: 20px`, a 40px box), OUTSIDE this flex
     column rather than a flex child of it the way `.drop__close` is of
     `.drop__head`, so there is no `justify-content: space-between` trick
     to lean on here. 20 (its own right offset) + 40 (its width) = 60 is
     where its box starts; 68 clears it with 8px to spare, so both the row
     and the hint below it wrap before reaching it rather than running
     underneath.
     Written as variables, not bare numbers, because `.sleeve__title` below
     has to cancel exactly these two values to reach past them — see its
     own comment. Change the padding, and the title's centering follows. */
  --sleeve-head-pad-l: 20px;
  --sleeve-head-pad-r: 68px;
  padding: 20px var(--sleeve-head-pad-r) 12px var(--sleeve-head-pad-l);
}

.sleeve__head-row {
  display: flex;
  align-items: center;
  gap: 12px;
  /* Positioning context for `.sleeve__title` below, which centers on THIS
     row rather than sharing its flex flow with `.sleeve__back`. */
  position: relative;
}

/* Same display-face treatment `.card__title`/`.drop__title` already use for
   a screen's own name, just in the sleeve's ink (`--sleeve-ink`, kraft
   paper) instead of `--fg` (a dark panel). Sized to `.card__title`'s 20px,
   not `.drop__title`'s 24 — the sleeve is a second FACE of the same card,
   not its own full panel.

   CENTERED ON THE ROW, NOT LEFT AGAINST THE ARROW (2026-09-29), asked for
   directly. Staying a flex sibling of `.sleeve__back` and centering its
   own text would only centre it in the space left over AFTER the arrow's
   width, which reads off-centre against the header as a whole — so it is
   pulled out of that flow instead and centred on a box measured from the
   row. `.sleeve__back` is then the row's only flex child, which does not
   change its own size or the row's height (still set by the 40px back
   button, as it always was). `pointer-events: none` because this is a
   static label with nothing to click — it must not sit on top of the
   arrow and steal its taps now that the two overlap in the same box.

   STILL VISIBLY OFF-CENTRE, REPORTED DIRECTLY (2026-09-29, same day) —
   because `inset: 0` centred it on `.sleeve__head-row`'s own box, and that
   box is NOT centred on the sleeve: it is `.sleeve__head`'s padded content
   area, and that padding is asymmetric (20px left, 68px right, reserved
   for `.sleeve__close` — see that element's own comment). Measured at
   520px wide: row spans x 20-452 (centre 236), while the sleeve itself
   spans 0-520 (centre 260) — 24px off, which is exactly the "left-leaning"
   read. Centering on the row was never going to fix this; the row itself
   is off-centre.
   `left`/`right` now reach past the row's own edges by exactly
   `.sleeve__head`'s two padding values (as negative offsets, canceling
   them), landing on `.sleeve__head`'s padding box — which IS the full
   sleeve width, since the header has no margin of its own. `top`/`bottom`
   are untouched at 0, so the vertical anchor stays the row's own height;
   only the horizontal reach changed. Verified: text centre now 260.00,
   matching the sleeve's true centre to 0.00px, at both the 520px desktop
   panel and the 375px phone sheet (where the sleeve is full-width and the
   same asymmetric padding still applies). */
.sleeve__title {
  position: absolute;
  top: 0;
  bottom: 0;
  left: calc(-1 * var(--sleeve-head-pad-l));
  right: calc(-1 * var(--sleeve-head-pad-r));
  display: flex;
  align-items: center;
  justify-content: center;
  margin: 0;
  font-family: "Bungee", "Inter", sans-serif;
  font-weight: 400;
  font-size: 20px;
  line-height: 26px;
  color: var(--sleeve-ink);
  text-transform: uppercase;
  pointer-events: none;
}

.sleeve__back {
  /* Icon-only now (2026-09-24) — the label moved to a visually-hidden span
     in index.html, so `gap` has nothing left to space against.
     Padding 8 -> 10 (2026-09-25, WCAG touch-target audit): 20px icon + 2x10
     padding = 40px box. The matching negative margin keeps the VISIBLE
     position unchanged — this is the invisible-hit-area trick, not a
     visual grow, so the header's layout doesn't shift. */
  display: flex;
  align-items: center;
  margin: -10px 0 -10px -10px;
  padding: 10px;
  border: none;
  border-radius: 8px;
  background: none;
  color: var(--sleeve-ink);
  font: inherit;
  font-size: 14px;
  font-weight: 600;
  cursor: pointer;
}

/* No hover background (2026-09-24) — dropped in the same session the wash
   was flagged as the odd one out: every other icon button here answers a
   hover with motion alone (invariants 35, 37, and `.card__close`/
   `.sleeve__close` above), so a background wash on top of the new arrow
   nudge was two signals for one control. */
.sleeve__back:focus-visible { outline: 2px solid var(--sleeve-ink); outline-offset: 2px; }

/* THE ARROW NUDGES LEFT AND BACK ON HOVER (2026-09-24), standing in for the
   word now that the label is visually hidden — "back" reads from the
   direction of travel rather than from text. Same idiom as the globe's hop
   (`map-discover-hop` above): a one-shot keyframe animation on `:hover`,
   not a persistent hover transform, so it plays once and settles at rest
   while the pointer is still there — a peek, not a permanent shift. Each
   keyframe carries its OWN easing (leaving fast, arriving slow, the same
   "weight" logic as the hop), so the wrapping `animation` duration is
   `linear`. `will-change` is deliberately NOT added here — that fix was for
   a small vector RESHAPING under `scale()`, which blurs while rasterizing;
   a plain `translateX` moves an already-rasterized layer and does not hit
   the same artifact. Gated on `(hover: hover)` so a sticky touch `:hover`
   cannot strand the icon off to the side. */
.sleeve__back .icon { transform: translateX(0); }
@media (hover: hover) {
  .sleeve__back:hover .icon {
    animation: sleeve-back-nudge 380ms linear;
  }
}
@keyframes sleeve-back-nudge {
  0% {
    transform: translateX(0);
    animation-timing-function: cubic-bezier(0.22, 0.61, 0.36, 1);
  }
  45% {
    transform: translateX(-4px);
    animation-timing-function: cubic-bezier(0.55, 0.06, 0.68, 0.19);
  }
  100% {
    transform: translateX(0);
  }
}
@media (prefers-reduced-motion: reduce) {
  .sleeve__back:hover .icon { animation: none; }
}

/* THE HEADER'S HINT TEXT (2026-09-25, moved below the title row and made
   conditional on 2026-09-28). It used to be `.sleeve__back`'s own flex-row
   sibling, serving as the row's only visible label; now `.sleeve__title`
   carries that job (a real Bungee heading, asked for directly) and this
   drops to a plain block below the row, shown only once a comment actually
   exists ("once someone leaves a comment, this text... can appear below
   the header"). Still Inter / `--sleeve-ink-soft` — the type style itself
   was never asked to change, only its position and whether it shows at
   all. The `flex`/`min-width: 0` wrapping guard from the old row layout is
   gone with it; a block-level `<p>` under `.sleeve__head`'s own 68px
   right-padding wraps correctly with no flex trick needed.
   HIDDEN BY DEFAULT, SHOWN ONLY WHEN `.sleeve` ITSELF IS MARKED NON-EMPTY —
   the exact same `data-empty` flag `.sleeve__board[data-empty]` already
   used for `.sleeve__empty` below, promoted from `.sleeve__board` to
   `.sleeve` (their nearest shared ancestor) so both can read the one flag
   card.js computes in `renderBoard()`, rather than keeping two copies of
   the same fact in two different attributes. */
/* CENTRED ON THE PANEL, LIKE THE "COMMENTS" TITLE ABOVE IT (2026-09-30).
   Was left-aligned to `.sleeve__write`'s edge (same day), then centred on
   request. `.sleeve__head` is padded 20 left / 68 right (the right side
   clears the X), so its content box is centred 24px LEFT of the panel and
   plain `text-align: center` would sit 24px off the title. A 48px left
   margin makes the box symmetric (68 each side), so its centre is the
   panel's. Keeps the same 68px clearance from the X on both sides, which
   also means the two-line wrap on a phone is balanced. */
.sleeve__hint {
  display: none;
  margin: 0 0 0 48px;
  text-align: center;
  font-size: 13px;
  line-height: 19px;
  color: var(--sleeve-ink-soft);
}

.sleeve[data-empty="false"] .sleeve__hint { display: block; }

/* Same pill treatment as `.map-toast` (colour, radius, font, fade), but
   anchored to `.sleeve` (already `position: absolute`) instead of the whole
   map, so it appears where the report actually happened rather than
   floating over the map behind an open panel. z-index 6 clears everything
   else `.sleeve` stacks internally, including the report menu's own 5.
   `overflow: hidden` is new (2026-09-29, for the countdown bar below) — it
   clips the bar to this pill's own rounded corners rather than letting a
   square bar poke past them at full width. */
.sleeve__toast {
  position: absolute;
  top: 84px;
  left: 50%;
  transform: translateX(-50%);
  margin: 0;
  /* Extra bottom padding (was a plain 10px) reserves the bar's own strip
     without it overlapping the text baseline. */
  padding: 10px 16px 13px;
  border-radius: 10px;
  background: rgba(20, 20, 20, 0.94);
  color: #fafafa;
  font-size: 13px;
  line-height: 18px;
  text-align: center;
  max-width: calc(100% - 32px);
  /* ONE LINE, always (2026-09-30, asked for: it wrapped to two on a phone).
     Every message this toast shows is short enough to fit a 320px screen;
     the ellipsis is only a backstop so a future longer one is cut cleanly
     rather than wrapping. */
  white-space: nowrap;
  text-overflow: ellipsis;
  z-index: 6;
  pointer-events: none;
  opacity: 0;
  overflow: hidden;
  transition: opacity 200ms ease;
}
.sleeve__toast.is-shown { opacity: 1; }

/* THE COUNTDOWN BAR — asked for directly ("a time bar under the toast so
   users can see when it will disappear"), 2026-09-29. A single bar that
   shrinks from full width to nothing over the SAME window the toast is
   actually on screen for, so it is real information (how much longer this
   stays up), not decoration — which is why, unlike most motion in this
   file, it is NOT simply killed under reduced motion below; it is instead
   made to jump in one step rather than animate continuously, the same
   "lose the travel, keep the state" rule invariant 17b's countdown ring
   already uses for exactly this reason (that ring also carries real
   information no other element repeats).
   `transform: scaleX`, not `width` — animating width forces layout on every
   frame; a transform composites instead, same reasoning as every other
   animated property in this file. `transform-origin: left` is what makes
   it shrink FROM the right edge TOWARDS the left, reading as "time running
   out left-to-right" rather than shrinking from the centre. */
.sleeve__toast-bar {
  position: absolute;
  left: 0;
  right: 0;
  bottom: 0;
  height: 3px;
  /* Was rgba(255,255,255,0.55) — reported as not standing out against the
     near-black toast fill (and, behind it, the sleeve's own kraft paper).
     #22c55e (Tailwind green-500) is the same green as the location dot in
     the header bar (.map-place__dot and its halo), so "confirmed" and
     "this is you" share one hue. The copy-link and reported checks are
     still #4ade80 and do not match yet. */
  background: #22c55e;
  transform: scaleX(0);
  transform-origin: left center;
}
/* `animation-duration` here MUST match `SLEEVE_TOAST_MS` in card.js — that
   constant is what actually removes `.is-shown` (and so hides the toast);
   this is only the visual echo of it, and the two silently disagreeing
   would mean the bar either finishes early (reading as "gone" while the
   message is still up) or is still full when the message vanishes. */
.sleeve__toast.is-shown .sleeve__toast-bar {
  animation: sleeve-toast-countdown 3000ms linear forwards;
}
@keyframes sleeve-toast-countdown {
  from { transform: scaleX(1); }
  to { transform: scaleX(0); }
}

@media (prefers-reduced-motion: reduce) {
  .sleeve__toast { transition: none; }
  /* Not `display: none` — the bar still needs to exist and be visible;
     only its continuous animation is what reduced motion objects to.
     `animation: none` alone would leave it at its base `scaleX(0)` (i.e.
     invisible before the animation ever ran, since the animation is what
     sets scaleX(1) at 0%) — explicitly forcing `scaleX(1)` here is what
     keeps it showing FULL for the toast's whole visible duration, then
     disappearing in one step with everything else when `.is-shown` is
     removed, rather than never appearing at all. */
  .sleeve__toast.is-shown .sleeve__toast-bar {
    animation: none;
    transform: scaleX(1);
  }
}

.sleeve__scroll {
  flex: 1;
  min-height: 0;
  overflow-y: auto;
  padding: 0 20px 24px;
  /* A column, so the board can take up the slack and push the write button
     or the composer to the BOTTOM of the sleeve (2026-09-24). */
  display: flex;
  flex-direction: column;
}

/* THE BOARD FILLS THE SLEEVE'S SPARE HEIGHT; IT IS NO LONGER A SQUARE
   (2026-09-24, the user's call). It was `aspect-ratio: 1/1`, which left the
   composer floating mid-panel with empty kraft below it; now it grows
   (`flex: 1`) and the write button or composer sits at the sleeve's foot.
   Nothing in card.js assumed a square — positions are stored as a
   percentage of each axis separately and the drag reads the live rect — so
   a sticker keeps its relative spot as the board changes shape. The
   `min-height` is what makes a short screen SCROLL instead of squashing the
   board flat; width is still capped at 420px so it does not balloon on a
   wide desktop panel. */
.sleeve__board {
  position: relative;
  /* THE BOARD IS THE WHOLE SLEEVE BETWEEN THE HEADER AND THE COMPOSER, AND
     IT IS INVISIBLE (2026-09-24, the user's call). It was a 420px-capped
     box with a 1px outline and a 5% darker fill, which read as a frame the
     stickers had to stay inside. Now there is no outline, no fill, and the
     negative margin reaches back over `.sleeve__scroll`'s 20px side padding
     so it runs edge to edge — a sticker can go anywhere on the paper. The
     drag clamp reads this element's live rect, so it follows for free. */
  flex: 1 0 auto;
  min-height: 280px;
  margin: 0 -20px;
  background: none;
  /* Clips a sticker dragged to the very edge rather than letting it spill
     onto the header or the composer — card.js also clamps the stored
     position, so this is a backstop, not the only guard. */
  overflow: hidden;
  touch-action: none;
}

.sleeve__empty {
  position: absolute;
  inset: 0;
  display: flex;
  align-items: center;
  justify-content: center;
  margin: 0;
  padding: 0 32px;
  text-align: center;
  font-size: 13px;
  line-height: 19px;
  color: var(--sleeve-ink-soft);
}

/* Hidden the instant a sticker exists — card.js toggles this, not CSS,
   since it also has to stop counting once real content is there. Reads off
   `.sleeve`'s own `data-empty` now (2026-09-28), not `.sleeve__board`'s —
   promoted to their shared ancestor so `.sleeve__hint` above can read the
   same flag rather than card.js keeping two attributes in sync by hand. */
.sleeve[data-empty="false"] .sleeve__empty { display: none; }

.sleeve__write {
  display: flex;
  align-items: center;
  justify-content: center;
  gap: 8px;
  width: 100%;
  max-width: 420px;
  height: 48px;
  margin: 16px auto 0;
  /* SOLID, not dashed, AND 1.5px (2026-09-24) — matching "Travel the
     globe"'s `.btn--secondary` outline exactly (`border: 1.5px solid
     var(--cta)`), just on the sleeve's own `--sleeve-line` token rather
     than borrowing `--cta` (that button's landing-page orange would clash
     with the kraft/ink palette here). */
  border: 1.5px solid var(--sleeve-line);
  border-radius: 12px;
  background: none;
  color: var(--sleeve-ink);
  font: inherit;
  font-size: 14px;
  font-weight: 600;
  cursor: pointer;
  transition: background-color 150ms ease;
}

.sleeve__write:hover { background: rgba(42, 35, 24, 0.06); }
.sleeve__write:focus-visible { outline: 2px solid var(--sleeve-ink); outline-offset: 2px; }

/* Once someone has already left their one comment, or once the composer is
   open, the door is not shown — never both at once, and never a second
   door while the first comment is still theirs to delete instead. */
.sleeve__write[hidden] { display: none; }

/* --- the composer --- */

.sleeve__composer {
  width: 100%;
  max-width: 420px;
  margin: 16px auto 0;
  padding: 16px;
  border-radius: 12px;
  background: rgba(0, 0, 0, 0.06);
}

.sleeve__field-row {
  display: flex;
  /* WRAPS (2026-10-10): five shapes + three colours are ~302px on one row,
     which only fits a 375px-wide phone. On a narrower Android phone the
     colours ran off the right edge; now they drop to a second line. */
  flex-wrap: wrap;
  align-items: center;
  justify-content: space-between;
  gap: 12px;
  margin-bottom: 12px;
}

.sleeve__shapes,
.sleeve__colors { display: flex; align-items: center; gap: 6px; }

/* THE FIVE PREVIEWS ARE ONE FAMILY (2026-09-24): every one is a 28px box
   drawn as a SILHOUETTE in the sleeve's ink. They were a CSS disc and square
   at 28px beside a Phosphor heart at 16px and the Figma blobs at 18px WITH
   their white paper backing showing — five sizes and two treatments.
   The heart is now the user's own Figma heart (`#sticker-heart`), the same
   artwork the posted sticker uses, not a generic icon.
   `--sticker-paper: transparent` is what drops the white backing: each
   sticker symbol's base shape reads `fill: var(--sticker-paper, white)`, so
   the previews switch it off and the stickers on the board keep it.
   ALL FIVE ARE ONE COLOUR IN EVERY STATE, and the pressed one gets a RING
   separated by a gap of kraft — the same mark the colour swatches use, so
   the row has one selection language. Two treatments failed first: a ring
   drawn ON the button's own edge, the same ink as a filled disc, was
   invisible; and marking selection by going darker read as the pressed
   shape simply being the wrong colour (the user's report). The colour is
   the sleeve's ink mixed 55% into the kraft, about 3:1 against it (WCAG
   1.4.11) — `color-mix`, so it follows either token if they move. */
.sleeve__shape-btn {
  position: relative;   /* anchors the invisible hit-area `::after` below */
  width: 28px;
  height: 28px;
  flex: none;
  padding: 0;
  border: none;
  background: none;
  border-radius: 6px;
  color: color-mix(in srgb, var(--sleeve-ink) 55%, var(--sleeve-bg));
  --sticker-paper: transparent;
  cursor: pointer;
  display: flex;
  align-items: center;
  justify-content: center;
  transition: box-shadow 150ms ease;
}

/* Invisible tap-area expansion (2026-09-25, WCAG touch-target audit) — an
   `::after` because `::before` already draws the circle/rectangle glyph
   below. 28px -> 40px effective. Capped at 6px a side deliberately: five
   shapes and three colours share one row with only 12px between neighbours
   (`.sleeve__shapes`/`.sleeve__colors`/`.sleeve__field-row` all use it), so
   expanding further would make adjacent hit areas overlap and steal taps
   from each other — the exact failure mode this trick exists to avoid.
   Growing the VISIBLE row to fit a full 44px target instead was rejected:
   it would force a second row on a 375px screen, a bigger layout change
   than this session's other fixes. */
.sleeve__shape-btn::after {
  content: "";
  position: absolute;
  inset: -6px;
}

.sleeve__shape-btn--circle::before,
.sleeve__shape-btn--rectangle::before {
  content: "";
  width: 24px;
  height: 24px;
  background: currentColor;
}
.sleeve__shape-btn--circle::before    { border-radius: 50%; }
.sleeve__shape-btn--rectangle::before { border-radius: 4px; }
.sleeve__shape-btn .icon { width: 28px; height: 28px; }

.sleeve__shape-btn:hover { box-shadow: 0 0 0 2px var(--sleeve-bg), 0 0 0 4px var(--sleeve-line); }
.sleeve__shape-btn[aria-pressed="true"] {
  box-shadow: 0 0 0 2px var(--sleeve-bg), 0 0 0 4px var(--sleeve-ink);
}
.sleeve__shape-btn:focus-visible { outline: 2px solid var(--sleeve-ink); outline-offset: 5px; }

/* THREE SWATCHES (2026-09-24, replacing the free colour input of 09-23).
   Chosen to stand out on the kraft: blue is its complement, cream stands
   out by lightness, pink by saturation. The pressed one carries a ring
   separated by a gap of kraft, so it reads on the dark blue and the pale
   cream alike. */
.sleeve__color-btn {
  position: relative;   /* anchors the invisible hit-area `::after` below */
  width: 26px;
  height: 26px;
  flex: none;
  padding: 0;
  border: none;
  border-radius: 50%;
  background: var(--swatch);
  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);
  cursor: pointer;
}
/* Same trick, same 6px cap, as `.sleeve__shape-btn::after` above — 26px ->
   38px effective, capped by the same 12px neighbour gaps. */
.sleeve__color-btn::after {
  content: "";
  position: absolute;
  inset: -6px;
}
.sleeve__color-btn[aria-pressed="true"] {
  box-shadow: 0 0 0 2px var(--sleeve-bg), 0 0 0 4px var(--sleeve-ink);
}
.sleeve__color-btn:focus-visible { outline: 2px solid var(--sleeve-ink); outline-offset: 5px; }

.sleeve__colors { gap: 12px; }
.sleeve__shapes { gap: 12px; }

.sleeve__text {
  display: block;
  width: 100%;
  min-height: 44px;
  padding: 10px 12px;
  border: 1px solid var(--sleeve-line);
  border-radius: 8px;
  background: var(--sleeve-bg);
  color: var(--sleeve-ink);
  font: inherit;
  font-size: 14px;
  line-height: 20px;
  resize: none;
}

.sleeve__text::placeholder { color: var(--sleeve-ink-soft); }
.sleeve__text:focus-visible { outline: 2px solid var(--sleeve-ink); outline-offset: 1px; }

/* Right-aligned actions row only now — the count moved to its own line
   above (2026-09-24), matching `.drop__count`'s position under its
   textarea. `justify-content: flex-end` replaces the old `space-between`,
   which existed only to push the count and the buttons to opposite ends of
   this row; with one child left, `space-between` would collapse it to the
   LEFT instead. */
.sleeve__composer-foot {
  display: flex;
  align-items: center;
  justify-content: flex-end;
  margin-top: 10px;
}

/* Same convention as `.drop__count` (2026-09-24): a full phrase rather than
   a bare number, right-aligned on its own line directly under the field,
   `margin: 8px 0 0` matching exactly. `<p>`, not `<span>`, for the same
   reason — a block of its own line rather than sharing a row. */
.sleeve__count {
  margin: 8px 0 0;
  font-size: 12px;
  font-weight: 500;
  font-variant-numeric: tabular-nums;
  color: var(--sleeve-ink-soft);
  text-align: right;
}

/* The last stretch, same idea as `.drop__count--low` — weight carries the
   warning as well as colour, per WCAG 1.4.1, so it still reads for anyone
   who cannot separate this red from the kraft. `#6b1414` is NOT one of the
   app's existing marker reds (`#9C1C31`, `#C62842`, `#f1472f`) — those were
   all measured against black vinyl or white, and every one of them reads
   under 4:1 against this kraft `#cfa074` (`#9C1C31` measures 3.41:1 here).
   `#6b1414` measures 5.15:1 on the rendered kraft, clearing the 4.5:1 floor
   this 12px text needs — it is not large enough for the lower 3:1 bar.
   Threshold is 10 of the sticker's 60 characters — the same ~14% of the
   limit `.drop__count--low`'s 40-of-280 uses, rounded to a clean number. */
.sleeve__count--low {
  color: #6b1414;
  font-weight: 700;
}

.sleeve__composer-actions { display: flex; gap: 8px; }

.sleeve__cancel,
.sleeve__post {
  /* Vertical padding 8 -> 12 (2026-09-25, WCAG touch-target audit): ~31.5px
     tall -> ~40px. Visible pill background on Post, so growing the padding
     grows the real control, same reasoning as `.card__comments-toggle`. */
  padding: 12px 16px;
  border: none;
  border-radius: 999px;
  font: inherit;
  font-size: 13px;
  font-weight: 600;
  cursor: pointer;
}

.sleeve__cancel {
  background: none;
  color: var(--sleeve-ink-soft);
}

.sleeve__cancel:hover { color: var(--sleeve-ink); }

.sleeve__post {
  background: var(--sleeve-ink);
  color: var(--sleeve-bg);
}

.sleeve__post:disabled {
  background: rgba(42, 35, 24, 0.25);
  color: rgba(42, 35, 24, 0.4);
  cursor: not-allowed;
}

.sleeve__cancel:focus-visible,
.sleeve__post:focus-visible { outline: 2px solid var(--sleeve-ink); outline-offset: 2px; }

/* --- stickers --- */

/* STICKER TEXT IS ALWAYS `#121212` (2026-09-24, the user's call), so the
   COLOURS are chosen to suit the ink rather than the ink computed per
   colour. That retires `pickInk()` and the light ink it could choose: with
   one fixed dark ink, every sticker colour offered must be LIGHT, and the
   three in index.html (`.sleeve__color-btn`) were measured for it — sky
   `#8fd3ff` 11.5:1, lemon `#ffe45c` 14.7:1, pink `#ff9ecb` 9.8:1 against
   the text. Aimed at 7:1, not 4.5, because stickers shrink to half size as
   the board fills (`--sticker-scale`) and small text needs the margin.
   Against the kraft they pop by HUE (sky is kraft's complement, pink sits
   well away from it) or by LIGHTNESS (lemon); a dark colour would pop more
   but would bury the text, which is exactly the trade this rules out.
   ANY NEW SWATCH MUST BE CHECKED AGAINST `#121212` FIRST. */
:root {
  --sticker-ink: #121212;
  --sticker-paper-default: #f6efe0;   /* a colourless sticker's fallback fill */
}

/* Sized by card.js from the sticker count (`--sticker-scale`, 1 down to a
   floor as the board fills) rather than a fixed px value, per the answer
   "stickers can shrink" — see card.js's "the sleeve" section for the curve
   and the floor. */
.sticker {
  position: absolute;
  left: var(--x, 50%);
  top: var(--y, 50%);
  /* 180px (2026-09-24, was 140): the blob shapes' usable area was so small
     at 140 that they clamped to 2 lines against the rectangle's 5 — seen on
     screen and read as inconsistent. Rather than keep the size and grow the
     mismatch, the sticker itself grew and the clamp became ONE number for
     every shape (see `.sticker__words`), so all five now behave the same
     way: two lines, then an ellipsis. Change this with `--open-scale`
     below — the two are one ratio. */
  width: calc(180px * var(--sticker-scale, 1));
  height: calc(180px * var(--sticker-scale, 1));
  box-sizing: border-box;
  /* NOT flex, and NOT how this started. `.sticker__text` was a flex item of
     this element with no explicit `flex-basis`, and `width: 100%` on it —
     which should have set the basis — was silently overridden to near-0.
     Measured `getComputedStyle` width at 5.67px, then 8.57px for different
     text, both far under the 60px+ the box actually had: a flex item's
     `width` is only ADVISORY for its flex-basis, and something in this
     stack (the absolutely positioned heart glyph as a sibling, sized text,
     the padding — never fully isolated) was still collapsing it. Rather
     than chase a flex-basis bug in a decorative shape, the text is now
     absolutely positioned INSIDE this box instead of flowing through it —
     see `.sticker__text` — which sidesteps flex sizing entirely. */
  /* Centred on its own stored point and given a slight fixed tilt per
     sticker (card.js), so a freshly-posted board does not look like a grid
     of perfectly upright tiles — closer to something actually stuck down by
     hand. Rotation travels with the drag; it is set once, at creation, and
     never changes afterwards. */
  transform: translate(-50%, -50%) perspective(420px) rotateX(calc(var(--tilt-x, 0deg) + var(--peel))) rotateY(var(--tilt-y, 0deg)) rotate(var(--rot, 0deg)) scale(calc(var(--open-scale, 1) * var(--lift)));
  transform-origin: center;
  color: var(--ink);
  background: var(--bg);
  /* The lift off the paper. Doing this rather than a border is also what
     lets a pale swatch (cream) still read as a distinct object against a
     background close to it in luminance — the shadow is the edge, not a
     contrast ratio between the two fills. */
  box-shadow: 0 2px 6px rgba(0, 0, 0, 0.28), 0 1px 0 rgba(255, 255, 255, 0.25) inset;
  cursor: grab;
  touch-action: none;
  -webkit-user-select: none;
  user-select: none;
  transition: transform 180ms cubic-bezier(0.22, 1, 0.36, 1), box-shadow 180ms ease;
}

/* `--bg` comes from card.js (inline `--sticker-color`); the ink is the one
   fixed `--sticker-ink` for every sticker — see the note above it. */
.sticker {
  --bg: var(--sticker-color, var(--sticker-paper-default));
  --ink: var(--sticker-ink);
}

/* THE WHITE EDGE IS WHAT MAKES IT A STICKER (2026-09-24). Every shape now
   carries it in the user's Figma art — see `.sticker__art`. The rectangle
   was the last one drawn in CSS, and its 1.5px line sat OUTSIDE the white
   edge; in Figma the hand-drawn outline is on the coloured shape, INSIDE
   the white, on all five (the user spotted the inconsistency). */
/* Heart/Blob/Blob 2: the user's own Figma sticker art (sticker-sprite,
   index.html), each carrying its own white paper base and hand-drawn black
   outline baked in — only the main shape's fill is `currentColor`, driven
   here. Positioned exactly like the old Phosphor heart glyph was, and for
   the same reason: it scales with `--sticker-scale` for free instead of a
   viewBox recomputed in JS on every resize (invariant 17's rule). */
.sticker--rectangle,
.sticker--circle,
.sticker--heart,
.sticker--blob,
.sticker--blob2 { background: none; box-shadow: none; }

.sticker__art {
  position: absolute;
  inset: 0;
  width: 100%;
  height: 100%;
  /* `color` on `.sticker` itself is the TEXT ink (`--ink`), inherited down
     into `.sticker__text` — the glyph needs the swatch colour instead
     (`--bg`), so it is set again here rather than reusing the inherited
     value. Two different things want `currentColor` in this one element. */
  color: var(--bg);
  filter: drop-shadow(0 2px 4px rgba(0, 0, 0, 0.32));
}

/* ============ CARRYING A STICKER: THE TILT (2026-09-24) ============
   From the user's screen recording. SECOND VERSION — the first misread it.
   It had a flat side-to-side WOBBLE and a band of light LOOPING across the
   sticker; the user pointed out the video does neither. Frame by frame, at
   full resolution: a sticker held STILL sits flat and lifted with no sheen
   at all; a sticker being MOVED tilts in 3D toward its direction of travel
   (one edge dips away, the other comes forward — which foreshortens the
   outline, and that is what read as a spin), and the light across it is a
   REFLECTION that shifts with the tilt, faint, and gone when it is flat.
   So everything here is driven by the drag's VELOCITY, from card.js
   (`wireSticker`), which writes per frame:
     --tilt-x / --tilt-y   the 3D tilt, eased toward a target from the
                           pointer's speed, capped, decaying to 0 at rest
     --shx / --shy / --sho where the reflection sits, and how strong
   `.is-dragging` adds the lift and deeper shadow; on release
   `.is-settling` holds the smooth path while the tilt eases back to flat.
   The tilt goes INSIDE `.sticker`'s one `transform`, never in the
   individual `rotate`/`scale` properties, which apply BEFORE `transform`
   and would swing the sticker round its translate(-50%) offset — the same
   one-property collision invariants 28, 30 and 38 record. */
@property --lift { syntax: "<number>"; inherits: false; initial-value: 1; }
@property --peel { syntax: "<angle>";  inherits: false; initial-value: 0deg; }

.sticker__sheen {
  position: absolute;
  inset: 0;
  pointer-events: none;
  /* SUBTLE, asked for: a faint shade leading a faint highlight. */
  background: linear-gradient(115deg,
    transparent 38%,
    rgba(0, 0, 0, 0.08) 46%,
    rgba(255, 255, 255, 0.28) 51%,
    rgba(255, 255, 255, 0) 58%) 0 0 / 260% 260% no-repeat;
  background-position: calc(50% + var(--shx, 0%)) calc(50% + var(--shy, 0%));
  opacity: var(--sho, 0);
  -webkit-mask: var(--sheen-mask) center / contain no-repeat;
  mask: var(--sheen-mask) center / contain no-repeat;
}
/* Each silhouette is the WHITE BASE path of that shape's sprite symbol, in
   the same viewBox — `contain` places it exactly as the art's own `meet`
   does. Regenerate from index.html if the art changes (and note the two
   blob symbols' base paths share the id "White Blob" — select by symbol,
   never by that id). The rectangle is a CSS box, so its radius clips it. */
.sticker--rectangle { --sheen-mask: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 330 330'%3E%3Crect width='330' height='330' rx='20.625' fill='black'/%3E%3C/svg%3E"); }
.sticker--circle { --sheen-mask: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 330 330'%3E%3Ccircle cx='165' cy='165' r='165' fill='black'/%3E%3C/svg%3E"); }
.sticker--heart  { --sheen-mask: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 330 286'%3E%3Cpath d='M203.083 258.927C239.037 231.98 290.921 189.793 312.542 156.053C328.721 130.846 333.984 99.6169 326.948 70.5806C311.913 4.4387 228.659 -22.5885 176.801 21.7359C173.884 24.2123 171.196 26.9576 168.436 29.7765C167.31 30.927 166.171 32.0896 165 33.2512C163.829 32.0896 162.69 30.9268 161.564 29.7764C158.804 26.9576 156.116 24.2123 153.199 21.7359C101.341 -22.5885 18.087 4.4387 3.05247 70.5806C-3.9843 99.6169 1.27904 130.846 17.4578 156.053C39.0789 189.793 90.9635 231.98 126.917 258.927C136.935 266.437 165 286 165 286C165 286 193.065 266.437 203.083 258.927Z' fill='black'/%3E%3C/svg%3E"); }
.sticker--blob   { --sheen-mask: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 330 253.688'%3E%3Cpath d='M93.4783 59.888C139.39 54.5035 154.137 48.8219 185.963 24.2516C233.222 -12.2226 303.725 -12.3878 323.886 57.3811C339.388 111.041 324.441 177.617 290.037 208.141C232.104 259.544 124.886 268.734 58.3346 229.078C0.959041 194.896 -17.4781 129.133 18.2975 86.276C30.4312 71.74 49.5035 65.044 93.4783 59.888Z' fill='black'/%3E%3C/svg%3E"); }
.sticker--blob2  { --sheen-mask: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 330 270.6'%3E%3Cpath d='M0.493824 175.919C-6.79738 111.062 67.0286 0 196.931 0C272.518 0 330 34.98 330 110.176C330 194.791 204.903 259.434 134.468 268.866C62.7623 278.468 8.6295 248.289 0.493824 175.919Z' fill='black'/%3E%3C/svg%3E"); }

/* ---- THE PEEL AND THE PRESS (2026-09-24, third pass) ----
   The user's second reference (Framer University's "3D Sticker Drag")
   shows two one-shot moments the tilt alone never gave, and the user saw
   "no movement at all" in the tilt-only version — which was also simply
   too weak: 700px perspective and a ~10deg lean foreshortened a 140px
   sticker by under 2%. Now 420px and a stronger gain in card.js.
     PICK-UP (`.is-peeling`, 320ms): the top edge tips BACK (`--peel`,
       added to the tilt's rotateX) as it lifts, and a band of light rolls
       down across it — a sticker being peeled off the paper.
     DROP (`.is-pressing`, 340ms): a diagonal band sweeps bottom-left to
       top-right while it presses back down to size.
   The bands are `.sticker__sweep`, NOT the tilt sheen: that element's
   opacity is the tilt's `--sho`, which is 0 at rest and would zero any
   child. Same silhouette mask, so the band never leaves the shape. */
.sticker__sweep {
  position: absolute;
  inset: 0;
  overflow: hidden;
  pointer-events: none;
  -webkit-mask: var(--sheen-mask) center / contain no-repeat;
  mask: var(--sheen-mask) center / contain no-repeat;
}
.sticker__sweep::before {
  content: "";
  position: absolute;
  inset: -60%;
  opacity: 0;
}
.sticker.is-peeling { animation: sticker-peel 320ms cubic-bezier(0.2, 0.7, 0.3, 1); }
@keyframes sticker-peel {
  0%   { --peel: 0deg; }
  40%  { --peel: 24deg; }
  100% { --peel: 0deg; }
}
/* SLOWED AND SOFTENED (2026-09-24, "a little too fast … needs to be
   smoother"): the bands were 320/340ms on a curve that started at speed,
   appeared at full strength on frame one and cut off at the end. Now
   ~2x as long on a symmetric ease-in-out, fading IN over the first fifth
   and OUT over the last, with wider, softer gradient stops. The PEEL's
   tip (`sticker-peel`, 320ms) is deliberately NOT slowed — only the light.
   So `.is-peeling` is cleared when the SWEEP ends, not the tip (card.js). */
.sticker.is-peeling .sticker__sweep::before {
  background: linear-gradient(180deg, transparent 36%, rgba(0, 0, 0, 0.08) 45%,
              rgba(255, 255, 255, 0.40) 51%, transparent 62%);
  animation: sticker-sweep-down 650ms cubic-bezier(0.45, 0, 0.55, 1) forwards;
}
@keyframes sticker-sweep-down {
  0%   { opacity: 0; transform: translateY(-38%); }
  20%  { opacity: 1; }
  80%  { opacity: 1; }
  100% { opacity: 0; transform: translateY(38%); }
}
.sticker.is-pressing .sticker__sweep::before {
  background: linear-gradient(45deg, transparent 36%, rgba(0, 0, 0, 0.08) 45%,
              rgba(255, 255, 255, 0.40) 51%, transparent 62%);
  animation: sticker-sweep-diag 700ms cubic-bezier(0.45, 0, 0.55, 1) forwards;
}
@keyframes sticker-sweep-diag {
  0%   { opacity: 0; transform: translate(-30%, 30%); }
  20%  { opacity: 1; }
  80%  { opacity: 1; }
  100% { opacity: 0; transform: translate(30%, -30%); }
}
@media (prefers-reduced-motion: reduce) {
  .sticker.is-peeling { animation: none; }
  .sticker.is-peeling .sticker__sweep::before,
  .sticker.is-pressing .sticker__sweep::before { animation: none; }
}

.sticker.is-dragging { --lift: 1.06; }
.sticker.is-dragging .sticker__art { filter: drop-shadow(0 10px 14px rgba(0, 0, 0, 0.32)); }
/* While carried and while settling, `transform` is NOT transitioned — the
   tilt is written every frame and a transition would make it lag behind
   the pointer. Only the lift eases, and `transform` follows it because
   `--lift` is registered. */
.sticker.is-settling { transition: --lift 240ms ease; }

.sticker.is-dragging {
  cursor: grabbing;
  /* It must track the pointer with no lag — only the registered `--lift`
     eases (see "THE TILT" above). */
  transition: --lift 200ms ease;
  z-index: 3;
}

/* Tapped open: big enough to read regardless of the shrink every other
   sticker on a busy board is under. Scale rather than a width/height change
   so the same transform this element already carries (drag position +
   fixed tilt) keeps composing instead of fighting a second animated
   property — the collision invariants 28/30/38 all warn about. */
.sticker.is-open {
  /* Opens to 252px on screen whatever the board has shrunk it to — left at
     the same absolute target when the closed size grew to 180px, so the
     ratio dropped to 1.4x rather than the old 1.8x. What makes the WHOLE
     comment fit is not the scale (a transform scales the text with the box,
     so the ratio never changes) but `.sticker__words` dropping to a smaller
     type and losing its clamp inside the same box; the scale then brings it
     back up to readable. */
  --open-scale: calc(252px / (180px * var(--sticker-scale, 1)));
  z-index: 4;
  cursor: pointer;
}

.sticker__text {
  /* ABSOLUTELY POSITIONED, not a flex child being centred by its parent —
     that was the first version, and it could not be made to work. With
     `.sticker` as a flex container, `.sticker__text` as its item and
     `width: 100%` meant to set the flex-basis, the browser still measured
     it at a few px wide (5.67, then 8.57 for different text — both
     verified with `getComputedStyle`, not guessed at) with every character
     of the comment squeezed into an invisible sliver. `display: -webkit-box`
     for line-clamping was the first suspect and was removed with no change
     to the number, so the flex-basis collapse was never actually about the
     clamp. Rather than keep chasing a flex-sizing bug on a decorative
     shape, the text is now positioned in its OWN box, inset from the
     sticker's edge by the padding `.sticker` used to carry — which sidesteps
     the flex algorithm entirely, the same way `.sticker__art` (formerly
     `.sticker__heart-bg`) already does for the glyph. */
  position: absolute;
  inset: 14%;
  /* `margin: 0` IS LOAD-BEARING. This is a <p>, and the browser's default
     1em margin top and bottom sat INSIDE the inset: measured, the box was
     69px tall instead of 101, which is most of why sticker text was being
     cut off. */
  margin: 0;
  text-align: center;
  font-weight: 600;
  overflow-wrap: anywhere;
  /* A backstop only — `.sticker__words` clamps itself with an ellipsis, so
     nothing should ever reach this edge. */
  overflow: hidden;
}

/* THE WORDS, CLAMPED WITH AN ELLIPSIS (2026-09-24). A separate span because
   `-webkit-line-clamp` needs its own `display: -webkit-box`. IT IS CENTRED
   BY POSITION, NOT BY FLEX, AND MUST STAY THAT WAY: as a flex item Chrome
   blockified the -webkit-box to `flow-root` (measured), which silently
   switches the clamp off — no ellipsis, and the overflow split above and
   below. Absolute positioning keeps it a -webkit-box. Type scales with
   `--sticker-scale` so the clamp holds at any shrink — before this the box
   shrank and the 12px text did not, so a busy board hid ever more of every
   comment.
   **THE CLAMP IS 2 LINES FOR EVERY SHAPE, NOT PER-SHAPE (2026-09-24, was
   5/4/3/2).** It used to be fitted to each shape's own capacity — the
   rectangle held 5 lines, the blobs only 2 — and the user saw that
   inconsistency on screen and asked for one uniform rule instead: two
   lines, then an ellipsis, on every shape. The sticker grew to 180px in the
   same change so two lines still has room to breathe inside the smaller
   shapes.
   OPEN, the clamp comes off and the type steps DOWN to 11/13 inside the
   same box — enough for the full 60-character comment — and `--open-scale`
   (now 1.4x, see `.sticker.is-open`) carries it back up to readable size.
   Scaling alone could never fit more text: it enlarges box and words
   together. */
.sticker__words {
  position: absolute;
  left: 0;
  right: 0;
  top: 50%;
  transform: translateY(-50%);
  display: -webkit-box;
  -webkit-box-orient: vertical;
  -webkit-line-clamp: 2;
  line-clamp: 2;
  max-width: 100%;
  overflow: hidden;
  font-size: calc(14px * var(--sticker-scale, 1));
  line-height: calc(18px * var(--sticker-scale, 1));
}
/* EACH SHAPE'S TEXT BOX IS FITTED TO ITS OWN COLOURED AREA (2026-09-24).
   `inset: 14%` is a square inside the sticker's square FRAME, and only the
   rectangle fills its frame — on the Figma shapes the lines ran onto the
   white edge and out (the user's report, on a blob). These insets are the
   largest rectangle that fits inside each shape's `currentColor` fill,
   MEASURED by rasterising the sprite symbol and scanning it, plus 6px of
   breathing room — not estimated; being percentages, they scale automatically
   with the sticker's own size. At the original 140px that was:
     rectangle ~92 x 90   circle ~77 x 78
     heart     ~78 x 57   blob   ~80 x 44   blob 2 ~66 x 51
   So "a 100 x 100 inside" is true of the rectangle only. These capacities are
   why the closed clamp used to differ per shape (5/4/3/2 lines) before it was
   made uniform at 2 (see `.sticker__words`) — the numbers above are kept for
   the geometry, not for the line counts, which no longer apply. If the art
   ever changes, RE-MEASURE; do not eyeball these.
   OPEN, each shape steps its type down just far enough for a full
   60-character comment in that same box, and `--open-scale` (now 1.4x)
   brings it back up: 11px -> ~15.4 on screen for rectangle and circle,
   9px -> ~12.6 for the heart, 8px -> ~11.2 for the blobs. */
.sticker--circle .sticker__text { inset: 21.9% 22.8% 22.2% 22.5%; }
.sticker--heart  .sticker__text { inset: 18.2% 22.5% 41% 22.2%; }
.sticker--blob   .sticker__text { inset: 38.9% 22.8% 30% 20%; }
.sticker--blob2  .sticker__text { inset: 29% 25.2% 34.4% 27.9%; }
/* Open, the breathing room drops from 6px to 2px (2.9% of 140) — measured:
   a 60-character comment of long unbreakable words needs 5 lines on the
   blob, and the 6px box held 4. Resting stickers keep the full 6px. */
.sticker--rectangle.is-open .sticker__text { inset: 11.1%; }
.sticker--circle.is-open .sticker__text { inset: 19% 19.9% 19.3% 19.6%; }
.sticker--heart.is-open  .sticker__text { inset: 15.3% 19.6% 38.1% 19.3%; }
.sticker--blob.is-open   .sticker__text { inset: 36% 19.9% 27.1% 17.1%; }
.sticker--blob2.is-open  .sticker__text { inset: 26.1% 22.3% 31.5% 25%; }

/* No per-shape closed-clamp overrides any more — `.sticker__words`'s base
   `-webkit-line-clamp: 2` now applies to every shape uniformly. */
.sticker.is-open .sticker__words {
  -webkit-line-clamp: unset;
  line-clamp: none;
  font-size: calc(11px * var(--sticker-scale, 1));
  line-height: calc(13px * var(--sticker-scale, 1));
}
.sticker--heart.is-open .sticker__words {
  font-size: calc(9px * var(--sticker-scale, 1));
  line-height: calc(10.5px * var(--sticker-scale, 1));
}
.sticker--blob.is-open .sticker__words,
.sticker--blob2.is-open .sticker__words {
  font-size: calc(8px * var(--sticker-scale, 1));
  line-height: calc(9.5px * var(--sticker-scale, 1));
}

/* Shown only on the sticker that belongs to you, or on every sticker when
   the open note is one of your own drops (Q3 of the design conversation —
   the person who dropped a note may moderate their own board). card.js
   toggles this with a class rather than a hidden attribute so it can stay
   out of the tab order until the sticker is open — a 20px delete target
   sitting on a 60px sticker at all times would be too easy to hit by
   mistake while dragging. */
.sticker__delete {
  display: none;
  position: absolute;
  top: -6px;
  right: -6px;
  width: 24px;
  height: 24px;
  border: none;
  border-radius: 50%;
  background: #1a1a1a;
  color: #fafafa;
  align-items: center;
  justify-content: center;
  cursor: pointer;
  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.4);
}

.sticker.is-open.can-delete .sticker__delete { display: flex; }
.sticker__delete:focus-visible { outline: 2px solid var(--fg); outline-offset: 2px; }

/* THE FOCUS RING FOLLOWS THE STICKER'S SHAPE, NOT ITS BOX (2026-09-24).
   `.sticker` is a focusable button (tabindex 0), and with no rule of ours
   the browser drew its default `outline: auto` — orange and white — round
   the element's invisible 140px SQUARE, whatever the shape inside. A click
   can trip it too: after typing in the composer the browser may still
   treat the next focus as keyboard focus. The user saw it on a blob and
   read it as the whole area selecting.
   So the default outline is switched off on `:focus`, and `:focus-visible`
   gets a ring traced round the ART instead: four hard drop-shadows, one
   nudged each way, build a 2px line in the sleeve's ink that follows the
   silhouette exactly — a CSS outline can only ever be a rectangle.
   NEVER just delete the ring: a keyboard user needs it to see which sticker
   they are on (WCAG 2.4.7). Only its shape changed. */
.sticker:focus { outline: none; }
.sticker:focus-visible .sticker__art {
  filter:
    drop-shadow(2px 0 0 var(--sleeve-ink))
    drop-shadow(-2px 0 0 var(--sleeve-ink))
    drop-shadow(0 2px 0 var(--sleeve-ink))
    drop-shadow(0 -2px 0 var(--sleeve-ink))
    drop-shadow(0 2px 4px rgba(0, 0, 0, 0.32));
}

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

/* --- submit --- */

/* `.drop__username-submit` (the one-time username step's "Continue" button,
   2026-09-25) shares this exactly — same primary action, same weight in the
   panel. It is NOT named `.drop__submit` itself, because drop.js binds that
   class with a bare `querySelector` assuming one match; being first in the
   DOM (the username step precedes the form), it would otherwise steal the
   real submit button's binding. */
.drop__submit,
.drop__username-submit {
  height: 54px;
  margin-top: 16px;
  border: none;
  border-radius: 16px;
  /* The same primary as "Locate me" on the landing screen — one CTA colour for
     the one action the whole app is for. Black on it measures 13.94:1, which is
     also what the landing button measures. (It was white on #f1472f, which was
     3.70:1 and failed: 18px/600 is not WCAG "large text" — that needs 24px, or
     18.66px at weight 700 — so it owes the full 4.5:1.) */
  background: var(--cta);
  color: #000000;
  font: inherit;
  font-size: 18px;
  font-weight: 600;
  cursor: pointer;
  transition: background-color 200ms ease;
}

.drop__submit:disabled,
.drop__username-submit:disabled {
  background: #2a2a2a;
  color: rgba(255, 255, 255, 0.3);
  cursor: not-allowed;
}

.drop__submit:focus-visible,
.drop__username-submit:focus-visible { outline: 2px solid var(--fg); outline-offset: 4px; }

/* Pushed to the bottom of the username step (2026-09-25), not left where the
   content ends — reported directly: a lot of dead space sat under it on the
   phone sheet, and a primary mobile CTA belongs where a thumb already rests
   anyway. `margin-top: auto` claims whatever space `.drop__username`'s
   `min-height: 100%` opened up above; the column's own `gap: 24px` still
   holds as the FLOOR once the help text grows past a couple of lines.
   Placed AFTER the shared rule above on purpose — same specificity, so
   source order is what lets this win over that rule's `margin-top: 16px`. */
.drop__username-submit { margin-top: auto; }

/* --- the location circle is a control now --- */

/* The whole marker opens the uploader — ring and centre note alike. */
.map-me,
.map-me__halo,
.map-me__dot { cursor: pointer; }
.map-me__halo:focus-visible { outline: 2px solid var(--fg); outline-offset: 4px; }

/* Reduced motion: the pulse stops entirely and the element is taken to zero,
   leaving the STATIC ring — which is the real boundary anyway, since the fill
   is only 0.10. Nothing about the circle's legibility depends on the motion,
   so there is nothing to compensate for here.

   A CSS rule is sufficient for this one, unlike the map pins' hover spin: that
   coast is a JS-driven transition CSS cannot suppress (invariant 28), whereas
   this is a pure CSS animation and the media query ends it outright. */
@media (prefers-reduced-motion: reduce) {
  .map-me__pulse { animation: none; opacity: 0; }
}

/* Notes sit above the circle so one inside it still takes its own tap, rather
   than being swallowed by a 300px disc.
   LIVE NOTES SIT ABOVE PAST ONES (2026-10-09, asked for): past notes are added
   to the map after live ones, so by DOM order alone they painted on top and
   hid the live notes they overlapped. Three layers now: circle 1, past notes
   2, live notes 3. A past note keeps its own tap wherever it is not under a
   live one, and still sits above the circle. A keyboard-focused past note
   comes to the front so the one being chosen is never hidden. */
.map-pin { z-index: 3; }
.map-pin[data-status="old"] { z-index: 2; }
.map-pin[data-status="old"]:focus-visible { z-index: 4; }
.map-me { z-index: 1; }

/* --- how long a note has left --- */

.card__expiry { display: flex; align-items: center; gap: 8px; }
/* It inherits rgba(255,255,255,0.5) from .card__poster, so the extra 0.45
   multiplied out to an effective 0.225 alpha = 2.09:1. At 12px on #262626
   there is no headroom to dim a separator further and stay legible, so it
   simply matches its row (4.89:1). Do not reintroduce the dimming. */
.card__expiry-sep { opacity: 1; }
.card__expiry-text { font-variant-numeric: tabular-nums; }
/* The countdown, not the pin art. #eab308 measures 7.89:1 on the #262626 card
   and is fine; #dc2626 measured 3.13:1 and failed — on the very state that most
   needs reading, "expiring soon". #f87171 is the same red family one step
   lighter and measures 5.47:1. The pin ART keeps its original colours: those
   are graphics, not text, and the card states the time in words as well, so
   colour is never the only carrier (WCAG 1.4.1). */
.card__expiry[data-band="yellow"] .card__expiry-text { color: #eab308; }
.card__expiry[data-band="red"] .card__expiry-text { color: #f87171; }
/* A past note says when it was shared, in the row's own grey. */
.card__expiry[data-band="old"] .card__expiry-text { color: inherit; }

@media (prefers-reduced-motion: reduce) {
  .drop { transition: opacity 1ms linear, visibility 0s; transform: none; }
}

@media (min-width: 861px) {
  .drop {
    top: 0;
    right: auto;
    width: var(--panel-w);
    max-height: none;
    height: 100%;
    border-radius: 0;
    box-shadow: 0 0 40px rgba(0, 0, 0, 0.5);
    transform: translateX(-16px);
  }

  .drop--in { transform: none; }

  /* Reversed with the card's, above: the drop form dims the map too. */

  .map-view--drop .map-nav { transform: translateX(calc(var(--panel-w) / 2)); }
}

@media (max-width: 640px) {
  .drop__head { padding: 16px; }
  /* Tighter than the desktop 24/40: 16px between fields, and 8px on top of that
     gap for the CTA to make 24px. */
  .drop__body { padding: 16px; gap: 16px; }
  .drop__submit { margin-top: 8px; }
  .drop__textarea { min-height: 80px; }
  /* Touch: a taller pill, a bigger x, and a 44px-tall target — still asymmetric
     so it never eats into the label. */
  /* The two padding rules that were here are gone: the base is 8px 12px now
     (4pt grid), so they were restating it. Only the custom chip's reserve and
     the delete button's size still differ at this breakpoint. */
  .drop__genre--custom { padding-right: 40px; }
  .drop__genre--custom[aria-pressed="true"] { padding-right: 39px; }
  .drop__genre-del { width: 24px; height: 24px; right: 6px; }
  .drop__genre-del::before { inset: -10px -6px -10px -5px; }
}

/* ==========================================================================
   The record (2026-09-16)
   ==========================================================================
   The card and the drop form used to be a flat 400px rail. They are now a
   vinyl record: the disc's centre sits off-screen to the LEFT and a little
   under half of it reads into the map, with every field and the video sitting
   on top of it.

   The geometry is arithmetic, not taste, and it is the thing to understand
   before retuning any of it. A disc that shows 400px at its widest is a
   CRESCENT: it pinches to nothing at the top and bottom of the window. A 960px
   record centred 80px off-screen gives the full 400 at the vertical middle and
   only 97px at the top and bottom of an 892px window — and growing the disc
   does not rescue it, because keeping a 360px column on vinyl for 700px of
   height needs a disc ~7,600px across, at which point the arc is a straight
   line and it is not a record any more.

   So the record cannot be the only ground. `--vinyl-size` is deliberately
   larger than the viewport (115vh, floor 900px) so the rim is cut by the top
   and bottom edges rather than floating, and `.vinyl__veil` carries the two
   corners the disc cannot reach. THE VEIL IS LOAD-BEARING FOR CONTRAST, not
   decoration: without it the top and bottom fields sit on a light basemap.
   See invariant 12 — measure against the rendered composite, never the token.

   At 1316x892 this resolves to a 1025.8px disc centred at x = -112.9, which is
   what puts ~56px of the cream label at the left edge. Change `--vinyl-size`
   and the label walks off screen. */

/* THE PANEL DOES NOT CLIP AND DOES NOT SCROLL. Both moved to `.card__scroll` /
   `.drop__scroll`, and the reason is the animation: a panel that clips cuts the
   record into a rectangle, and at rest those cuts sit exactly on the viewport
   edges so nobody sees them. The moment the panel moves they come inboard.
   Measured on the reveal: a 56px flat gap along the BOTTOM at the start of the
   open, and at the overshoot a 46px inset on the LEFT and 5px at the TOP —
   three straight edges on something meant to be a round object. With the clip
   gone the disc is a plain unclipped circle, and the only edge that can ever
   appear is its own curve. Do not put `overflow` back on these. */
.card,
.drop {
  display: flex;
  flex-direction: column;
  overflow: visible;
}

.card__scroll,
.drop__scroll {
  flex: 1 1 auto;
  min-height: 0;
  width: 100%;
  overflow-y: auto;
  overflow-x: hidden;
  -webkit-overflow-scrolling: touch;
}

.vinyl {
  /* Absolute, not sticky: it is outside the scroll container now, so there is
     nothing to stay pinned against. `inset: 0` resolves against the panel's
     PADDING box, so it spans the full panel width whatever the rim inset is. */
  position: absolute;
  inset: 0;
  /* NEGATIVE, and that is the whole mechanism for putting content above the
     record. This used to be `z-index: 0` plus a
     `.card > *:not(.vinyl) { position: relative }` rule to lift the children —
     and that rule is (0,2,0), so it BEAT `.card__close`'s own (0,1,0)
     `position: absolute` and silently turned the close button into a relative,
     in-flow element. Its `right: 20px` then shifted it 20px to the LEFT of the
     card instead of pinning it to the right corner: measured at x = -20, half
     off the screen, with the video pushed 32px down behind it. The X was simply
     gone.

     A negative z-index needs no help from the children. Painting order inside a
     stacking context puts negative-z descendants ABOVE the element's own
     background but BELOW in-flow content, which is exactly the sandwich wanted
     — and it works on the phone too, where the sheet has an opaque background
     the disc must still sit on top of. Do not reintroduce a rule that sets
     `position` on every child; the panels contain absolutely positioned
     controls that own their own. */
  z-index: -1;
}

.vinyl__disc {
  position: absolute;
  pointer-events: none;
}

.vinyl__disc {
  width: var(--vinyl-size);
  height: var(--vinyl-size);
  border-radius: 50%;
  /* Top layer first: grooves, then the rotating sheen, then the vinyl itself.
     The GROOVES ARE CONCENTRIC, so they cannot show rotation on their own —
     the conic sheen is the only thing that makes the spin visible at all. */
  /* The two groove inks are variables so a breakpoint can retune their WEIGHT
     without restating the whole three-layer background — which is how the two
     would drift apart. The phone runs them softer; see the mobile block. */
  --groove-hi: rgba(255, 255, 255, 0.075);
  --groove-lo: rgba(0, 0, 0, 0.5);
  /* THE SHEEN IS THE ONLY THING THAT CAN SHOW ROTATION. The grooves are
     concentric, and a circle rotated about its own centre maps onto itself, so
     they are motionless by definition. It is a variable because desktop and the
     phone see completely different PARTS of this disc and need different
     sweeps. Two lobes, which is right when the whole disc is on screen and
     centred behind the content, as it is on a phone — more would read as a
     starburst rather than light glancing off a record.

     EACH LOBE HAS A PLATEAU, and that is deliberate. These used to be pure
     ramps (0 -> 0.075 over 34deg) and a grey ramp that gradual is not
     perceptible however far it travels; the disc rotated and nothing appeared
     to move. Edges are what the eye catches, so each lobe now rises over 20deg,
     HOLDS for 25, and falls over 25. Peaks lifted 0.075/0.058 -> 0.13/0.10. */
  --vinyl-sheen: conic-gradient(
    from 0deg at 50% 50%,
    rgba(255, 255, 255, 0) 0deg,
    rgba(255, 255, 255, 0.13) 20deg,
    rgba(255, 255, 255, 0.13) 45deg,
    rgba(255, 255, 255, 0) 70deg,
    rgba(255, 255, 255, 0) 175deg,
    rgba(255, 255, 255, 0.10) 195deg,
    rgba(255, 255, 255, 0.10) 220deg,
    rgba(255, 255, 255, 0) 245deg,
    rgba(255, 255, 255, 0) 360deg
  );
  background:
    repeating-radial-gradient(
      circle at 50% 50%,
      var(--groove-hi) 0px,
      var(--groove-hi) 0.5px,
      var(--groove-lo) 0.5px,
      var(--groove-lo) 1.6px,
      rgba(255, 255, 255, 0) 1.6px,
      rgba(255, 255, 255, 0) 4px
    ),
    var(--vinyl-sheen),
    radial-gradient(circle at 50% 50%, #1b1b1b 0%, #101010 56%, #050505 100%);
}

/* --- desktop needs a different sheen, and the reason is geometry ---
 *
 * The disc here is 300vh (2343px at 781 tall) with its centre far off-screen to
 * the LEFT, so the panel shows a narrow slice near the rim — measured, about 62
 * degrees of arc as seen from that centre. Two soft lobes 42 degrees wide cross
 * that window only about a third of the time and, at 0.058 alpha over #050505,
 * amount to 5 -> 19 out of 255 smeared across a thousand pixels.
 *
 * PROVEN INVISIBLE, not assumed: two screenshots 8s apart, the disc rotated
 * 101.5 degrees between them, a sheen lobe inside the window in one and absent
 * in the other — and the two frames were identical. The spin was running
 * perfectly and could not be seen. That is what "the vinyl isn't spinning"
 * actually was.
 *
 * So desktop gets MORE lobes, NARROWER and a little stronger. A 45 degree
 * period keeps one or two highlights inside that 62 degree window at all times
 * and crosses it every 3s at 24s a revolution — continuous movement rather than
 * an occasional pass — and the narrower band gives an edge the eye can catch.
 * The phone keeps the two-lobe version: the whole disc is on screen there,
 * centred behind the content, where eight lobes would read as a starburst. */
/* --- keeping the sheen off the controls (2026-09-17) ---
 *
 * The sheen was crossing the play button and the waveform and washing them out.
 * It cannot simply be "moved down the disc", and the reason is worth writing
 * down: the sheen rotates WITH the disc, so anything positioned in disc space
 * travels with it. The one quantity rotation preserves is RADIUS — and radius
 * does not separate these controls from the comment below them, because the
 * disc's centre is off to the LEFT, level with the panel's middle. Measured
 * from that centre, the transport spans r 706-1090 and the comment 688-1110:
 * the same band. A radial fade would dim both or neither.
 *
 * So the fade has to live in SCREEN space, which means on `.vinyl` — which does
 * not rotate — rather than on `.vinyl__disc`, which does. `::after` is enough:
 * it is later in paint order than the disc so it lands on top of it, and
 * `.vinyl`'s own `z-index: -1` still keeps the pair below the content.
 *
 * The stops are the panel's real geometry at 781px tall: the transport ends at
 * y=525 (67%) and the comment runs 541-632 (69-81%). The dimming holds to 67%
 * and is gone by 84%, so the sheen is suppressed over the controls, fades in
 * behind the comment — which the user explicitly allowed — and is unimpeded
 * across the bare record below it, which is where the rotation now reads.
 *
 * 0.55 and not more: the grooves are only a 22-level modulation over #050505 to
 * start with, and heavier dimming flattens the top of the panel to flat black.
 * Checked — at 0.55 they still show through the transport area. */
@media (min-width: 861px) {
  .vinyl::after {
    content: "";
    position: absolute;
    inset: 0;
    pointer-events: none;
    background: linear-gradient(
      to bottom,
      rgba(0, 0, 0, 0.55) 0%,
      rgba(0, 0, 0, 0.55) 67%,
      rgba(0, 0, 0, 0) 84%
    );
    /* CLIPPED TO THE RECORD, and it is not optional. `.vinyl` is a 520x781
       RECTANGLE, while the record inside it is a circle whose rim pulls away
       from the panel's right edge everywhere except the exact middle — 37px at
       y=100, 42px at y=700. The panel paints nothing out there by design, so an
       unclipped `::after` laid 55% black straight over the MAP in that sliver:
       a dark rectangle hanging off the record's curve, which is exactly what it
       looked like.
       Same centre and radius as `.vinyl__disc`, written from the same variables
       so the two cannot drift. This is the same fix, and the same reasoning, as
       the rim clip on `.drop__head`. */
    clip-path: circle(calc(var(--vinyl-size) / 2)
                      at calc(var(--panel-w) - var(--vinyl-size) / 2) 50vh);
  }
}


@media (min-width: 861px) {
  .vinyl__disc {
    /* THE EDGE MATTERS MORE THAN THE ALPHA. The first attempt at this ramped
       from 0 to 0.115 over 13deg, which at the panel's radius is a ~200px-wide
       smooth fade — a 30-level grey ramp that gradual is simply not perceptible,
       and two frames 22.5deg apart were still identical. Diagnosed by swapping
       the sheen for opaque red with a hard edge, which showed up instantly and
       proved the geometry was fine all along. So: a defined band, ramp 6deg,
       PLATEAU 6deg, fall 8deg, dark for the rest of the 45deg period. The
       plateau is what gives it edges to see.

       0.16 over the #050505 the disc reaches out here composites to about
       #2d2d2d. Note that still-frame comparison UNDERSTATES this badly: motion
       is far easier to detect than a static difference, so judge it playing,
       not from screenshots. */
    --vinyl-sheen: repeating-conic-gradient(
      from 0deg at 50% 50%,
      rgba(255, 255, 255, 0) 0deg,
      rgba(255, 255, 255, 0.16) 6deg,
      rgba(255, 255, 255, 0.16) 12deg,
      rgba(255, 255, 255, 0) 20deg,
      rgba(255, 255, 255, 0) 45deg
    );
  }
}

.vinyl__label {
  position: absolute;
  /* A 12" label is ~100mm on a 302mm disc. Holding the real ratio is what
     keeps it reading as a record rather than a dartboard. */
  left: 33.4%;
  top: 33.4%;
  width: 33.2%;
  height: 33.2%;
  border-radius: 50%;
  background:
    radial-gradient(circle at 38% 32%, #f0e8c8 0%, #e2d8b2 62%, #d3c79c 100%);
  box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.35);
}

.vinyl__spindle {
  position: absolute;
  left: 49.1%;
  top: 49.1%;
  width: 1.8%;
  height: 1.8%;
  border-radius: 50%;
  background: #060606;
}

/* --- the spin ---
 *
 * `--vinyl-spin-s` is the ONE number. A real record is 33 1/3 RPM, i.e. 1.8s a
 * revolution — unwatchable behind text at this size, because the disc fills the
 * whole panel on a phone and a point near its edge would travel 700px a second.
 * This was 48s (1.25 RPM) and is now 24s (2.5 RPM): asked for on 2026-09-17 to
 * "actually spin like a real vinyl would" while staying "very subtle as to not
 * disturb". At 24s a point 200px off centre moves 52px/s, which reads as
 * turning when you look at it and ignores easily when you do not.
 *
 * WHAT MAKES IT VISIBLE AT ALL is the conic sheen. The grooves are concentric,
 * so they cannot show rotation — delete the sheen and the disc turns
 * invisibly. On the phone the off-centre highlight on `.vinyl__label` used to
 * help too, and that label is hidden there now, so the sheen is the whole cue.
 *
 * IT IS DRIVEN BY ITS OWN CLASS, `card--spinning`, set on the TAP. Do not put
 * it back on `card--playing`: that is only set once the player reports PLAYING
 * or BUFFERING, and on a first play the IFrame API has to be fetched and the
 * player built first — seconds in which the user has tapped play and nothing
 * moves. Chaining `card--loading` alongside it does not fix that either, and
 * the trace is why: `onReady` removes `card--loading` before `card--playing`
 * arrives, so for ~300ms neither matches, the animation is REMOVED, and the
 * disc snaps back to 0deg before restarting. Measured 22.36deg, then 0, then a
 * 300ms stall. A record that jerks backwards is worse than one that never
 * turns. card.js owns the class and clears it on pause, end, error and close,
 * with a 6s grace timer for the case where playback is refused silently. */
@keyframes vinyl-spin {
  to { transform: rotate(360deg); }
}

@media (prefers-reduced-motion: no-preference) {
  .card {
    --vinyl-spin-s: 24s;
  }

  .card--spinning .vinyl__disc {
    animation: vinyl-spin var(--vinyl-spin-s) linear infinite;
  }
}

/* --- desktop: full height, and the right edge is the record's rim ---
 *
 * There is no rectangle and no veil: the panel box is still 400px wide so
 * invariant 15's arithmetic holds, but it paints nothing. All you see is the
 * disc, and the box outside the rim is transparent, so the map shows through
 * and the player's trailing edge is the record's curve.
 *
 * WHY THERE IS NO VEIL. The first attempt floated the disc on a dark veil
 * inside the old rectangle and the record was invisible: the disc renders
 * #1b1b1b -> #050505 and the veil composited to about #111 — the same darkness,
 * so there was nothing for the rim to be seen against. It needs the light
 * basemap. Never put a dark surface back behind it.
 *
 * FULL HEIGHT DECIDES THE DISC SIZE, and the relationship is fixed. With the
 * panel spanning the viewport, its corners sit half a viewport-height from the
 * disc's centre, so for a disc of diameter k*vh the rim pulls back from 400 by
 * `[(k/2) - sqrt(k^2/4 - 0.25)] * vh` at those corners — a constant FRACTION of
 * the height, which is the only reason this can be written in vh and stay right
 * at every window size.
 *
 *     diameter   inset    content @892   content @1200   layer
 *       200vh   0.134vh       280px           239px      13MB
 *       250vh   0.104vh       307px           275px      20MB
 *      *300vh*  0.086vh       323px           297px      29MB
 *       400vh   0.064vh       343px           324px      51MB
 *       600vh   0.042vh       363px           350px     115MB
 *
 * 300vh is the trade on disk: a 76px bulge at 892, which is a curve you can
 * actually see, against a content column of 323. A bigger disc buys back width
 * but flattens the edge toward a straight line and the layer grows as the
 * square. `padding-right` MUST equal the inset — it is what holds the form
 * inside the circle, and 8.6vh is 0.0858vh with a hair of safety. */
@media (min-width: 861px) {
  .card,
  .drop {
    --vinyl-size: 300vh;

    top: 0;
    height: 100%;
    max-height: none;
    border-radius: 0;
    background: transparent;
    /* A box-shadow here would draw a rectangle around an invisible box. The
       shadow belongs on the disc, where it follows the circle. */
    box-shadow: none;
    /* --- the roll ---
       The record arrives by rolling in from off-screen and rolls back out when
       it closes. What makes it read as ROLLING rather than sliding is that the
       rotation is locked to the travel: a wheel turns `distance / radius`
       radians, so 520px of travel against a 150vh radius is about 24 degrees.
       It is hardcoded because CSS cannot divide a length by a length — the true
       angle is 28deg at a 700px viewport and 17deg at 1200, exact at about 832.
       Nobody can measure the difference: the grooves are CONCENTRIC, so the
       only thing rotation actually shows is the sheen sweeping.

       The rotation uses the independent `rotate` property, NOT `transform`:
       `.card--playing` animates `transform` for the 48s spin and the two would
       overwrite each other. As separate properties they compose. */
    /* --- the vinyl reveal ---
       The panel springs in from the left on a single rigid transform and
       springs back out. ONLY `transform` is animated: translateX, translateY
       and rotate combined into one value on one curve, so it runs on the
       compositor. Nothing here touches clip-path, width/height, top/left or
       scale — those repaint every frame, which is what makes this kind of
       motion stutter.

       Because the two translations share one curve the panel travels
       diagonally, right and down together, which is what reads as popping in
       left-to-right while rolling in top-to-bottom. It is one rigid sweep, not
       a progressive reveal.

       `transform-origin` sits on the panel's own left edge just past centre, so
       the tilt reads as a hinge rather than a wide swing.

       NO OVERSHOOT, BY DECISION (2026-09-17). This was easeOutBack,
       `cubic-bezier(0.34, 1.56, 0.64, 1)`, and it overshot 9.78%. On a panel
       flush to the viewport edge that is not a flourish, it is a hole: watched
       and measured on 2026-09-17, the left edge swung to **+43.6px at 352ms**,
       59% of the way through, and `elementFromPoint` in that strip returned
       `.map-scrim` — dimmed MAP, for 359ms, down the full height of the screen.
       Gentler springs were measured on the live panel rather than guessed:
       1.35 gave 18.2px over 275ms, 1.2 gave 5.6px over 175ms. The user asked
       for no bounce at all, so this is easeOutQuint — a pure deceleration that
       never passes its resting place.
       **Any curve whose second control point's y exceeds 1 overshoots**, and on
       this panel every pixel of overshoot is a pixel of map. Keep y <= 1.
       (The variables used to be named `--spring-*`. Nothing springs any more,
       and the name outlived the motion by one design decision.) */
    --panel-in-ms: 600ms;
    --panel-in-ease: cubic-bezier(0.22, 1, 0.36, 1);       /* easeOutQuint */
    --panel-out-ms: 400ms;
    --panel-out-ease: cubic-bezier(0.4, 0, 1, 1);          /* decisive, no bounce */

    /* No fade here. It rolls in from outside the screen, so there is nothing to
       fade from — and a panel that fades WHILE it travels reads as an overlay
       appearing rather than an object arriving. */
    opacity: 1;
    transform-origin: 0% 55%;
    /* On the animated element ONLY — never an ancestor. */
    will-change: transform;
    transform: translate(-91%, -7%) rotate(-4.5deg);
    /* This rule is the state it returns TO, so its timing is the CLOSE. */
    transition: transform var(--panel-out-ms) var(--panel-out-ease),
                visibility 0s linear var(--panel-out-ms);

    /* The one thing holding content inside the rim, and it has to be PADDING ON
       THE PANEL rather than a max-width on the children: a max-width caps an
       element's width but not where it ends, so `.card__media` — which carries a
       16px left margin — still finished 16px past the rim.

       One name, two uses: the well adds it back so the disc is not clipped at
       the content edge. Change it in one place. */
    --rim-inset: 8.6vh;
    padding-right: var(--rim-inset);
  }

  .card--in,
  .drop--in {
    transform: translate(0%, 0%) rotate(0deg);
    transition: transform var(--panel-in-ms) var(--panel-in-ease), visibility 0s;
  }

  /* THE SLEEVE SLIDES STRAIGHT OUT (2026-09-24, the user's call). Closing
     on the sleeve face must not do the record's exit — up, and tipped
     -4.5deg round the rim — because a sleeve is a flat square, not a
     wheel. It goes straight left, fully off screen, on the same 400ms
     close curve. `:not(.card--in)` so it applies only to the CLOSED state
     and never outranks `.card--in` while open. card.js (`open()`) resets
     the face with transitions off, so the next record still rolls in from
     its own starting point. */
  .card--sleeve:not(.card--in) { transform: translate(-101%, 0%); }

  /* Rolling right on the way in, so the disc is wound BACK while it waits and
     unwinds to zero as it travels — a wheel moving right turns clockwise. */
  /* The disc carries NO rotation of its own. An earlier version rolled it
     against the panel's travel; the panel's own tilt supersedes that, and two
     rotations on one object fight each other. `.card--playing`'s 48s spin still
     animates the disc's `transform` and is untouched. */

  /* The record has no straight edge to hang a scrollbar on: the track would
     float off the rim and over the map wherever the disc has curved away.
     Wheel, trackpad, touch and keys all still scroll. */
  /* The header rides ABOVE the scrim here, so it stays lit and clickable while
     everything else dims. The nav slides clear of the panel precisely so it
     "stays reachable" — letting a z-index 4 scrim swallow its clicks would make
     that slide pointless, and Discover, search and the clock would be dead for
     as long as a panel is open. The phone layout does dim them, because there
     the sheet covers the screen and there is nowhere for them to be.
     To dim the controls as well, delete this block. */
  /* One element to lift now that the chip rides inside the bar. */
  .map-view--card .map-nav,
  .map-view--drop .map-nav { z-index: 7; }

  .card__scroll,
  .drop__scroll { scrollbar-width: none; }
  .card__scroll::-webkit-scrollbar,
  .drop__scroll::-webkit-scrollbar { width: 0; height: 0; }

  .vinyl__disc {
    /* Centre pinned so the rim touches 400 at mid-height; vertically centred on
       the viewport, which is the panel's own height here. */
    left: calc(var(--panel-w) - var(--vinyl-size));
    top: calc(50vh - var(--vinyl-size) / 2);
    /* INSET ONLY. An outer drop shadow here reads as a dark straight-edged
       rectangle in the panel's corners, and it is not a mistake in the shadow —
       it was the shadow being CLIPPED, back when a wrapper with `overflow:
       hidden` sliced the halo along straight edges. Nothing clips the disc any
       more, so the halo would no longer be cut — but it still has no job: the
       scrim behind the record is what separates it from the map, and a shadow
       on a 2,676px circle is a very large blur to composite for nothing.

       There is nothing to soften anyway — the record has the scrim behind it
       now, which is what separates it from the map. */
    box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.07);
  }

  /* The rim pulls in at the top of the panel, so a control pinned to the panel
     box's own corner lands OUTSIDE the record and floats over the dimmed map:
     `right: 20px` puts its edge at 500 against a rim of 455.6 at that height.
     Insetting it by the rim's own inset puts it 20px inside the record's edge,
     which is where `.drop__close` already sits — that one is inside
     `.drop__head`, so the panel's padding carries it in automatically. */
  .card__close { right: calc(var(--rim-inset) + 20px); }

  /* SUPERSEDED (2026-09-24): `.card__close` no longer resets to a flat
     `right: 20px` on the sleeve face — it isn't the sleeve's button any
     more at all. `.sleeve__close` (styles.css, unscoped) carries its own
     permanent flat 20px, since the sleeve never has a rim to clear on any
     breakpoint. `.card__close` now always uses the offset above, on both
     faces — the sleeve simply covers it once it slides across, the same
     way it covers the rest of the record. */

  /* THE HEADER IS OPAQUE AGAIN (2026-09-17), and the round trip is the point.
     It was `var(--bg)` so the header could occlude fields sliding under it. On
     2026-09-16 that was removed by request — the bar read as a slab laid across
     the vinyl. But the header is sticky and `.drop__scroll` is the scroll
     container, so with nothing behind it the fields did not slide UNDER the
     title, they passed THROUGH it: seen on screen 2026-09-17 with the form
     scrolled to its end, the display-face title sitting directly on the URL
     field's fine print and the input, both illegible where they crossed. 216px
     of travel past a 73px header.

     So the fill is back, by decision, with the collision shown first. The thing
     that was NOT obvious and is why this works: `--bg` is `#0d0d0d` and the
     record's surface under the header is near-black too, so the slab does not
     read as a slab — checked at the top of the scroll, where a mismatch would
     show most, and there is no visible edge. The `border-bottom` stays and is
     now the deliberate divider rather than the only one.

     It cannot overflow onto the map: the header's right edge measures exactly
     the panel's content edge (453px at 520 wide), and `elementFromPoint` just
     outside it returns `.vinyl`, not the map — that is `padding-right:
     var(--rim-inset)` doing its job.

     If it ever needs to be lighter, a gradient fading out over the last ~16px
     is the way, NOT transparency: transparency is what this replaced. */
  .drop__head {
    background: var(--bg);
    /* REACH THE RIM. The panel's `padding-right: var(--rim-inset)` stops every
       child at the content edge (453px at 520 wide), but the record's rim is a
       circle: it touches 453 only at the panel's very top corner and bulges to
       ~476 by the header's bottom edge, 73px down. A rectangle stopping at 453
       therefore leaves a widening crescent of bare vinyl beside the fill.

       So the header steps back OUT over the padding with a negative margin, and
       is then clipped to the disc's own circle — same centre, same radius, both
       written from the same variables the disc itself uses, so the two cannot
       drift. `clip-path` rather than a rounded corner because the curve is the
       disc's, not an approximation of it, and because it clips the
       `border-bottom` too: a border is not background, so a gradient would have
       let that 1px line run out over the map.

       The padding gains the same inset back, which is what keeps `.drop__close`
       exactly where it was — its right edge measures 433px either way, matching
       `.card__close`'s `right: calc(var(--rim-inset) + 20px)`. */
    margin-right: calc(var(--rim-inset) * -1);
    padding-right: calc(20px + var(--rim-inset));
    clip-path: circle(calc(var(--vinyl-size) / 2)
                      at calc(var(--panel-w) - var(--vinyl-size) / 2) 50vh);
  }
}

@media (max-width: 860px) and (prefers-reduced-motion: reduce) {
  .card,
  .drop { transition: transform 200ms linear, visibility 0s linear 200ms; }

  .card--in,
  .drop--in { transition: transform 200ms linear, visibility 0s; }
}

/* Rolling a 2,676px record across the screen is exactly what
   `prefers-reduced-motion` exists for. No travel and no rotation here — the
   panel just fades, which is what it did before the record existed. */
@media (min-width: 861px) and (prefers-reduced-motion: reduce) {
  /* Same end states, no rotation and no overshoot — a quick snap rather than a
     spring. The translate stays so the panel still arrives from its own side
     instead of materialising in place. */
  .card,
  .drop {
    transform: translate(-91%, -7%);
    transition: transform 200ms linear, visibility 0s linear 200ms;
  }

  .card--in,
  .drop--in {
    transform: translate(0%, 0%);
    transition: transform 200ms linear, visibility 0s;
  }

  .card--sleeve:not(.card--in) { transform: translate(-101%, 0%); }
}

/* --- mobile: the disc rises from the bottom edge --- */
@media (max-width: 860px) {
  .card,
  .drop {
    /* THE DISC IS THE PANEL NOW (2026-09-17). It used to be
       `max(150vw, 88vh)` sitting at `top: 104px`, which made it an object
       rising from below — and that read stopped making sense once the sheet's
       own top became a record's edge. Worse, it showed: the disc only reached
       the sheet's full width 53px below its crest, so the grooves visibly
       "stopped halfway towards the top" and the panel's top third was bare.

       So the disc is sized and placed to COINCIDE with the clip circle: same
       centre, radius 4px larger. Everything the clip lets you see is disc, edge
       to edge, and the domed top is both the panel's edge and the record's.
       The 4px is deliberate — exactly coincident circles leave an antialiased
       seam where the two edges meet, so the disc is grown just past the clip
       and `top: -4px` puts the centre back where it was. */
    --vinyl-size: calc(var(--sheet-dome-r) * 2 + 8px);

    /* A DEFINITE height, not `max-height`, so the sheet is always 88% and the
       record fills whatever the content does not. The cost is that a short card
       no longer hugs its content on a phone.

       And it runs 100px BELOW the viewport, with matching padding so no content
       falls into the bleed. Without that, the spring's overshoot lifts the sheet
       about 70px off the bottom of the screen at the top of its travel and
       exposes its own flat bottom edge — the one straight edge this reveal is
       not allowed to show. 100px covers a 9.78% overshoot of an 88vh sheet with
       room to spare. The desktop panel needs no equivalent: it paints nothing
       itself, so it has no edges to expose. */
    /* ONE VARIABLE, because the height is written twice and the two must not
       drift. It was 88%, which put the dome's crest at y=97 against a header
       ending at 72 — a 25px gap at the centre, and the crest is the closest
       point, so that is the one you see. 80% drops the crest to 162 and opens
       that to 90px, about the height of the header itself.
       Note the gap is NOT one number: the top is a curve, so at the corners it
       is a further 40.9px down (the dome's own depth). At 80% that is 25 -> 90
       at the centre and 66 -> 131 at the sides. */
    --sheet-h: 80%;
    height: calc(var(--sheet-h) + 100px);
    /* The base rule caps these at `max-height: 88%`, which silently ate the
       bleed and cost the sheet 100px of VISIBLE height — measured, its top
       dropped from 97 to 197. The cap has to grow with it. */
    max-height: calc(var(--sheet-h) + 100px);
    bottom: -100px;
    padding-bottom: 100px;
  }

  .vinyl__disc {
    left: calc(50% - var(--vinyl-size) / 2);
    /* -4, not 0: it cancels the 4px the diameter gained above, so the disc's
       centre still lands on the clip circle's centre (50%, var(--sheet-dome-r))
       while its radius stays 4px outside it. */
    top: -4px;

    /* SOFTER ON THE PHONE. The grooves now cover the whole panel rather than
       its lower two-thirds, and they sit under every label, field and chip — at
       the desktop weight that is a texture competing with text across the entire
       surface. Roughly halved: highlight 0.075 -> 0.04, line 0.5 -> 0.26. The
       ring SPACING is untouched at 4px, so they still read as vinyl at this
       size; only the ink is lighter. */
    --groove-hi: rgba(255, 255, 255, 0.04);
    --groove-lo: rgba(0, 0, 0, 0.26);
  }

  /* --- the sheet's top IS the record's edge (2026-09-17) ---
   *
   * Asked for: a top rounded to mimic the vinyl, no coloured centre because it
   * made the form unreadable, and then — of the first attempt — "make the top
   * edges smoother, they currently drop off at a strange angle."
   *
   * THAT IS WHY THIS IS A CLIP-PATH AND NOT A BORDER-RADIUS, and the reason is
   * measurable. The first version was `border-radius: 50% 50% 0 0 / 14vw`,
   * which is an ELLIPSE with rx 187.5 and ry 52.5 — and an ellipse does not
   * have one curvature, it has a range. Radius of curvature at the crest (end
   * of the minor axis) is `a²/b` = 670px; at the sides (end of the major axis)
   * it is `b²/a` = **14.7px**. A 45x swing: nearly flat across the middle, then
   * a tight kink at each edge. That kink is the strange angle.
   *
   * A record's edge is a CIRCLE — one constant radius the whole way — and
   * `border-radius` cannot draw a shallow circular arc: asking for rx = ry = R
   * makes the browser clamp both to half the width, which is a semicircle
   * 187.5px deep. So the shape comes from `clip-path` instead.
   *
   * WHY 120vw, and why not the disc's own radius. The circle has to contain the
   * whole sheet except the top corners, or it eats the bottom ones too. With a
   * half-width of 50vw and a sheet height h that needs
   * `R >= (50vw² + h²) / 2h` — 429px at 375x812. The disc's own radius is 357,
   * which is SMALLER than that, so clipping to the real record would cut the
   * bottom off the sheet. 120vw (450px at 375) clears the bound at every phone
   * tried and gives a 10.91vw dome: `120 - sqrt(120² - 50²)`, 40.9px at 375.
   * Shallower than the record's own 53.2, and uniformly curved, which is the
   * trade the "smoother" note asked for.
   *
   * The clip also does the header's corners for free — clip-path clips every
   * descendant, unlike a radius, which is why `.drop__head` no longer needs a
   * radius of its own. It clips the `box-shadow` away too; on a phone that sat
   * over a scrimmed map and was doing nothing.
   */
  .card,
  .drop {
    --sheet-dome-r: 120vw;
  }

  .drop { clip-path: circle(var(--sheet-dome-r) at 50% var(--sheet-dome-r)); }

  /* ON `.card` SPECIFICALLY, THE CLIP LIVES ON THE RECORD'S OWN PIECES, NOT
     ON THE PANEL (2026-09-25, fixing a bug reported directly: "the top of
     the vinyl record itself changes shape" when the comment sleeve opens).
     This clip-path used to sit on `.card` itself, same as `.drop`, and
     `.card--sleeve { clip-path: none }` (see the history below) switched it
     off whenever the sleeve was showing — but `.card` is the SHARED parent
     of both faces, so turning its clip off to keep the sleeve flat also
     un-clipped `.vinyl` and `.card__scroll` underneath it, at the exact
     moment the sleeve's class toggled. The record's own dome popped square
     right as the cover started sliding, then rounded again on close — the
     bug was never about the sleeve, it was the RECORD losing its shape as a
     side effect of the mechanism meant to give the sleeve its own.
     Fixed by moving the clip onto exactly the two elements that need a
     domed edge — `.vinyl` (crops its own 4px-oversized disc down to the
     true radius, invariant 26) and `.card__scroll` (cuts its square content
     corners into the curve) — so the record is clipped UNCONDITIONALLY, the
     same shape whether or not a sleeve exists at all. `.card__close` is
     deliberately left out: it was swept along for the ride before, but at
     its resting `top: 44px` it already clears the curve on its own (that's
     why 44 was chosen over 20 — see the note on it below), and its own
     `inset(50%)`/`:focus-visible` clip-paths further down this file would
     have overridden anything added here regardless.
     `.card .vinyl` is scoped — `.drop` has its own `.vinyl` too (invariant
     26), already correctly clipped by `.drop`'s own rule above, and an
     unscoped selector would apply this a second, redundant time to it.
     `.card__scroll` needs no scoping; nothing else uses that name. Both
     read `--sheet-dome-r` as an inherited custom property from `.card`,
     unchanged from before — only which element's OWN box the circle is
     measured against moved, and since `.card` carries no padding on this
     breakpoint (that's a desktop-only rim-inset thing, invariant 26), both
     elements' boxes still coincide exactly with `.card`'s own, so the
     circle lands in the identical place it always did. */
  .card .vinyl,
  .card__scroll {
    clip-path: circle(var(--sheet-dome-r) at 50% var(--sheet-dome-r));
  }

  /* `.card`'S OWN BACKGROUND HAS TO GO TOO, AND THIS IS WHY (reported
     directly, right after the fix above: "a strange square with rounded
     edges behind the vinyl record"). `.card`'s base rule (this file, not
     mobile-specific) carries `background: #262626` and a box-shadow — and
     while `.card` itself HAD the dome clip-path, that background was
     cropped down to the exact same circle as everything else, so it was
     never actually visible as its own shape: it sat perfectly UNDER the
     coincident vinyl disc (invariant 26) and nobody could tell it was
     there. Moving the clip-path off `.card` (see above) fixed the sleeve
     bug but also, as a side effect, let that background paint at its own
     UNCLIPPED size for the first time — a plain 24px-rounded RECTANGLE,
     taller and squarer than the dome, so its top corners now stick out
     past the vinyl's curve exactly where the old bug's screenshot shows
     them.
     This is not something `.card` needs back. Giving `.card` its own
     permanent clip-path again would re-clip `.sleeve` right along with it
     — `.sleeve` is `.card`'s child too — which is the exact bug the fix
     above exists to prevent. And the background itself was never load-
     bearing: `.vinyl` is sized to coincide with the dome (invariant 26,
     "the disc IS the panel") and sits BEHIND `.card__scroll` at
     `z-index: -1`, so every pixel a viewer can see inside the dome is
     already either the disc or the scroll content painted over it — none
     of it was ever `.card`'s own fill showing through. Blanking it here
     costs nothing visible and removes the one thing that COULD show past
     the dome's edge now that nothing clips it down to size. `.drop` is
     untouched — it kept its own clip-path (above) and has no sleeve to
     fight it over, so its background was never at risk. */
  .card { background: none; box-shadow: none; }

  /* THE SLEEVE'S TOP EDGE IS STRAIGHT (2026-09-22), AND A same-day ATTEMPT
     TO SHARE THE RECORD'S DOME WITH IT WAS WRONG AND REVERSED (2026-09-24).
     The reasoning for sharing it read well on paper — "a sleeve slid over a
     domed record should take the record's own edge" — and was wrong on
     screen: a real record sleeve is a flat paper square, and the whole
     point of THIS session's change is that the covering motion has to look
     like a real one. A domed sleeve reads as a second record, not a paper
     cover. `.sleeve` carries its own small conventional corner radius
     instead — not a curve trying to read as a record, just a flat sleeve's
     own corner. The 100px bottom bleed still needs nothing extra: `.sleeve`
     is `inset: 0` and opaque, so having no clip at all only ever exposes
     MORE kraft, never the flat edge the bleed exists to hide.
     `.card--sleeve { clip-path: none }` USED TO LIVE HERE AND IS GONE
     (2026-09-25) — it switched `.card`'s own clip off so `.sleeve` would
     escape it, and that is exactly the mechanism that broke the record's
     shape above. Now that the clip lives on `.vinyl`/`.card__scroll`
     directly instead of on `.card`, `.sleeve` was NEVER clipped by anything
     to begin with — there is nothing left to switch off, in either state. */
  /* SHARP CORNERS (2026-09-25), reversing the "conventional 20px corner"
     call from the note above — asked for directly, the user did not want
     any rounding here, corner included. Kept the flat-shape part of that
     2026-09-24 decision (a domed sleeve still reads as a second record, not
     a cover) and dropped only the radius. */
  .card--sleeve .sleeve { border-radius: 0; }

  /* THE SLEEVE COMES UP FROM THE BOTTOM HERE, NOT IN FROM THE LEFT
     (2026-09-24, the user's call). The desktop panel is a SIDE panel, so a
     sleeve sliding in from its side reads as a natural extension of that
     shape — the phone panel is a BOTTOM sheet, the same shape the record's
     own reveal already uses ("comes up from the bottom on the same spring
     as the desktop record," this file's note on `.card`), and a sideways
     slide there would cut across the grain of everything else on this
     breakpoint. `translateY(100%)` clears the sleeve's own height exactly
     the way the horizontal version cleared its width — off the BOTTOM of
     the panel at rest, sliding up to cover. Timing and easing are
     untouched: only the AXIS changes, not the curve or duration. */
  .sleeve { transform: translateY(100%); }
  .card--sleeve .sleeve { transform: translateY(0); }

  /* THE SHEET'S 100px BOTTOM BLEED IS OFF-SCREEN (see `bottom: -100px` on
     `.card` above) and `.sleeve`, at `inset: 0`, runs down into it. The
     paper filling it is right — it covers the spring's overshoot — but
     once the board grew to push the composer to the foot (2026-09-24) the
     write button landed IN the bleed, 28px below a 812px screen. Its
     content has to stop where the screen does: 24px of ordinary padding
     plus the bleed. If the bleed ever changes, this 100 changes with it. */
  .card--sleeve .sleeve__scroll { padding-bottom: calc(24px + 100px); }

  /* SUPERSEDED (2026-09-24): `.card__close` no longer resets to `top: 20px`
     on the sleeve face — a second same-day change from the two-buttons
     split, on top of the earlier dome-sharing attempt this paragraph used
     to describe (also reversed within the session). `.card__close` is the
     record's own button now, full stop, so it always uses the
     dome-clearance `top: 44px` below regardless of which face is showing —
     the sleeve covers it once it slides across, same as it covers the rest
     of the record. `.sleeve__close` (styles.css, unscoped) carries its own
     permanent `top: 20px; right: 20px`, since the sleeve has no dome to
     clear on any breakpoint, ever. */

  /* The curve is ~34px down at the title's own x, so 16px of padding put the
     text outside the sheet entirely. The card's close button has the same
     problem and the same answer below. */
  .drop__head { padding-top: 44px; }

  /* `top: 20px` puts the button's 32px box at y=52 against a curve that is 32px
     down at its x — it was clipped. Moved to 44 to match the drop header, which
     puts the box at y=76, and `.card__media`'s margin has to follow it to keep
     the 4px clearance its own note is about: 56 -> 80. Move either and check
     BOTH the glyph and the hit box, as that note says. */
  /* THE CARD'S X IS HIDDEN, NOT DELETED (2026-09-17). Asked for: on a phone the
     note panel closes by tapping outside it, and the X goes. The DROP form
     keeps its X and does NOT get tap-to-dismiss — a half-typed form thrown away
     by a stray tap is the reason invariant 26 never bound the scrim.

     It stays in the DOM and is only visually hidden, because a scrim tap is not
     a control: it has no label, no role and no place in the accessibility tree,
     so `display: none` here would leave a VoiceOver user with no way out of a
     panel covering 88% of the screen — and Escape cannot rescue them, there
     being no keyboard on a phone. Hidden this way it is still reachable and
     still announced, at no visual cost.

     And it comes BACK on focus, the way a skip link does: this breakpoint is a
     width, not a device, so a sighted keyboard user in a narrow window would
     otherwise tab to a control they cannot see.

     `.sleeve__close` GETS THE EXACT SAME TREATMENT NOW IT IS A SEPARATE
     BUTTON (2026-09-24) — the scrim handler in card.js closes the panel on
     `card--in` alone, with no check for which face is showing, so tapping
     outside works identically while viewing the sleeve. Everything above
     applies to it for the same reasons, unchanged. */
  .card__close,
  .sleeve__close {
    position: absolute;
    width: 1px;
    height: 1px;
    margin: -1px;
    padding: 0;
    overflow: hidden;
    clip-path: inset(50%);
    white-space: nowrap;
    /* BELT AND BRACES against the flash. The clip alone should be enough, and
       in the pane it measurably was — 147 frames of a real tap never took the
       button past 1x1 and `:focus-visible` never matched. But it was seen
       flashing on a real device, and `opacity: 0` cannot be painted by any
       engine under any focus heuristic while still leaving the button in the
       accessibility tree and focusable. Belt is the clip, braces is this;
       `:focus-visible` undoes both together. */
    opacity: 0;
  }

  /* THE RESTORE IS GATED ON A DEVICE THAT CAN HOVER, and that is the whole
     point (2026-09-17). The button coming back on focus was correct for a
     narrow DESKTOP window — a sighted keyboard user must be able to see what
     they have tabbed to (WCAG 2.4.7) — but 860px is a width, not a device, and
     on an actual phone it meant a stray focus could still paint an X the design
     says is not there. The user saw exactly that and asked for it gone.

     `(hover: hover)` splits the two cleanly: a phone reports `hover: none` and
     `pointer: coarse` (verified in the pane's mobile emulation — hover none,
     pointer coarse, 5 touch points), so there the button can NEVER be painted,
     focused or not. A desktop window narrowed past 860px still has a mouse and
     a Tab key, and there it still appears. Nothing is traded away: a touch
     device has no Tab to strand anyone with.
     Two separate rules, not one shared selector, because the two buttons'
     restored POSITIONS differ — the record's clears the dome, the sleeve's
     never needs to. */
  @media (hover: hover) {
    .card__close:focus-visible {
      width: 32px;
      height: 32px;
      margin: 0;
      overflow: visible;
      clip-path: none;
      opacity: 1;
      top: 44px;
      right: 20px;
    }
    .sleeve__close:focus-visible {
      width: 32px;
      height: 32px;
      margin: 0;
      overflow: visible;
      clip-path: none;
      opacity: 1;
      /* 17px, not 20 (2026-09-28) — a duplicate of the base rule's own
         re-centring fix, missed the first time round because this is a
         SEPARATE hardcoded copy of the position, not a shared reference to
         it. Same target as the base rule: `.sleeve__head-row`'s centre at
         33px, half this box's own 32px height (16) below it. */
      top: 17px;
      right: 20px;
    }
  }

  /* THE SMALLER, CENTRED VIDEO IS GONE (2026-09-28, reversed on request).
     It used to be `max-width: 76%` with auto margins — "the point is to hear
     the track rather than watch it" — but centring a narrower box inside a
     panel where every other element (title, artist, the comments toggle)
     sits flush against a fixed side margin put the video visibly out of step
     with everything around it: "the text and other elements are all nicely
     aligned but the video itself doesn't reach the same edge alignment."
     Put two ways to fix that to the user — left-align the smaller video, or
     drop the shrink and let it span the same edges as the rest of the card
     — and the second was chosen. So there is no width/margin-left/
     margin-right override here any more; `.card__media` falls back to
     whatever the surrounding breakpoints already set (16px each side at
     640px and under, from the rule below; 16px between 641 and 860, from
     this element's own base rule above — see the very next note for why
     both now agree), the same fixed values every other mobile breakpoint in
     this file already uses instead of a centred, variable-width box.
     `margin-top` MOVED AGAIN THE SAME DAY, 40 -> 51px — not for width or
     alignment (that reasoning above is untouched), but because reverting
     the shrink put the video's own CORNERS much closer to the panel's
     curved dome than its centre ever was. Reported directly: "I want there
     to be a bit more of a gap between the video and the top of vinyl, it
     looks a bit tight" — and measured before answering, since the dome is a
     circular curve, not a flat line, so "the gap" is not one number: at
     40px, the clearance directly above the flat CENTRE of the panel was a
     full 40px, but at the video's own LEFT/RIGHT CORNERS — now close to the
     panel's edges, where the curve dips its lowest — it was only 5px. The
     curve's shape does not move with this value, only the video's position
     relative to it, so the relationship is purely additive: +Npx to
     `margin-top` is +Npx of corner clearance. Asked for 16px at the
     corners, so +11 on top of the measured 5 gave 51 as a first pass.
     NUDGED TO 50 THE SAME DAY, on the user's own eye once it was on screen
     ("on mobile, make that 50px") — one pixel back off the first pass, not a
     re-measurement. Corner clearance is ~15px, centre clearance 50px. */
  .card__media {
    margin-top: 50px;
  }

  /* ONE 16PX SIDE GAP FOR THE WHOLE RECORD, ON PURPOSE (2026-09-28, asked for
     directly: "the vinyl record needs a 16px gap on the left and right side
     and all of the elements inside of it need to respect that gap").
     `.card__media` and `.card__body` are the ONLY two things in this card
     that set their own left/right inset — every other element (title,
     artist, genre chips, the handle/expiry line, the waveform row, the
     comments toggle) lives inside `.card__body` and inherits its padding for
     free, so aligning those two is aligning everything. `.card__media`'s own
     16px already lived at this breakpoint (see the note above); the gap here
     was `.card__body`'s own padding still reading the DESKTOP value (`16px
     20px 20px`, i.e. 20px sides) because the only existing mobile override
     for it was scoped to 640px and under (`padding: 16px`), leaving a real,
     if easy-to-miss, gap in coverage between 641 and 860. `padding-left` /
     `padding-right` only, so the desktop 16px TOP / 20px BOTTOM this
     breakpoint was never asked to change stay exactly as they were — this
     is a side-gap fix, not a general repadding. */
  .card__body {
    padding-left: 16px;
    padding-right: 16px;
  }

  /* NO LABEL AND NO SPINDLE on the phone, on EITHER panel. The cream centre is
     a 237px circle: in the drop form it lands behind the genre chips and the
     comment field, and in the card it sits directly under the waveform and the
     "@user · Expired" line, where the waveform all but disappears into it.
     Dark chips on cream with white text between them is not a contrast problem
     that can be tuned out. The disc keeps its black and its grooves, which is
     what makes it read as a record anyway. Desktop keeps the label: there the
     content sits in the panel's left half and the label falls clear of it. */
  .vinyl__label,
  .vinyl__spindle { display: none; }
}

/* ---------- Editing your own note, and its "Edit" tool on the card
   (2026-09-28) ----------
 *
 * Shown only when card.js has a `dropId` for the open note — a real drop of
 * THIS browser's, never the simulated backdrop (invariant 7). Same motion
 * family as `.card__visit`/`.card__copy` beside it: one held transform per
 * verb rather than a shared background wash. A pencil's nib is its bottom-
 * left corner in this glyph, so the rotation pivots from there rather than
 * the icon's centre — it reads as the tip staying planted while the pencil
 * tilts, not the whole glyph spinning in place.
 */
.card__edit .icon {
  transition: transform 280ms cubic-bezier(0.4, 0, 0.2, 1);
  transform-origin: 22% 78%;
}
@media (hover: hover) {
  .card__edit:hover .icon,
  .card__edit:focus-visible .icon { transform: rotate(-14deg); }
}

/* ---------- The "note shared" confirmation (2026-09-28) ----------
 *
 * Its own dim backdrop, not the shared `.map-scrim` (that element's
 * visibility is wired to `.map-view--card`/`.map-view--drop`, and this
 * modal deliberately appears with NEITHER of those set — right after the
 * drop panel has already closed). `role="dialog"`/`aria-modal` live on
 * `.share-success__panel`, because the backdrop itself is not the dialog.
 */
.share-success {
  position: absolute;
  inset: 0;
  z-index: 8;
  display: flex;
  align-items: center;
  justify-content: center;
  padding: 24px;
  background: rgba(13, 13, 13, 0.72);
  opacity: 0;
  visibility: hidden;
  transition: opacity 200ms ease, visibility 0s linear 200ms;
}

.share-success.is-open {
  opacity: 1;
  visibility: visible;
  transition: opacity 200ms ease, visibility 0s;
}

.share-success__panel {
  position: relative;
  width: 100%;
  max-width: 360px;
  background: #262626;
  border-radius: 20px;
  padding: 32px 24px 24px;
  box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
  /* Same idea as the record panel's own reveal (invariant 26): a gentle
     settle, not a spring — this is a confirmation, not an arrival. */
  transform: scale(0.94);
  transition: transform 220ms cubic-bezier(0.22, 1, 0.36, 1);
}
.share-success.is-open .share-success__panel { transform: scale(1); }

/* CENTRED ON THE TITLE, NOT THE PANEL'S CORNER (fixed 2026-09-28, reported
   directly: "isn't the X button suppose to line up with the header text?").
   Measured the same way `.sleeve__close`'s own `top: 13px` was derived
   (this file, above): the title's box starts at the panel's own 32px
   padding-top with no margin of its own, at a 30px line-height, so its
   vertical centre is 32 + 15 = 47px from the panel's top edge. A 40px
   button centres on that at `top: 27px` (47 - 20). `right: 24px` matches
   `.share-success__panel`'s own right padding, the same way `.card__close`'s
   `right: 20px` matches `.card__body`'s. */
.share-success__close {
  position: absolute;
  top: 27px;
  right: 24px;
  display: flex;
  align-items: center;
  justify-content: center;
  width: 40px;
  height: 40px;
  padding: 0;
  border: none;
  border-radius: 50%;
  background: none;
  color: var(--fg);
  cursor: pointer;
}
/* SAME HOVER LANGUAGE AS EVERY OTHER CLOSE BUTTON IN THE APP (fixed
   2026-09-28, reported directly) — `.card__close`, `.drop__close` and
   `.sleeve__close` all answer a hover by swelling the ICON to 1.2x over
   200ms, gated on `(hover: hover)` so it cannot stick after a tap; none of
   them carries a background disc any more (invariant 35/37's "the icon
   itself answers" language, which replaced a shared 0.1-alpha white disc
   across the whole app in 2026-09-24). This modal's close button had
   invented its own background-wash treatment instead of reusing that
   pattern — replaced outright, not tuned. */
.share-success__close .icon { transition: transform 280ms cubic-bezier(0.4, 0, 0.2, 1); will-change: transform; }
.share-success__close:focus-visible { outline: 2px solid var(--fg); outline-offset: 2px; }
@media (hover: hover) {
  .share-success__close:hover .icon {
    transform: scale(1.2);
    transition-duration: 200ms;
  }
}
@media (prefers-reduced-motion: reduce) {
  .share-success__close .icon { transition: none; }
  .share-success__close:hover .icon { transform: none; }
}

/* Same Bungee/uppercase treatment as `.drop__title` — this panel is a small
   dialog, not a second full panel, but the header is still the app's one
   display face for a heading. */
.share-success__title {
  margin: 0 0 12px;
  font-family: "Bungee", "Inter", sans-serif;
  font-weight: 400;
  font-size: 24px;
  line-height: 30px;
  color: var(--fg);
  text-transform: uppercase;
}

.share-success__body {
  margin: 0 0 24px;
  font-size: 15px;
  line-height: 22px;
  color: rgba(255, 255, 255, 0.85);
}
.share-success__count { color: var(--fg); font-weight: 600; }

.share-success__actions {
  display: flex;
  flex-direction: column;
  gap: 12px;
}

.share-success__btn {
  height: 48px;
  border-radius: 16px;
  font: inherit;
  font-size: 16px;
  font-weight: 600;
  cursor: pointer;
  transition: filter 150ms ease, background-color 150ms ease;
}
.share-success__btn:focus-visible { outline: 2px solid var(--fg); outline-offset: 2px; }

/* Same primary as `.drop__submit` — one CTA colour for the one action the
   whole app is built around, whether that is dropping the first note or
   another right after it. */
.share-success__btn--primary {
  border: none;
  background: var(--cta);
  color: #000000;
}
@media (hover: hover) {
  .share-success__btn--primary:hover { filter: brightness(1.08); }
}

.share-success__btn--secondary {
  border: 1.5px solid var(--cta);
  background: transparent;
  color: var(--cta);
}
@media (hover: hover) {
  .share-success__btn--secondary:hover { background: rgba(var(--cta-rgb), 0.09); }
}

@media (prefers-reduced-motion: reduce) {
  .share-success,
  .share-success__panel,
  .card__edit .icon { transition: none; }
}

/* Phones: the credit sits at the bottom of the bottom-left corner, under
   Admin (2026-09-30). Its full one-line width (~342px at 375) ran under the
   zoom "−" button on the right edge, so it wraps before reaching that column
   (29px button + 10px margin + a little air). Fully spelled out still —
   invariant 1 — only wrapped. */
@media (max-width: 860px) {
  .maplibregl-ctrl-bottom-left .maplibregl-ctrl-attrib { max-width: calc(100vw - 52px); }
}

/* ---------- comment inbox: the bell (2026-10-01) ----------
   A segment of the bar between search and the place, shown only to someone
   with a live note of their own (map.js). Resting grey like the search icon;
   white once there is something new, with a gold count. Its answer to a hover
   is the bell itself swinging — the bar's own language (invariant 37): the
   control moves, nothing is painted beside it. */
.map-inbox {
  position: relative;
  flex: none;
  display: flex;
}

.map-inbox__btn {
  position: relative;
  display: flex;
  align-items: center;
  justify-content: center;
  width: 48px;
  height: 56px;
  padding: 0;
  border: 0;
  background: none;
  color: #a1a1a1;
  cursor: pointer;
  transition: color 150ms ease;
}

.map-inbox.has-new .map-inbox__btn,
.map-inbox__btn[aria-expanded="true"] { color: #ffffff; }

.map-inbox__btn:focus-visible { outline: 2px solid var(--fg); outline-offset: -4px; border-radius: 12px; }

.map-inbox__btn .icon { transform-origin: 50% 12%; }

/* The count sits on the bell's shoulder. Gold with near-black type, the
   app's CTA pair (12.9:1). */
.map-inbox__badge {
  position: absolute;
  top: 12px;
  left: 26px;
  min-width: 16px;
  height: 16px;
  padding: 0 4px;
  border-radius: 999px;
  background: var(--cta);
  color: #0d0d0d;
  font-size: 10px;
  font-weight: 700;
  line-height: 16px;
  text-align: center;
  box-shadow: 0 0 0 2px #232323;
}

@media (hover: hover) {
  .map-inbox__btn:hover { color: #ffffff; }
  .map-inbox__btn:hover .icon { animation: inbox-ring 520ms cubic-bezier(0.36, 0, 0.4, 1); }
}

@keyframes inbox-ring {
  0%   { transform: rotate(0); }
  20%  { transform: rotate(14deg); }
  45%  { transform: rotate(-10deg); }
  70%  { transform: rotate(5deg); }
  100% { transform: rotate(0); }
}

/* The panel hangs off the BAR, centred under it, so it can never run off a
   375px screen whatever the bar's width. The centring is a transform, so the
   entrance keyframes repeat it (same collision invariants 28/30 record). */
.map-inbox__panel {
  position: absolute;
  z-index: 3;
  top: calc(100% + 12px);
  left: 50%;
  width: min(320px, calc(100vw - 32px));
  padding: 8px;
  border: 1px solid rgba(255, 255, 255, 0.1);
  border-radius: 16px;
  background: #262626;
  box-shadow: 0 16px 32px -8px rgba(0, 0, 0, 0.7);
  transform: translateX(-50%);
  animation: inbox-panel-in 140ms cubic-bezier(0.4, 0, 0.2, 1);
}

@keyframes inbox-panel-in {
  from { opacity: 0; transform: translateX(-50%) translateY(-6px) scale(0.96); }
  to   { opacity: 1; transform: translateX(-50%); }
}

.map-inbox__title {
  margin: 4px 12px 8px;
  font-size: 12px;
  font-weight: 600;
  letter-spacing: 0.02em;
  color: #a1a1a1;
}

.map-inbox__list {
  list-style: none;
  margin: 0;
  padding: 0;
  max-height: 320px;
  overflow-y: auto;
}

.map-inbox__item {
  display: flex;
  flex-direction: column;
  gap: 2px;
  width: 100%;
  padding: 8px 12px;
  border: 0;
  border-radius: 10px;
  background: none;
  color: var(--fg);
  text-align: left;
  cursor: pointer;
  transition: background-color 150ms ease;
}

.map-inbox__item:hover { background: #3a3a3a; }
.map-inbox__item:focus-visible { background: #3a3a3a; outline: 2px solid var(--fg); outline-offset: -2px; }

.map-inbox__song {
  font-size: 14px;
  font-weight: 600;
  line-height: 20px;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}

.map-inbox__meta {
  font-size: 12px;
  line-height: 16px;
  color: #a1a1a1;
}

.map-inbox__item.is-new .map-inbox__meta { color: var(--cta); font-weight: 600; }

@media (max-width: 860px) {
  .map-inbox__btn { width: 44px; }
  .map-inbox__badge { left: 24px; }
  /* The field takes the whole bar while open (invariant 15); the bell stands
     down with the place segment. Its divider is a direct child of the bar,
     so the existing searching rule already hides it. */
  .map-view--searching .map-inbox { display: none; }
  .map-inbox__item { padding: 12px; }
}

@media (prefers-reduced-motion: reduce) {
  .map-inbox__btn:hover .icon { animation: none; }
  .map-inbox__panel { animation: none; }
}

/* THE COMPOSER STAYS ABOVE AN ANDROID KEYBOARD (2026-10-10). Android browsers
   now resize the page when the keyboard opens (`interactive-widget=
   resizes-content` in index.html's viewport meta — without it Chrome drew the
   keyboard OVER the sheet and the field and Post button sat underneath it).
   iPhone Safari ignores that setting and pans the page instead, so none of
   this runs there. A resized phone viewport is short, so while it is: the
   sleeve takes nearly the whole height instead of 80%, and while the
   composer is open the hint and the sticker board step aside (they come back
   on Post or Cancel),
   so the shapes, colours, field and both buttons all fit. Landscape phones
   get the same, which helps them too. */
@media (max-width: 860px) and (max-height: 560px) {
  .card.card--sleeve { --sheet-h: calc(100% - 12px); }
  .sleeve:has(.sleeve__composer:not([hidden])) .sleeve__hint { display: none; }
  .sleeve:has(.sleeve__composer:not([hidden])) .sleeve__board { display: none; }
  .sleeve:has(.sleeve__composer:not([hidden])) .sleeve__composer { margin-top: 4px; }
  .card--sleeve .sleeve__scroll { padding-bottom: calc(12px + 100px); }
}

/* WHILE THE VIDEO IS FULLSCREEN, NOTHING ABOVE IT TRANSFORMS OR CLIPS
   (2026-10-10). card.js adds `card--fullscreen` when YouTube's player goes
   fullscreen. Android Chrome positioned the fullscreen video using the
   panel's transform and the record's circle clip, so it landed lower down
   and cut off. Nothing here is visible during fullscreen, so switching these
   off costs nothing; `!important` because the panel's own transform and clip
   rules differ by breakpoint and this must beat all of them. */
.card.card--fullscreen,
.card--fullscreen .card__scroll,
.card--fullscreen .card__media,
.card--fullscreen .card__embed {
  transform: none !important;
  clip-path: none !important;
  will-change: auto !important;
}
.card--fullscreen .card__scroll,
.card--fullscreen .card__media { overflow: visible !important; }

/* OUR OWN FULLSCREEN (2026-10-10, Android). The button only shows where
   card.js decided to own fullscreen (`card--own-fs`) and once the player is
   showing (`card--video`); everywhere else YouTube's own button is used. */
.card__fs { display: none; }
.card--own-fs.card--video .card__fs { display: flex; }

/* The fullscreen box is .card__media itself: black and square-cornered,
   with a 56px strip down the RIGHT for our exit button so it never sits on
   YouTube's own controls. On the RIGHT, not the top (2026-10-10): a wide
   video on a landscape phone is limited by the screen's HEIGHT, so a strip
   on top shrank the whole picture (~20% on the user's phone) while the
   black bars at the sides went unused. The player fills the rest and
   letterboxes the video itself. */
.card__media:fullscreen {
  margin: 0;
  border-radius: 0;
  aspect-ratio: auto;
  background: #000;
}
.card__media:fullscreen .card__thumb { display: none; }
.card__media:fullscreen .card__embed {
  inset: 0 56px 0 0;
  width: auto;
  height: auto;
  opacity: 1;
  pointer-events: auto;
}
.card__fs-exit { display: none; }
.card__media:fullscreen .card__fs-exit {
  position: absolute;
  top: 6px;
  right: 8px;
  display: flex;
  align-items: center;
  justify-content: center;
  width: 44px;
  height: 44px;
  padding: 0;
  border: none;
  border-radius: 50%;
  background: transparent;
  color: #fff;
  cursor: pointer;
}
.card__fs-exit:focus-visible { outline: 2px solid #fff; outline-offset: 2px; }

/* SIDEWAYS EVEN WHEN THE SCREEN STAYS UPRIGHT (2026-10-10, the user's call:
   "the video fills sideways and they need to flip their phone"). card.js asks
   Android to turn the screen to landscape, like the YouTube app; if the
   browser refuses, or the phone's rotation is locked, the screen is still
   portrait and this turns the player 90deg itself so it fills the screen
   sideways. The fullscreen box can't be rotated (the browser forces
   `transform: none` on it), so its children are: the player fills the
   rotated frame minus the 56px exit strip along the rotated RIGHT edge,
   which is the screen's BOTTOM, so the strip again costs no video height
   once the phone is turned. The exit button sits in that strip, turned to
   match. Once the screen really is landscape, this media query stops
   matching on its own. */
@media (orientation: portrait) {
  .card__media:fullscreen .card__embed {
    inset: auto;
    top: calc((100vh - 56px) / 2);
    left: 50%;
    width: calc(100vh - 56px);
    height: 100vw;
    transform: translate(-50%, -50%) rotate(90deg) !important;
  }
  .card__media:fullscreen .card__fs-exit {
    top: auto;
    bottom: 6px;
    right: 6px;
    transform: rotate(90deg);
  }
}

/* THE "OLDER NOTES" BANNER (2026-10-26). Sits just under the header bar
   (24 + 56 + 16 on desktop, 16 + 56 + 12 on phones), same near-solid fill
   as the bar and the toast so it reads as app chrome, not map. z-index 2:
   under the header (3), so the clock menu and inbox that hang off the bar
   open over it, and under the scrim (4), so an open panel covers it. The
   toast shares this spot; it is brief and sits above (6). */
.map-banner {
  position: absolute;
  top: 96px;
  left: 0;
  right: 0;
  z-index: 2;
  display: flex;
  align-items: flex-start;
  gap: 4px;
  width: fit-content;
  max-width: min(calc(100% - 32px), 560px);
  margin-inline: auto;
  padding: 10px 4px 10px 16px;
  border-radius: 12px;
  background: rgba(35, 35, 35, 0.94);
  color: #fafafa;
  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.25);
}
.map-banner[hidden] { display: none; }
.map-banner__text {
  margin: 0;
  padding-top: 2px;
  font-size: 14px;
  line-height: 20px;
}
/* A button that reads as a link: it does something on this page (flies home
   and opens the form) rather than going to another URL. */
.map-banner__link {
  display: inline;
  padding: 0;
  border: none;
  background: none;
  color: var(--cta);
  font: inherit;
  font-weight: 600;
  text-decoration: underline;
  text-underline-offset: 3px;
  cursor: pointer;
}
.map-banner__link:focus-visible { outline: 2px solid var(--cta); outline-offset: 2px; border-radius: 2px; }
.map-banner__close {
  flex: none;
  display: flex;
  align-items: center;
  justify-content: center;
  width: 32px;
  height: 32px;
  margin: -4px 0 -4px;
  padding: 0;
  border: none;
  border-radius: 50%;
  background: none;
  color: #a1a1a1;
  cursor: pointer;
}
.map-banner__close:focus-visible { outline: 2px solid var(--fg); outline-offset: 2px; }
@media (hover: hover) {
  .map-banner__close:hover { color: #fff; }
}
@media (max-width: 860px) {
  .map-banner { top: 84px; }
}
