/* ═══════════════════════════════════════════════════════════════════
   loaders.css — THE SHIFT: the product's loading indicator

   The mark's plate, working. Four tiles rotate stations — up the left,
   along the top, into the corner, down and around — and the green
   never travels with them: it belongs to the TOP-RIGHT CORNER, and a
   tile wears it only while standing there (bloom on arrival, drained
   on departure). The same grammar the quad selector enforces at rest
   (one hue per plate, and it lives in the corner — see quad.css and
   docs-private/QUAD_ADOPTION.md), here enforced in motion.

   FIVE REGISTERS, one component (motion study 002, all adopted —
   the product MIXES them, by surface family, per the placement map
   in docs-private/LOADERS_ADOPTION.md):

     .shift                 The Rotation — four even beats, everyone
                            advances one station together. The default
                            wherever no other register has a claim.
     .shift--cover          The Cover — three on, one station open;
                            tiles slide ONE AT A TIME to cover the
                            vacancy as it laps the plate. The quiet
                            register: feeds, table rows, consoles,
                            step trackers, tiny slots.
     .shift--swap           The Swap — diagonal pairs trade stations
                            through the center, one over, one under.
                            The exchange register: Fabric, marketplace,
                            orders — surfaces about value changing hands.
     .shift--ambient        The Carousel — the beats removed: perpetual
                            even glide, the green CRESTS as each tile
                            rounds the corner. Long AI-generation waits
                            at ≥48px; "the studio is humming", not "an
                            operation is running".
     .shift--double         The Double — two quick hops, then a long
                            dwell; through the corner the green is a
                            flash, landed in it a full shift. The
                            game's register: hustle surfaces, the grow
                            desk, anywhere the product may grin.

   MARKUP (the whole contract — four empty tiles, a11y on the root;
   IDENTICAL for every register — the Cover hides its own fourth tile,
   so callers never vary the tile count):

     <div class="shift" role="status" aria-label="Loading">
       <i></i><i></i><i></i><i></i>
     </div>

   Server-rendered surfaces include templates/_loader.html (set
   shift_variant to a register name). JS that paints a waiting state
   calls SP.shift({register, size, …}) from static/js/app.js — the
   partial's JS twin — never a hand-written string. A button doing
   async work uses SP.whileBusy(btn, label, fn), which restores it in
   a finally so a rejected request cannot strand it disabled.

   PLACEMENT MODIFIERS (position, not personality):
     .shift--panel    centered block for card/section bodies (default 36px)
     .shift--inline   16px, inline-grid, sits in a line of text
     .shift--step     14px, inline-grid, the step-tracker slot
     .shift--hero     96px, centered — pairs naturally with --ambient

   TOKENS — override on an ancestor to reskin, never restyle tiles:
     --shift-size     side length (any CSS length; everything scales)
     --shift-accent   the corner's hue. THE MARK'S GREEN IS THE
                      STUDIO'S: tenant surfaces re-token this to the
                      tenant accent (helpers_brand), same boundary as
                      --quad-green. Non-corner tiles carry no hue at
                      any accent, so the one-hue rule survives reskins.
     --shift-cell     tile surface (default white — the plate is a
                      white card on every ground the product has)
     --shift-tempo    duration multiplier (1 = house tempo)

   Reduced motion: the component freezes to the RESTING MARK — white
   plate, green corner, nothing moving — the same pose quad.css's own
   reduced-motion rules leave the selector in.

   SEE IT WORKING: /design-loading (templates/design_loading.html,
   unlinked + noindex) drives these exact assets — all five registers
   side by side, the size ladder, both skins, the tenant-accent swap, a
   tempo control and the reduced-motion pose. It is to this component
   what /design-corner is to the quad, and it is the reference for the
   rules; read it before adopting.

   Adoption ledger: docs-private/LOADERS_ADOPTION.md records every
   surface this replaced, which register each one takes and why, plus
   the deliberate skips. Update it in the same change that adopts,
   skips, or moves a surface between registers.
   ═══════════════════════════════════════════════════════════════════ */

.shift{
  /* ── tokens ──────────────────────────────────────────────────────
     Deliberately NOT declared here. A custom property declared on the
     element itself beats any value inherited from an ancestor, so
     defaulting them on `.shift` would silently kill the whole skin
     seam: a tenant wrapper (or /design-loading's accent + tempo
     controls) setting --shift-accent on a parent would never reach
     the tiles. The defaults live in the var() fallbacks below, which
     apply only when nothing up the tree has set them.

        --shift-size    36px      side length; everything derives
        --shift-accent  #00d98e   the corner's hue — the tenant seam
        --shift-cell    #fff      tile surface
        --shift-tempo   1         duration multiplier

     ── derived — not part of the skin seam ── */
  --sh-rw: max(1px, calc(var(--shift-size, 36px) * .022));   /* the rule    */
  --sh-rr: max(1.5px, calc(var(--shift-size, 36px) * .025)); /* tile radius */
  --sh-u: calc(100% + var(--sh-rw));                   /* one station */
  --sh-T: calc(4.8s * var(--shift-tempo, 1));             /* one cycle   */

  position: relative;
  /* The Swap keyframes a z-index on its tiles so the diagonal pass reads
     as one tile over and one under. That is ORDERING BETWEEN TWO TILES
     and nothing more — but `position:relative` with `z-index:auto` makes
     no stacking context, so without this those values resolve against
     the PAGE and a tile at z-index 3 paints over whatever sits above the
     loader. Isolating contains the component's own ordering inside it,
     at every size and for every caller. */
  isolation: isolate;
  display: grid;
  width: var(--shift-size, 36px);
  height: var(--shift-size, 36px);
  flex: none;
}
.shift > i{
  position: absolute;
  top: 0;
  left: 0;
  width: calc(50% - var(--sh-rw)/2);
  height: calc(50% - var(--sh-rw)/2);
  background: var(--shift-cell, #fff);
  border-radius: var(--sh-rr);
  box-shadow: 0 1px 2px rgba(28,26,22,.10);
  animation: shift-go var(--sh-T) infinite, shift-hue var(--sh-T) ease infinite;
  will-change: transform;
}
/* Four tiles, one shared circuit, quarter-cycle apart — the delays are
   what turn one keyframe timeline into a ring. */
.shift > i:nth-child(2){animation-delay: calc(var(--sh-T) * -.25), calc(var(--sh-T) * -.25)}
.shift > i:nth-child(3){animation-delay: calc(var(--sh-T) * -.5),  calc(var(--sh-T) * -.5)}
.shift > i:nth-child(4){animation-delay: calc(var(--sh-T) * -.75), calc(var(--sh-T) * -.75)}

/* ── The Rotation ────────────────────────────────────────────────
   Move = 8% of the cycle per beat; mid-keys bow outward and squash
   along the travel axis; the landing segment overshoots. The other
   three beats rest. Timing functions live on the keyframes that own
   the departing pose — a timing function only shapes a property's
   segment when declared on a keyframe that also declares it. */
@keyframes shift-go{
  0%{transform:translate(0,0) scale(1); animation-timing-function:cubic-bezier(.5,0,.7,.5)}
  4%{transform:translate(calc(var(--sh-u)*.5), calc(var(--sh-u)*-.1)) scaleX(1.1) scaleY(.9); animation-timing-function:cubic-bezier(.25,.7,.3,1.25)}
  8%{transform:translate(var(--sh-u),0) scale(1)}
  25%{transform:translate(var(--sh-u),0) scale(1); animation-timing-function:cubic-bezier(.5,0,.7,.5)}
  29%{transform:translate(calc(var(--sh-u)*1.1), calc(var(--sh-u)*.5)) scaleX(.9) scaleY(1.1); animation-timing-function:cubic-bezier(.25,.7,.3,1.25)}
  33%{transform:translate(var(--sh-u),var(--sh-u)) scale(1)}
  50%{transform:translate(var(--sh-u),var(--sh-u)) scale(1); animation-timing-function:cubic-bezier(.5,0,.7,.5)}
  54%{transform:translate(calc(var(--sh-u)*.5), calc(var(--sh-u)*1.1)) scaleX(1.1) scaleY(.9); animation-timing-function:cubic-bezier(.25,.7,.3,1.25)}
  58%{transform:translate(0,var(--sh-u)) scale(1)}
  75%{transform:translate(0,var(--sh-u)) scale(1); animation-timing-function:cubic-bezier(.5,0,.7,.5)}
  79%{transform:translate(calc(var(--sh-u)*-.1), calc(var(--sh-u)*.5)) scaleX(.9) scaleY(1.1); animation-timing-function:cubic-bezier(.25,.7,.3,1.25)}
  83%,100%{transform:translate(0,0) scale(1)}
}
/* The corner confers the colour: green while resting top-right
   (the 8–25% window of the shared circuit), bloom on arrival,
   drained during the departing move. The rgba fallback keeps the
   bloom where color-mix is unsupported; it hardcodes the mark's
   green, which is correct everywhere but a tenant reskin — there
   the color-mix line is what carries the tenant accent. */
@keyframes shift-hue{
  0%{background:var(--shift-cell, #fff); box-shadow:0 1px 2px rgba(28,26,22,.10)}
  7%{background:var(--shift-accent, #00d98e)}
  10%{box-shadow:0 1px 2px rgba(28,26,22,.10), 0 0 calc(var(--shift-size, 36px)*.18) rgba(0,217,142,.5);
      box-shadow:0 1px 2px rgba(28,26,22,.10), 0 0 calc(var(--shift-size, 36px)*.18) color-mix(in srgb, var(--shift-accent, #00d98e) 50%, transparent)}
  24%{background:var(--shift-accent, #00d98e); box-shadow:0 1px 2px rgba(28,26,22,.10)}
  33%,100%{background:var(--shift-cell, #fff); box-shadow:0 1px 2px rgba(28,26,22,.10)}
}

/* ── The Carousel (.shift--ambient) ──────────────────────────────
   Same circuit, beats removed: strictly linear glide, a 1.05 crest
   at the corner (the 20/30% stops are exact linear waypoints, so the
   crest never disturbs the constant speed), and the green held only
   around the crest. */
.shift--ambient{--sh-T: calc(7.2s * var(--shift-tempo, 1))}
.shift--ambient > i{
  animation-name: shift-glide, shift-crest;
  animation-timing-function: linear, linear;
}
@keyframes shift-glide{
  0%{transform:translate(0,0) scale(1)}
  20%{transform:translate(calc(var(--sh-u)*.8), 0) scale(1)}
  25%{transform:translate(var(--sh-u),0) scale(1.05)}
  30%{transform:translate(var(--sh-u), calc(var(--sh-u)*.2)) scale(1)}
  50%{transform:translate(var(--sh-u),var(--sh-u)) scale(1)}
  75%{transform:translate(0,var(--sh-u)) scale(1)}
  100%{transform:translate(0,0) scale(1)}
}
@keyframes shift-crest{
  0%,16%{background:var(--shift-cell, #fff); box-shadow:0 1px 2px rgba(28,26,22,.10)}
  23%{background:var(--shift-accent, #00d98e)}
  25%{box-shadow:0 1px 2px rgba(28,26,22,.10), 0 0 calc(var(--shift-size, 36px)*.16) rgba(0,217,142,.45);
      box-shadow:0 1px 2px rgba(28,26,22,.10), 0 0 calc(var(--shift-size, 36px)*.16) color-mix(in srgb, var(--shift-accent, #00d98e) 45%, transparent)}
  27%{background:var(--shift-accent, #00d98e)}
  34%,100%{background:var(--shift-cell, #fff); box-shadow:0 1px 2px rgba(28,26,22,.10)}
}

/* ── The Cover (.shift--cover) ───────────────────────────────────
   A 12-beat sliding relay: three tiles, thirds apart on one circuit,
   moving in the last sliver of every quarter — so only one tile is
   ever in motion, and the un-covered station (the vacancy) laps the
   plate. The fourth tile hides itself: callers keep the four-tile
   markup contract untouched. */
.shift--cover{--sh-T: calc(6.4s * var(--shift-tempo, 1))}
.shift--cover > i{animation-name: shift-cover-go, shift-cover-hue}
.shift--cover > i:nth-child(1){animation-delay: calc(var(--sh-T) * -.33333), calc(var(--sh-T) * -.33333)}
.shift--cover > i:nth-child(2){animation-delay: calc(var(--sh-T) * -.66667), calc(var(--sh-T) * -.66667)}
.shift--cover > i:nth-child(3){animation-delay: 0s, 0s}
.shift--cover > i:nth-child(4){display: none}
@keyframes shift-cover-go{
  0%,21.25%{transform:translate(0,0) scale(1); animation-timing-function:cubic-bezier(.5,0,.7,.5)}
  23.1%{transform:translate(calc(var(--sh-u)*.5), calc(var(--sh-u)*-.07)) scaleX(1.06) scaleY(.94); animation-timing-function:cubic-bezier(.25,.7,.3,1.22)}
  25%{transform:translate(var(--sh-u),0) scale(1)}
  46.25%{transform:translate(var(--sh-u),0) scale(1); animation-timing-function:cubic-bezier(.5,0,.7,.5)}
  48.1%{transform:translate(calc(var(--sh-u)*1.07), calc(var(--sh-u)*.5)) scaleX(.94) scaleY(1.06); animation-timing-function:cubic-bezier(.25,.7,.3,1.22)}
  50%{transform:translate(var(--sh-u),var(--sh-u)) scale(1)}
  71.25%{transform:translate(var(--sh-u),var(--sh-u)) scale(1); animation-timing-function:cubic-bezier(.5,0,.7,.5)}
  73.1%{transform:translate(calc(var(--sh-u)*.5), calc(var(--sh-u)*1.07)) scaleX(1.06) scaleY(.94); animation-timing-function:cubic-bezier(.25,.7,.3,1.22)}
  75%{transform:translate(0,var(--sh-u)) scale(1)}
  96.25%{transform:translate(0,var(--sh-u)) scale(1); animation-timing-function:cubic-bezier(.5,0,.7,.5)}
  98.1%{transform:translate(calc(var(--sh-u)*-.07), calc(var(--sh-u)*.5)) scaleX(.94) scaleY(1.06); animation-timing-function:cubic-bezier(.25,.7,.3,1.22)}
  100%{transform:translate(0,0) scale(1)}
}
@keyframes shift-cover-hue{
  0%,22%{background:var(--shift-cell, #fff); box-shadow:0 1px 2px rgba(28,26,22,.10)}
  25%{background:var(--shift-accent, #00d98e)}
  29%{box-shadow:0 1px 2px rgba(28,26,22,.10), 0 0 calc(var(--shift-size, 36px)*.16) rgba(0,217,142,.45);
      box-shadow:0 1px 2px rgba(28,26,22,.10), 0 0 calc(var(--shift-size, 36px)*.16) color-mix(in srgb, var(--shift-accent, #00d98e) 45%, transparent)}
  45%{background:var(--shift-accent, #00d98e); box-shadow:0 1px 2px rgba(28,26,22,.10)}
  50%,100%{background:var(--shift-cell, #fff); box-shadow:0 1px 2px rgba(28,26,22,.10)}
}

/* ── The Swap (.shift--swap) ─────────────────────────────────────
   Changeovers: the corner diagonal (tiles 1+2) trades through the
   center carrying the green, the other diagonal (tiles 3+4) answers
   on the off-beats. One over (scale up), one under (scale down);
   z-index is keyframed so the pass reads. shift-still is the no-op
   hue slot for the pair that never colours. */
.shift--swap{--sh-T: calc(4.2s * var(--shift-tempo, 1))}
.shift--swap > i:nth-child(1){animation-name: shift-swap-a, shift-swap-hue; animation-delay: 0s, 0s}
.shift--swap > i:nth-child(2){animation-name: shift-swap-a, shift-swap-hue; animation-delay: calc(var(--sh-T) * -.5), calc(var(--sh-T) * -.5)}
.shift--swap > i:nth-child(3){animation-name: shift-swap-b, shift-still; animation-delay: 0s, 0s}
.shift--swap > i:nth-child(4){animation-name: shift-swap-b, shift-still; animation-delay: calc(var(--sh-T) * -.5), calc(var(--sh-T) * -.5)}
@keyframes shift-still{}
@keyframes shift-swap-a{
  0%,3%{transform:translate(var(--sh-u),0) scale(1); z-index:3; animation-timing-function:cubic-bezier(.55,0,.6,.6)}
  10%{transform:translate(calc(var(--sh-u)*.45), calc(var(--sh-u)*.45)) scale(1.09); z-index:3; animation-timing-function:cubic-bezier(.3,.6,.3,1.18)}
  17%{transform:translate(0,var(--sh-u)) scale(1); z-index:3}
  49%{transform:translate(0,var(--sh-u)) scale(1); z-index:3}
  53%{transform:translate(0,var(--sh-u)) scale(1); z-index:1; animation-timing-function:cubic-bezier(.55,0,.6,.6)}
  60%{transform:translate(calc(var(--sh-u)*.55), calc(var(--sh-u)*.55)) scale(.88); z-index:1; animation-timing-function:cubic-bezier(.3,.6,.3,1.18)}
  67%,100%{transform:translate(var(--sh-u),0) scale(1); z-index:1}
}
@keyframes shift-swap-b{
  0%,28%{transform:translate(0,0) scale(1); z-index:3; animation-timing-function:cubic-bezier(.55,0,.6,.6)}
  35%{transform:translate(calc(var(--sh-u)*.55), calc(var(--sh-u)*.45)) scale(1.09); z-index:3; animation-timing-function:cubic-bezier(.3,.6,.3,1.18)}
  42%{transform:translate(var(--sh-u),var(--sh-u)) scale(1); z-index:3}
  74%{transform:translate(var(--sh-u),var(--sh-u)) scale(1); z-index:3}
  78%{transform:translate(var(--sh-u),var(--sh-u)) scale(1); z-index:1; animation-timing-function:cubic-bezier(.55,0,.6,.6)}
  85%{transform:translate(calc(var(--sh-u)*.45), calc(var(--sh-u)*.55)) scale(.88); z-index:1; animation-timing-function:cubic-bezier(.3,.6,.3,1.18)}
  92%,100%{transform:translate(0,0) scale(1); z-index:1}
}
@keyframes shift-swap-hue{
  0%,3%{background:var(--shift-accent, #00d98e); box-shadow:0 1px 2px rgba(28,26,22,.10)}
  12%,63%{background:var(--shift-cell, #fff); box-shadow:0 1px 2px rgba(28,26,22,.10)}
  70%{background:var(--shift-accent, #00d98e)}
  74%{box-shadow:0 1px 2px rgba(28,26,22,.10), 0 0 calc(var(--shift-size, 36px)*.18) rgba(0,217,142,.5);
      box-shadow:0 1px 2px rgba(28,26,22,.10), 0 0 calc(var(--shift-size, 36px)*.18) color-mix(in srgb, var(--shift-accent, #00d98e) 50%, transparent)}
  88%,100%{background:var(--shift-accent, #00d98e); box-shadow:0 1px 2px rgba(28,26,22,.10)}
}

/* ── The Double (.shift--double) ─────────────────────────────────
   Two stations in two quick hops, then a long dwell. Two parity
   pairs share timelines a half-cycle apart, so all four hop in the
   same windows. Passed THROUGH, the corner is a green flash; landed
   IN, a full green shift with the bloom. The nth mapping makes the
   t=0 pose equal the resting mark. */
.shift--double{--sh-T: calc(5.2s * var(--shift-tempo, 1))}
.shift--double > i:nth-child(1){animation-name: shift-double-b, shift-double-b-hue; animation-delay: 0s, 0s}
.shift--double > i:nth-child(2){animation-name: shift-double-a, shift-double-a-hue; animation-delay: calc(var(--sh-T) * -.5), calc(var(--sh-T) * -.5)}
.shift--double > i:nth-child(3){animation-name: shift-double-b, shift-double-b-hue; animation-delay: calc(var(--sh-T) * -.5), calc(var(--sh-T) * -.5)}
.shift--double > i:nth-child(4){animation-name: shift-double-a, shift-double-a-hue; animation-delay: 0s, 0s}
@keyframes shift-double-a{
  0%{transform:translate(0,0) scale(1); animation-timing-function:cubic-bezier(.5,0,.7,.5)}
  3%{transform:translate(calc(var(--sh-u)*.5), calc(var(--sh-u)*-.08)) scaleX(1.08) scaleY(.92); animation-timing-function:cubic-bezier(.25,.7,.3,1.2)}
  6%{transform:translate(var(--sh-u),0) scale(1)}
  9%{transform:translate(var(--sh-u),0) scale(1); animation-timing-function:cubic-bezier(.5,0,.7,.5)}
  12%{transform:translate(calc(var(--sh-u)*1.08), calc(var(--sh-u)*.5)) scaleX(.92) scaleY(1.08); animation-timing-function:cubic-bezier(.25,.7,.3,1.2)}
  15%{transform:translate(var(--sh-u),var(--sh-u)) scale(1)}
  50%{transform:translate(var(--sh-u),var(--sh-u)) scale(1); animation-timing-function:cubic-bezier(.5,0,.7,.5)}
  53%{transform:translate(calc(var(--sh-u)*.5), calc(var(--sh-u)*1.08)) scaleX(1.08) scaleY(.92); animation-timing-function:cubic-bezier(.25,.7,.3,1.2)}
  56%{transform:translate(0,var(--sh-u)) scale(1)}
  59%{transform:translate(0,var(--sh-u)) scale(1); animation-timing-function:cubic-bezier(.5,0,.7,.5)}
  62%{transform:translate(calc(var(--sh-u)*-.08), calc(var(--sh-u)*.5)) scaleX(.92) scaleY(1.08); animation-timing-function:cubic-bezier(.25,.7,.3,1.2)}
  65%,100%{transform:translate(0,0) scale(1)}
}
@keyframes shift-double-a-hue{
  0%,3%{background:var(--shift-cell, #fff); box-shadow:0 1px 2px rgba(28,26,22,.10)}
  6%,9%{background:var(--shift-accent, #00d98e);
        box-shadow:0 1px 2px rgba(28,26,22,.10), 0 0 calc(var(--shift-size, 36px)*.1) rgba(0,217,142,.35);
        box-shadow:0 1px 2px rgba(28,26,22,.10), 0 0 calc(var(--shift-size, 36px)*.1) color-mix(in srgb, var(--shift-accent, #00d98e) 35%, transparent)}
  14%,100%{background:var(--shift-cell, #fff); box-shadow:0 1px 2px rgba(28,26,22,.10)}
}
@keyframes shift-double-b{
  0%{transform:translate(var(--sh-u),0) scale(1); animation-timing-function:cubic-bezier(.5,0,.7,.5)}
  3%{transform:translate(calc(var(--sh-u)*1.08), calc(var(--sh-u)*.5)) scaleX(.92) scaleY(1.08); animation-timing-function:cubic-bezier(.25,.7,.3,1.2)}
  6%{transform:translate(var(--sh-u),var(--sh-u)) scale(1)}
  9%{transform:translate(var(--sh-u),var(--sh-u)) scale(1); animation-timing-function:cubic-bezier(.5,0,.7,.5)}
  12%{transform:translate(calc(var(--sh-u)*.5), calc(var(--sh-u)*1.08)) scaleX(1.08) scaleY(.92); animation-timing-function:cubic-bezier(.25,.7,.3,1.2)}
  15%{transform:translate(0,var(--sh-u)) scale(1)}
  50%{transform:translate(0,var(--sh-u)) scale(1); animation-timing-function:cubic-bezier(.5,0,.7,.5)}
  53%{transform:translate(calc(var(--sh-u)*-.08), calc(var(--sh-u)*.5)) scaleX(.92) scaleY(1.08); animation-timing-function:cubic-bezier(.25,.7,.3,1.2)}
  56%{transform:translate(0,0) scale(1)}
  59%{transform:translate(0,0) scale(1); animation-timing-function:cubic-bezier(.5,0,.7,.5)}
  62%{transform:translate(calc(var(--sh-u)*.5), calc(var(--sh-u)*-.08)) scaleX(1.08) scaleY(.92); animation-timing-function:cubic-bezier(.25,.7,.3,1.2)}
  65%,100%{transform:translate(var(--sh-u),0) scale(1)}
}
@keyframes shift-double-b-hue{
  0%{background:var(--shift-accent, #00d98e); box-shadow:0 1px 2px rgba(28,26,22,.10)}
  8%,61%{background:var(--shift-cell, #fff); box-shadow:0 1px 2px rgba(28,26,22,.10)}
  65%{background:var(--shift-accent, #00d98e)}
  70%{box-shadow:0 1px 2px rgba(28,26,22,.10), 0 0 calc(var(--shift-size, 36px)*.18) rgba(0,217,142,.5);
      box-shadow:0 1px 2px rgba(28,26,22,.10), 0 0 calc(var(--shift-size, 36px)*.18) color-mix(in srgb, var(--shift-accent, #00d98e) 50%, transparent)}
  82%,100%{background:var(--shift-accent, #00d98e); box-shadow:0 1px 2px rgba(28,26,22,.10)}
}

/* ── placement modifiers ─────────────────────────────────────────── */
.shift--panel{margin: 22px auto}
.shift--inline{--shift-size: 16px; display: inline-grid; vertical-align: -3px}
.shift--step{--shift-size: 14px; display: inline-grid; vertical-align: -2px}
.shift--hero{--shift-size: 96px; margin: 32px auto}

/* The label SP.busy() keeps beside the loader inside a working button.
   The tiles inherit the button's text colour nowhere — they stay the
   plate — so a dark button needs no special case. */
.shift-busy-label{margin-left: .45em}

/* ── at rest ─────────────────────────────────────────────────────
   The resting mark: white plate, green corner, nothing moving. The
   Cover's third tile stays home (its fourth is hidden), so its rest
   pose keeps the vacancy at bottom-left. */
@media (prefers-reduced-motion: reduce){
  .shift > i{animation: none}
  .shift > i:nth-child(1){transform:translate(var(--sh-u),0); background:var(--shift-accent, #00d98e)}
  .shift > i:nth-child(2){transform:translate(var(--sh-u),var(--sh-u))}
  .shift > i:nth-child(3){transform:translate(0,var(--sh-u))}
  .shift--cover > i:nth-child(3){transform:none}
}
