/* Plain CSS, served as written: there is no build step, no preprocessor and no
   framework. This file is the base layer only — the document, the typography
   defaults and the things every section relies on. Section styles are added by
   the tickets that add the sections.

   Values come from tokens.css, which is linked first. Reach for a token before
   you type a hex code or a pixel.

   THE DESIGN HAS NO BREAKPOINT. Write the narrow layout first, and where a
   component needs a second shape, ask its own container how much room it has:
   `@container band (min-width: 48rem)`, with `container-type: inline-size` on
   the band that holds it. Do not add an `@media (min-width: …)`. The reasoning
   is at the foot of this file over the first @container rule; the short of it
   is that a component that reads the window is a component that is only
   correct in the one place it was first put, and there is no longer a single
   global number for a reader to hold in their head. `prefers-reduced-motion`
   is the one @media condition either public stylesheet asks about. */

/* ---- Where this page differs from the mockup, and why -------------------
 *
 * Every section below has been reconciled against
 * docs/mockups/brasslighthouse-mockups.html as a browser renders its FIRST
 * FRAME — its cascade overrides several of its own rules, so a value read out
 * of a rule in isolation is not the value on the screen. The hero eyebrow is
 * the worked example and .hero__eyebrow spells it out.
 *
 * What is left is this list. Put the home page at 1440 beside the mockup's
 * first frame and these are the differences; anything else is a defect.
 *
 * 1. THE SURFACE LADDER IS ONE STEP DOWN. The mockup's first frame is a 1120px
 *    card sitting on a warm-black body, so its bands are drawn on --frame and
 *    --panel and the night is only the surround. A real full-width page has no
 *    card: the night is the page. So the bar, the hero, the work section and
 *    the footer take --color-paper (the mockup's --night) and the quote band
 *    and the closing call to action take --color-paper-sunk (its --frame). The
 *    relationships are the mockup's — one step between neighbouring bands, the
 *    quote card one step below the band it is set into — and it is the absolute
 *    step that moves. The mockup's body gradient is part of that surround and
 *    is deliberately not on the page; the hero's own fog is, and is drawn.
 *
 * 2. THE LIGHTHOUSE IS THE ONE THIS SITE DREW. Already agreed: the reviewer
 *    prefers item 51's larger engraving to the mockup's, so the line art is not
 *    replaced or resized and only the light in it is reconciled. Three things
 *    follow from that and are part of the same difference — the hero's columns
 *    are 7fr to 5fr rather than the mockup's 1.62 to .76, which is what holds
 *    the drawing at its size; the engraving is one stroke class at one opacity
 *    where the mockup's is two (its .metal at .66 and its .fine at .32); and
 *    the drawing carries a lit point at the middle of the lamp, which the
 *    mockup's does not.
 *
 * 3. THE UNDERLINE HANGS BELOW THE LINE BOX. The mockup's .uline sits .14em
 *    into it and lets the descender on "price." cross the strokes. Everything
 *    else about the mark is the mockup's: the mint, the two widths, the .7 on
 *    the second stroke, the -2% overhang and all four times.
 *
 * 4. THE RUNNING TALLY IS ONE TREATMENT. The mockup wraps the figure in a <b>
 *    and paints it in the lit brass, leaving "invoiced so far" in the third
 *    cream. app.js writes the whole line as one text node — see
 *    PIPELINE_TALLY_TEXT there — so there is no element in it to paint
 *    separately, and the line takes the mockup's label treatment throughout.
 *
 * 5. THE PIPELINE RAIL SPANS THE LIST. The mockup's runs from the first dot to
 *    the last, which on five equal columns is 10% to 90%. Ours spans the whole
 *    list and app.js aims the line at (node + .5) / nodes; pinning it to the
 *    outer dots would write "five" into the stylesheet and into the script's
 *    arithmetic, and the stepper is built to be counted from the markup. The
 *    cost is a stub of hairline outside each end dot.
 *
 * 6. THE BAR AND THE FOOTER CARRY THE LIT HAIRLINE. The mockup rules every band
 *    with --rule and this page rules its bands with --color-line to match; the
 *    two shell rules are the stronger one because they are the only thing
 *    drawing the bar and the foot on /quote, /privacy and /terms, where what
 *    sits above and below them is the page as well.
 *
 * 7. THERE IS NO "YOURS TO KEEP" CHIP. §6 confirms the mockup's fourth chip is
 *    a mistake and §1 forbids the claim behind it. Three chips is the row.
 *
 * 8. THE FOOTNOTE IS OUTSIDE THE QUOTE CARD. The mockup keeps it inside .terms;
 *    here it is a sibling immediately under the card, so the qualification is
 *    beside the figure it qualifies at 360px and at 1024px alike. Its treatment
 *    is the mockup's .terms .fn either way.
 *
 * 9. THE PAGE SCALES BELOW THE BREAKPOINT. The mockup's 860px block moves its
 *    headline and its gutters and leaves every other size where it is. This
 *    page is written mobile first, so the display steps, the section padding
 *    and the gutter all step down on a phone. At 1440 the two agree.
 *
 * 10. TWO ROUNDINGS WORTH NAMING. The closing paragraph reads --measure-aside
 *     (46ch) where the mockup holds it to 52ch, and the work card's swatch is a
 *     16/10 box where the mockup's is 118px tall — the swatch stands in for a
 *     screenshot and holds the shape one will arrive in. Every other rounding
 *     is onto the 4px grid or the type scale and is noted where it is made.
 *
 * 11. /quote, /quote/received, /privacy AND /terms HAVE NO FRAME TO COMPARE TO.
 *     The mockup draws the home page and the client portal, and the portal is a
 *     later phase this project is told not to build. Those four pages read the
 *     same tokens: no leftover gold, no leftover typeface from before the
 *     re-theme, and no value left over from the light palette.
 *
 * 12. THE PAGE IS THE MOCKUP AT 1120 AND ITS OWN THING EITHER SIDE OF THAT.
 *     The mockup file draws a 1120px frame on a ground. This page's frame is
 *     the viewport, and at 1120 what is inside it is the mockup to the pixel —
 *     every ramp in tokens.css is anchored to return the mockup's own number
 *     there. Away from 1120 it is deliberately not the mockup scaled. A wider
 *     window buys a wider column (1024px out to 1216px), more air between the
 *     bands, a much larger headline and a slightly larger line of body copy,
 *     in that order of magnitude; past 1920 it buys only margin. A narrower
 *     one is unchanged from what it always was.
 *
 *     This replaced a rule that made the root unit itself follow the window —
 *     `clamp(1rem, 100vw / 70, 2000px / 70)` on `html` — which did give the
 *     mockup at 1.29×, 1.5× and 1.79× with nothing moved relative to anything
 *     else, and that turned out to be the problem rather than the feature. It
 *     is one ramp applied to every length at once, so it could not say that a
 *     headline should grow and a line of body copy should very nearly not: at
 *     1920 it drew 17px body copy at 29px. It also keys off width alone, so a
 *     1920×1080 monitor got a 1.71× page in a window that was not 1.71×
 *     taller, and the hero's calls to action fell below the fold.
 *
 *     The things that do not scale at all are the hairlines, which are one
 *     device pixel wherever they are drawn, the underline's own stroke, and
 *     the body's brass wash, which is fixed to the window rather than drawn on
 *     the page. */

/* ---- Cormorant Garamond and Jost -------------------------------------- */

/* The two families the Brass Lighthouse pages are set in: Cormorant Garamond
   for the display voice and Jost for everything the interface says. Both are
   self-hosted, so a public page makes no third-party request at all and the
   two faces first paint needs can be preloaded by name from the layout — a
   Google Fonts URL carries a hash that changes with the release and cannot be
   written into a `<link rel="preload">` by hand.

   The files are the upstream variable fonts pinned to one weight and cut to
   one Unicode range each; scripts/subset-fonts.py is what cuts them and
   static/fonts/README.md says what came out and under what licence.

   `swap` everywhere: text paints immediately in the fallback and reflows once,
   rather than sitting invisible while a font downloads. The unicode-range on
   the latin-ext faces means those files are only fetched by a page that
   actually contains an accented character — the two ranges are Google Fonts'
   own `latin` and `latin-ext`, and the same two strings are in the subsetting
   script. Change one and change the other, or the browser fetches a file that
   cannot draw the character it was fetched for.

   The fallback behind each family in tokens.css is a real stack rather than a
   bare `serif` or `sans-serif`, so the swap-in moves the page as little as it
   can: Georgia leads the serif and the system UI sans leads the sans. */

/* Cormorant Garamond, upright: 300, 400, 500 and 600. */

@font-face {
  font-family: "Cormorant Garamond";
  font-style: normal;
  font-weight: 300;
  font-display: swap;
  src: url("/static/fonts/cormorant-garamond-300-latin.woff2") format("woff2");
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA,
    U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191,
    U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}

@font-face {
  font-family: "Cormorant Garamond";
  font-style: normal;
  font-weight: 300;
  font-display: swap;
  src: url("/static/fonts/cormorant-garamond-300-latin-ext.woff2")
    format("woff2");
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7,
    U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF,
    U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}

@font-face {
  font-family: "Cormorant Garamond";
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url("/static/fonts/cormorant-garamond-400-latin.woff2") format("woff2");
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA,
    U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191,
    U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}

@font-face {
  font-family: "Cormorant Garamond";
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url("/static/fonts/cormorant-garamond-400-latin-ext.woff2")
    format("woff2");
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7,
    U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF,
    U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}

@font-face {
  font-family: "Cormorant Garamond";
  font-style: normal;
  font-weight: 500;
  font-display: swap;
  src: url("/static/fonts/cormorant-garamond-500-latin.woff2") format("woff2");
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA,
    U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191,
    U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}

@font-face {
  font-family: "Cormorant Garamond";
  font-style: normal;
  font-weight: 500;
  font-display: swap;
  src: url("/static/fonts/cormorant-garamond-500-latin-ext.woff2")
    format("woff2");
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7,
    U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF,
    U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}

@font-face {
  font-family: "Cormorant Garamond";
  font-style: normal;
  font-weight: 600;
  font-display: swap;
  src: url("/static/fonts/cormorant-garamond-600-latin.woff2") format("woff2");
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA,
    U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191,
    U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}

@font-face {
  font-family: "Cormorant Garamond";
  font-style: normal;
  font-weight: 600;
  font-display: swap;
  src: url("/static/fonts/cormorant-garamond-600-latin-ext.woff2")
    format("woff2");
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7,
    U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF,
    U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}

/* Cormorant Garamond, italic: 300 and 400. The italic is emphasis in running
   text and a pull quote; nothing on the site sets an italic heading, so the
   two heavier cuts are not held. */

@font-face {
  font-family: "Cormorant Garamond";
  font-style: italic;
  font-weight: 300;
  font-display: swap;
  src: url("/static/fonts/cormorant-garamond-300-italic-latin.woff2")
    format("woff2");
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA,
    U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191,
    U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}

@font-face {
  font-family: "Cormorant Garamond";
  font-style: italic;
  font-weight: 300;
  font-display: swap;
  src: url("/static/fonts/cormorant-garamond-300-italic-latin-ext.woff2")
    format("woff2");
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7,
    U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF,
    U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}

@font-face {
  font-family: "Cormorant Garamond";
  font-style: italic;
  font-weight: 400;
  font-display: swap;
  src: url("/static/fonts/cormorant-garamond-400-italic-latin.woff2")
    format("woff2");
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA,
    U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191,
    U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}

@font-face {
  font-family: "Cormorant Garamond";
  font-style: italic;
  font-weight: 400;
  font-display: swap;
  src: url("/static/fonts/cormorant-garamond-400-italic-latin-ext.woff2")
    format("woff2");
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7,
    U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF,
    U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}

/* Jost: 300, 400, 500 and 600, upright only. Upstream has an italic and the
   interface has nothing to set in it. */

@font-face {
  font-family: Jost;
  font-style: normal;
  font-weight: 300;
  font-display: swap;
  src: url("/static/fonts/jost-300-latin.woff2") format("woff2");
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA,
    U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191,
    U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}

@font-face {
  font-family: Jost;
  font-style: normal;
  font-weight: 300;
  font-display: swap;
  src: url("/static/fonts/jost-300-latin-ext.woff2") format("woff2");
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7,
    U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF,
    U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}

@font-face {
  font-family: Jost;
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url("/static/fonts/jost-400-latin.woff2") format("woff2");
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA,
    U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191,
    U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}

@font-face {
  font-family: Jost;
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url("/static/fonts/jost-400-latin-ext.woff2") format("woff2");
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7,
    U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF,
    U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}

@font-face {
  font-family: Jost;
  font-style: normal;
  font-weight: 500;
  font-display: swap;
  src: url("/static/fonts/jost-500-latin.woff2") format("woff2");
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA,
    U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191,
    U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}

@font-face {
  font-family: Jost;
  font-style: normal;
  font-weight: 500;
  font-display: swap;
  src: url("/static/fonts/jost-500-latin-ext.woff2") format("woff2");
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7,
    U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF,
    U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}

@font-face {
  font-family: Jost;
  font-style: normal;
  font-weight: 600;
  font-display: swap;
  src: url("/static/fonts/jost-600-latin.woff2") format("woff2");
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA,
    U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191,
    U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}

@font-face {
  font-family: Jost;
  font-style: normal;
  font-weight: 600;
  font-display: swap;
  src: url("/static/fonts/jost-600-latin-ext.woff2") format("woff2");
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7,
    U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF,
    U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}

/* ---- Document --------------------------------------------------------- */

*,
*::before,
*::after {
  box-sizing: border-box;
}

/* THE ROOT FONT SIZE, AND IT BELONGS TO THE READER.

   `100%` is font-size's initial value — the `medium` a browser resolves from
   the reader's own preference — so this is 16px for everybody who has not
   changed it and their own size for everybody who has, at every width, on
   every page. It is written out rather than left off because leaving it off
   is indistinguishable from having forgotten to think about it, and this
   declaration is the site's answer to a question it got wrong once.

   WHAT USED TO BE HERE, AND WHY IT IS NOT. The rule was

     font-size: clamp(1rem, 100vw / 70, 2000px / 70);

   which made the root unit follow the window — 16px at 1120, 20.6px at 1440,
   28.6px from 2000 — so that every rem length in tokens.css grew with it and
   the whole composition filled the window as the mockup does viewed zoomed.
   It did exactly that, and it was the wrong thing to want.

   A single ramp on the root cannot tell a headline from a line of body copy.
   Both are rem, so both grew at 1.71× on a 1920px monitor: the 80px headline
   became 137px, which is a poster, and 17px body copy became 29px, which is
   large print. Type has to grow at different rates or it is not growing, it
   is being magnified. That distinction is now made one token at a time in
   tokens.css, where it can be made honestly.

   It also keyed off width alone. A 1920×1080 window is 1.71× the mockup's
   width and 1.2× its height, so the hero was scaled by the first number in a
   window bounded by the second, and its two calls to action went under the
   fold. The hero now takes some of its vertical padding from `svh` for the
   same reason — see .hero.

   And it took the reader's preference away above 1120: the ramp overrode the
   1rem floor, so somebody who had set 20px got whatever `100vw / 70` said
   instead. Under WCAG 2.1 AA 1.4.4 that is not a failure — the page still
   scales — but it is the site deciding it knows better, which it does not.

   So: nothing on this page reads the viewport through the root unit. What
   reads the viewport is each token that should, on its own terms, and each
   component's own container width. See the head of tokens.css for the first
   and the @container rules below for the second. */
html {
  font-size: 100%;
  /* The nav anchor and the hero's 'See how it works' both jump to an id on
     this page; glide rather than teleport. Turned off again with the rest of
     the motion at the foot of this file. */
  scroll-behavior: smooth;
}

/* The shell is a column as tall as the viewport, so the footer is held at the
   bottom of the window on a page with too little in it to push it there —
   /privacy and /terms are a heading and two paragraphs, and a dark row halfway
   up the screen with white under it reads as a page that failed to load the
   rest of itself.

   This is the layout doing it and not `position: sticky` or a fixed footer:
   the row stays in the flow, is scrolled past on a long page exactly as it was
   before, and never sits over the content. `main` taking the slack below is
   the other half of it.

   The column has one item in it now and that is .page-frame, which is a column
   of the same kind: the frame fills the window, the bar and the footer are its
   first and last rows, and `main` takes the slack between them exactly as it did
   when the three were children of this rule. The frame carries no margin of its
   own at any width, so its outer size is the window's height and there is no
   scrollbar on a short page. See the Page frame section below.

   The two min-block-sizes are one value with a fallback. `svh` is the viewport
   at its smallest — the height with a phone's address bar showing — which is
   what stops the page being a hair taller than the window and scrolling by a
   few pixels for no reason; `vh` is what a browser too old for it reads
   instead, and the cost of getting the old answer is that same few pixels. */
body {
  display: flex;
  flex-direction: column;
  min-block-size: 100vh;
  min-block-size: 100svh;
  margin: 0;
  /* THE GROUND THE FRAME STANDS ON, and the two layers the mockup's body
     carries: the night itself, and a wide, shallow radial of brass hung off the
     top of the window. The numbers are the mockup's own —
     radial-gradient(1100px 520px at 50% -8%, brass at 11%, transparent 68%) —
     and the colour is a token, because app.css may not mix an alpha of its own.

     The wash is fixed rather than scrolled, so it is the light the window is lit
     by and not a mark on the top of a very long document; the colour behind it
     is the background-color, which the canvas takes whatever the attachment is.

     THERE IS NO GROUND EITHER SIDE OF THE FRAME ANY MORE. The frame is the
     viewport — see the Page frame section below — so this is the page's own
     background at every width, behind an opaque frame and the opaque bands
     inside it, and what is left of it on the glass is the canvas: the colour and
     the wash a browser paints in the overscroll a rubber-band pull opens up, and
     the colour it hands the window when the document is shorter than the frame
     is tall. The grain is the layer that really is over the page and it is a
     sibling of the frame rather than a child, which is what lets it lie over
     every band; see .page-grain.

     AND THE WASH IS THE ONE LENGTH IN THIS FILE STILL MEASURED IN PIXELS
     RATHER THAN IN THE ROOT UNIT, along with the hairlines and the 860px
     breakpoint. It is `background-attachment: fixed` and hung off 50% -8% of
     the window: it is the light the window is lit by rather than a piece of the
     composition, and it is the mockup's own pair of numbers. Scaling it with the
     root would be lighting a 2000px window four fifths harder than a 1120px
     one for no reason anybody asked for. */
  background-color: var(--color-paper);
  background-image: radial-gradient(
    1100px 520px at 50% -8%,
    var(--color-accent-ground),
    transparent 68%
  );
  background-attachment: fixed;
  color: var(--color-ink);
  font-family: var(--font-sans);
  font-size: var(--text-base);
  /* The mockup's body is the 300, and that is not a detail: it sets the weight
     of every paragraph, label and figure on the page that does not ask for
     another, and it is the difference between a page that reads as engraved and
     one that reads as an interface. Jost's 300 is on disk — see the @font-face
     rules above — so nothing here is synthesised. */
  font-weight: var(--weight-light);
  line-height: var(--leading-base);
  /* The mockup sets tabular figures on the body, so every number on the page is
     drawn on the same advance: the running tally that gains a digit five times
     a cycle, the column of prices down the quote card, and the dates. Two rules
     further down still name it, and both are now saying what the body already
     says rather than adding it. */
  font-variant-numeric: tabular-nums;
  -webkit-font-smoothing: antialiased;
}

/* The page between the bar and the footer, and what takes up whatever the
   window has left over.

   `flex: 1 0 auto` rather than the usual `flex: 1`: the basis stays the
   content's own height and the item is never allowed to shrink, so a page
   taller than the viewport is laid out as if none of this were here. Growing
   is the only thing this rule adds.

   AND IT KEEPS THE GROUND IT ALWAYS HAD, which is the one thing the frame would
   otherwise change inside itself. This box is what grows, so on a page with less
   in it than the window — /quote/received is an acknowledgement and two links,
   /privacy and /terms are a heading and two paragraphs — the slack under the
   content is this element's own background. Before the frame that was the body's
   night; without this line it would be the frame's surface, which is a step
   lighter, and /quote/received would show a band of it between the intake's foot
   and the footer's hairline. The frame is a container and not a re-colour: every
   band inside it draws exactly the surface it drew before, and so does the box
   they sit in. */
main {
  flex: 1 0 auto;
  background-color: var(--color-paper);
}

/* Nothing scrolled to should land against the top of the viewport. The nav is
   neither fixed nor sticky — see the site header section below — so this is
   breathing room rather than clearance under a bar. */
[id] {
  scroll-margin-block-start: var(--space-xl);
}

/* The display voice, and the thing the self-hosted serif was fetched for. The
   ticket that put the two families on disk pointed nothing at --font-serif, and
   said in the layout's own comment that setting the headings and the wordmark
   in it was the re-theme's work. This is that: every heading on every page the
   shell serves, in one rule, so no section carries a family of its own.

   THE WEIGHT IS THE 300, WHICH IS THE MOCKUP'S AND IS THE OPPOSITE OF WHAT WAS
   HERE. Every heading on the mockup's first frame is font-weight: 300 — the
   80px headline, the quote band's 40px, the work section's 32px and the closing
   42px — and this rule asked for --weight-bold, which is 700 and was matched to
   the 600 on disk. A Cormorant Garamond heading set in the 600 is a different
   face from the one the mockup draws: the mockup's display voice is a light
   old-style at a large size, and the heaviest cut at the same size reads as a
   masthead. The three names on the page that really are the 500 — a work card's,
   the quotation number, a release label — say so in their own sections.

   The tracking goes with it. The mockup's h2s carry none at all and its
   headline closes up by five thousandths of an em, which is --tracking-tight
   and is the hero's own rule to ask for; -0.02em on every heading was a value
   this file guessed at while the mockup was not on main. */
h1,
h2,
h3,
h4 {
  margin: 0;
  font-family: var(--font-serif);
  font-weight: var(--weight-light);
  line-height: var(--leading-snug);
  letter-spacing: var(--tracking-normal);
}

p {
  margin: 0;
}

a {
  color: var(--color-accent);
}

/* ---- Page frame ------------------------------------------------------- */

/* The frame the whole public page is drawn inside, and THE FRAME'S EDGES ARE
   THE SCREEN'S EDGES.

   Item 63 drew this as the mockup's .frame: a 1120px panel on a darker ground,
   with a hairline round it, a 3px corner and 48px of ground under its foot. That
   is what the mockup file does at 100% and it is not what the reviewer wants.
   The reference is the mockup viewed *zoomed*, so its frame fills the window: at
   2000px the same composition at roughly 1.8×, not the same 1120px composition
   with ground either side. So the panel's four properties are gone — the cap,
   the border, the corner and the foot — and what scales the composition instead
   is the root unit at the top of this file, which every length in tokens.css
   reads. Nothing moves relative to anything else; the whole page grows like a
   picture.

   ONE WRAPPER ROUND THE BAR, THE PAGE AND THE FOOTER, in the shared layout, so
   every public page is inside it — /, /quote, /quote/received, /privacy and
   /terms — and there is one definition rather than one per page. The internal
   briefs screen has a shell of its own and is not touched.

   WHAT IS LEFT OF IT IS A COLUMN, A CLIP AND A COLOUR, and no width at all.
   `inline-size: 100%` and no max-inline-size is the whole of "the frame is the
   viewport": there is nothing here that can be narrower than the window and
   nothing that can be wider, so there is no ground to show either side and no
   horizontal scrollbar to find at any width. There is no border, no radius and
   no margin at any width either — the base rule is the only rule, which is what
   the note under it used to say about the phone and is now true of every
   screen.

   THE COLOUR STAYS ITEM 63's --color-frame, and it is deliberately not the
   darker --color-paper. In the mockup viewed zoomed the card fills the window
   and its fill is all that is ever seen, so this is the value the reviewer has
   been approving against; repainting the box the night on the reasoning that it
   is the page now would be a colour change, and this ticket changes no colour.
   It is still a container and not a re-colour: every band inside keeps exactly
   the surface it had, and `main` keeps the page's own ground under the slack on
   a short page.

   IT IS A COLUMN, LIKE THE BODY IT REPLACED AS ONE. The bar is its first row,
   the footer its last, `main` grows between them, and `flex: 1 0 auto` is what
   fills a window with more height than the page has content — the same pair of
   rules the body and `main` carried before, one level down. See the note above
   `body`.

   OVERFLOW: HIDDEN IS THE CLIP THE MOCKUP USES, and it is what keeps the hero's
   40rem corner fog and every other absolutely positioned decoration inside the
   window instead of widening the document. Nothing inside is sticky or fixed,
   so there is nothing for this to catch: the bar is neither (see the site header
   section), the grain is fixed and is a sibling of this box rather than a child,
   and the skip link is absolute and sits outside the frame in the layout for the
   same reason.

   AND IT IS NOT A STACKING CONTEXT. `overflow: hidden` does not open one and
   nothing here sets a z-index, an opacity or a transform, so the bar's --z-nav
   and the grain's --z-grain still meet in the root stacking context: the noise
   lies over every band inside the frame and under the bar, exactly as it did. */
.page-frame {
  display: flex;
  flex: 1 0 auto;
  flex-direction: column;
  overflow: hidden;
  inline-size: 100%;
  background-color: var(--color-frame);
}

/* ---- Page grain -------------------------------------------------------- */

/* The layer the fractal noise is painted on: one still sheet of it over the
   window, so the warm-night surfaces under it read as a material rather than as
   void.

   The drawing is in templates/layouts/base.html and the paint is here, which is
   the split the headline underline and the hero illustration are written with.
   It is in the shared shell rather than on the home page because the brief
   describes the grain as a property of the page surface: / and /quote and
   /quote/received wear the same texture from one layer, and there is no second
   copy to come apart from this one.

   ONE LAYER, AND NOTHING PER COMPONENT. No card, panel, button or illustration
   carries grain of its own. The noise is over the page, so a second sheet on
   something standing on the page would be the grain at twice the strength in
   exactly the place the eye is looking.

   FIXED, NOT ABSOLUTE. The grain belongs to the window a visitor is looking
   through rather than to the document's full height: fixed is one screen's
   worth of noise, rasterised once and carried along with the scroll, where an
   absolute sheet as tall as the home page is several times the area of filter
   to paint for a texture nobody can tell apart from itself.

   OVER THE BANDS AND UNDER THE BAR. --z-grain is the step tokens.css puts
   between them, so the noise lies over every surface the page draws — the hero,
   the quote band, the work section, the closing call to action and the footer —
   and under the navigation bar, which takes --z-nav in the site header section
   below, and under the skip link, which was already above both.

   IT INTERCEPTS NOTHING, and pointer-events: none is the whole of that: every
   hover, click and tap passes through this sheet to whatever is under it. There
   is nothing focusable inside it either — see the markup — so the tab order
   from the bar through the hero's two calls to action and down to the footer is
   the order it was before the layer existed.

   FIVE PER CENT. Any more and the grain is a texture somebody notices instead
   of a surface they do not; any less and the dark bands are the void it is here
   to take off them.

   NOTHING IN HERE MOVES. The sheet is static, so there is no animation for the
   prefers-reduced-motion block at the foot of this file to collapse, and a
   visitor who has asked for less motion is shown exactly this. */
.page-grain {
  position: fixed;
  z-index: var(--z-grain);
  inset: 0;
  /* The insets place it and these two size it. An <svg> is a replaced element,
     so `auto` here would be the drawing's own intrinsic size rather than the
     stretch a <div> between four zero insets would get. */
  inline-size: 100%;
  block-size: 100%;
  pointer-events: none;
  opacity: 0.05;
}

/* ---- Focus ------------------------------------------------------------ */

/* One visible ring for every focusable thing, keyboard only (WCAG 2.1 AA
     2.4.7), and it is the mockup's own: a 1px lit-brass outline held 4px off,
     which is the single focus rule that file spends on every button and every
     anchor it draws. A section that needs a different shape overrides the
     radius, not the presence.

     IT WAS 0.1875rem OF BEAM BLUE HELD 0.125rem OFF, which is a band rather
     than a drawn edge and is not what the mockup specifies. The accessibility
     pass is what brought the two together: the button system and the intake
     form had already put the mockup's ring on the controls they own, so the
     page was carrying two rings and one of them was nobody's design.

     THE WIDTH IS A HAIRLINE AND STAYS IN PIXELS; THE OFFSET IS THE ROOT UNIT
     AND SCALES — the split .button:focus-visible already made, and the reason
     it applies here now. The line really is one device pixel, which is what
     makes this a pen line round a control rather than a band beside it; and
     0.25rem is the 4px it is drawn at at the mockup's own width, growing with
     the type it rings so the gap does not close up at 2000.

     THE OFFSET IS ALSO WHAT LETS ONE COLOUR DO THE WHOLE PAGE. Held 4px off,
     the ring is drawn on the surface behind the control instead of on its
     face: 11.6:1 on the page and 8.5:1 on the top panel step, past WCAG 2.1 AA
     1.4.11's 3:1 everywhere a control can stand — including on the brass call
     to action, where the same colour on the button's own face would be
     1.6:1. */
:focus-visible {
  outline: 1px solid var(--color-focus);
  outline-offset: 0.25rem;
}

/* ---- Skip link -------------------------------------------------------- */

/* Visible only on focus: the first stop for a keyboard user (WCAG 2.1 AA).

   The chip step and a lit hairline round it, rather than the dark slab it used
   to be. The slab was a dark rectangle dropped on a white page, which is what
   made it a chip; over a warm-night page it is a step the eye does not catch,
   and a skip link nobody can see is a skip link that is not there. So it takes
   the top of the surface ladder — --color-paper-raised-3, which tokens.css
   names for a chip — and the hairline is what draws its edge, because even the
   top step is only 1.4:1 against the page it sits over. The cream on it is
   11.5:1, so the words clear WCAG 2.1 AA 1.4.3 with room. */
.skip-link {
  position: absolute;
  left: -9999px;
  z-index: var(--z-skip-link);
}

.skip-link:focus {
  left: var(--layout-gutter);
  top: var(--space-2xs);
  display: inline-block;
  padding: var(--space-2xs) var(--space-sm);
  border: 1px solid var(--color-line-strong);
  border-radius: var(--radius-md);
  background-color: var(--color-paper-raised-3);
  color: var(--color-ink);
  font-weight: var(--weight-semibold);
  text-decoration: none;
}

/* ---- Visually hidden --------------------------------------------------- */

/* Text for a screen reader and for nothing else: taken out of the flow and
   clipped to nothing, rather than switched off. display: none and
   visibility: hidden both remove an element from the accessibility tree as
   well as from the page, which is the opposite of what this is for.

   The standard clip-rect shape, and every line of it earns its place: the 1px
   box with the -1px margin is what keeps a clipped element from being skipped
   by browsers that ignore a zero-sized one, the overflow is what holds the
   text inside that box, `clip` is the old rule and `clip-path` the current
   one, and the nowrap stops the text being folded into a one-character-wide
   column, which some screen readers read out letter by letter. */
.visually-hidden {
  position: absolute;
  inline-size: 1px;
  block-size: 1px;
  margin: -1px;
  padding: 0;
  overflow: hidden;
  clip: rect(0 0 0 0);
  clip-path: inset(50%);
  border: 0;
  white-space: nowrap;
}

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

/* The three shapes a call to action on this site comes in: the solid brass
   primary, the ghost that stands beside it and the quiet one under both. Most
   of them are anchors — a call to action here usually navigates somewhere — so
   the padding, the typeface and the suppressed underline are set here rather
   than inherited from a <button>.

   One typographic treatment across all three, from the mockup: the sans in
   uppercase at 12px, tracked far enough that the capitals do not close up, and
   a 2px corner that reads as cut rather than rounded. The family is
   --font-sans, so this is Jost wherever the self-hosted face is on the page and
   the fallback sans at the same size and tracking wherever it is not — which is
   what a fallback is for, not a defect.

   The face is the whole of what says which of the three a button is, and every
   state is a step on a ladder tokens.css already has: brass, then brass with
   the light on it; the brass wash behind the ghost; the panel steps under the
   quiet one. Nothing here is a colour mixed for a button, and no hex is typed
   in.

   Order matters at the foot of the section: :disabled is last so it beats the
   :hover and :active rules above it, which some browsers still match on a
   disabled control. */

.button {
  display: inline-block;
  /* The mockup's 15px 28px, on the 4px grid: 16px up and down, 24px each side.
     A button on this page is a wide, shallow slab of brass rather than a chip,
     and the padding is most of what says so. */
  padding: var(--space-sm) var(--space-md);
  border: 1px solid transparent;
  border-radius: var(--radius-xs);
  font-family: var(--font-sans);
  font-size: var(--text-2xs);
  /* The 500, which is the mockup's .btn and the heaviest weight anything on its
     first frame is set in. The 600 that was here is a cut heavier than the
     mockup draws and closed the tracked capitals back up. */
  font-weight: var(--weight-medium);
  letter-spacing: var(--tracking-wider);
  line-height: var(--leading-snug);
  text-decoration: none;
  text-transform: uppercase;
  transition: background-color var(--duration-fast) var(--ease-out),
    border-color var(--duration-fast) var(--ease-out),
    color var(--duration-fast) var(--ease-out);
}

/* The primary: a solid brass fill, and the only word on the site that sits on
   brass. The cream is 2.2:1 there and --color-gold-ink is 7.0:1, which is what
   that token exists for. The border stays transparent — the fill is painted
   under it, so all three variants are the same box at the same height. */
.button--primary {
  background-color: var(--color-gold);
  color: var(--color-gold-ink);
}

/* Under the pointer the light comes on: the lit brass, one step along the same
   ladder, with the gold ink at 11.2:1 on it. Pressed, the light goes off it
   again rather than a fourth colour being invented for the press. */
.button--primary:hover {
  background-color: var(--color-gold-hover);
}

.button--primary:active {
  background-color: var(--color-gold);
}

/* The secondary: a ghost. No fill, the lit hairline as its edge, and the lit
   brass as its word — 11.0:1 on the slab it stands on in the bar and the hero,
   and past 4.5:1 on every other step of the surface ladder. */
.button--ghost {
  border-color: var(--color-line-strong);
  background-color: transparent;
  color: var(--color-accent-on-slab);
}

/* Hovered, the ghost fills with the brass wash and its edge comes up to the
   brass itself; pressed, it settles onto a panel step. Both of those are
   tokens that exist for exactly this. */
.button--ghost:hover {
  border-color: var(--color-accent);
  background-color: var(--color-accent-wash);
}

.button--ghost:active {
  background-color: var(--color-paper-raised-2);
}

/* The tertiary: the quiet one. No fill, no edge, and the second cream step —
   there to be read, not to be answered. It takes a panel step under the
   pointer and the one above it under the press, and its word comes up to the
   full cream with them. */
.button--quiet {
  border-color: transparent;
  background-color: transparent;
  color: var(--color-ink-muted);
}

.button--quiet:hover {
  background-color: var(--color-paper-raised-2);
  color: var(--color-ink);
}

.button--quiet:active {
  background-color: var(--color-paper-raised-3);
}

/* The ring, and the keyboard only (WCAG 2.1 AA 2.4.7): a hairline of lit brass
   held a quarter of the root unit off the button. The offset is what keeps the
   ring off the brass face altogether — the lit brass is 1.6:1 against it — so
   the line is drawn on the surface behind the button, where
   --color-focus-inverse is 3:1 or better on every step of the ladder. The ring
   moves with the token, so no button carries a colour of its own for it.

   IT IS NO LONGER A DEPARTURE FROM THE SITE'S RING; IT IS THE SITE'S RING,
   WRITTEN OUT. This declaration was the mockup's outline on the one control the
   site's own 0.1875rem blue band could not be drawn on, and the accessibility
   pass moved the whole page onto the same rule — see :focus-visible at the top
   of this file, which is now the same 1px and the same 0.25rem. The two names
   are what stays apart: a button reads --color-focus-inverse, which tokens.css
   keeps for the ring on a brass fill, so the day a brass button needs a
   different ring from the page there is somewhere for it to move.

   THE WIDTH IS A HAIRLINE AND STAYS IN PIXELS; THE OFFSET IS THE ROOT UNIT AND
   SCALES. The line really is one device pixel — that is what makes this ring a
   drawn edge rather than a band — and 0.25rem is the 4px it has always been at
   the mockup's own width, growing with the button it is held off so the gap
   does not close up at 2000. */
.button:focus-visible {
  outline: 1px solid var(--color-focus-inverse);
  outline-offset: 0.25rem;
}

/* Disabled, and still legible: a panel step with the muted cream on it, which
   is past 4.5:1, rather than the whole button faded to an opacity that drags
   its own text under that on the way down. It reads as a control that is not
   available now, which is what a disabled submit is. */
.button:disabled {
  border-color: var(--color-line-strong);
  background-color: var(--color-paper-raised-2);
  color: var(--color-ink-muted);
}

/* ---- Site header ------------------------------------------------------ */

/* The navigation bar: the wordmark on the left, the three links and the ghost
   call to action on the right.

   It is the page, and a lit hairline along the bottom of it. The bar used to be
   the slab — a dark rectangle over a white page — and the hero under it was the
   same rectangle, so the two read as one band with nothing between them. On a
   warm-night page there is no rectangle to drop: the bar and the hero are both
   simply the top of the page, and what says where the bar ends is a rule rather
   than a change of colour. --color-line-strong and not --color-line, because
   this is a rule that has to be seen rather than felt: it is the only thing
   drawing the bar on /quote, /privacy and /terms, where what sits under it is
   the page as well and there is no band below to step down from.

   Everything in the row is the page's own ink, from the body. Nothing here is
   inverted any more, so no rule in this section names an -inverse token and the
   focus ring the whole site uses is the ring the bar gets — the lit brass is
   11.6:1 on the page, where on the old white-page slab the blue it replaced was
   2.8:1 and the bar had to override it.

   Not sticky, and not fixed. §2 does not ask for it, the bar does not fall out
   of the shell's layout wanting it, and a bar that is neither cannot sit over
   the hero headline on the first paint.

   Narrow first, like the rest of the file: the base rules are the collapsed
   bar — the wordmark, the call to action and the menu button, with the three
   text links in the panel the button opens — and the `@container` block at the
   foot of this section is the one row HP-02 draws, with no menu button in it
   and no panel. It asks the bar's own width, which is the width the row either
   fits in or does not: 44rem, or about a 780px window once the gutters either
   side of the bar are taken off.

   The row wraps at either width when there is no room for it. Below about
   420px there is not: the wordmark, the ghost call to action and the menu
   button are around 325px of fixed width before any gap, and a 360px phone has
   312px between the gutters. The button drops to a second line under the call
   to action there — see the justify-content on .site-nav for what keeps it
   under the call to action rather than under the wordmark. Fitting the three
   of them on one line at 360px would mean a smaller wordmark or a tighter
   call to action, and both of those are HP-02's to settle rather than this
   ticket's. */

/* The bar, and the one band the page grain does not cross. The sheet of noise
   is fixed over the window at --z-grain and this is what lifts the bar above it
   — the first rule in the file to read --z-nav, which tokens.css has carried
   since the stacking steps were written down.

   `position: relative` is there only to make that step count, because a z-index
   on a static box does nothing. It takes the bar out of nothing: the row is
   still in the flow, still neither sticky nor fixed, and not a pixel of it
   moves. See .page-grain for the layer on the other side of the step.

   THE INSET IS ON THE BAND AND THE WIDTH IS ON THE WRAPPER, which is the shape
   every other band on this site is built in — see .hero and .hero__inner, the
   quote band, the work section, the closing call to action and the footer. The
   band is full width, carries the page's background and its hairline, and holds
   the gutter; the wrapper inside it is --layout-max wide and centred, and that
   is the content line.

   IT WAS BOTH ON ONE ELEMENT HERE, and that is what parted the bar from the
   hero. A max-width and a padding on the same box are a border-box measurement:
   .site-nav was 1024px wide *including* two 48px gutters, so its content ran
   928px and started 48px inside the line the hero's copy starts on. At 1440 the
   wordmark sat 48px right of the eyebrow and "Get a quote" 48px left of the
   right-hand edge of the hero art, and the header read as the top of a
   different page. Split across the two elements the gutter is outside the
   column, the column is the mockup's 1024, and the two bands agree at every
   width.

   Nothing here is a nudge and there is no number: both values are the tokens
   tokens.css keeps for them, so the day the content column or the gutter moves,
   the bar moves with the page rather than against it. */
/* The band is a query container, so what is inside it can ask how much room it
   has without either of them knowing how wide the window is. See the note over
   the first @container rule below. */
.site-header {
  container: band / inline-size;

  position: relative;
  z-index: var(--z-nav);
  padding-inline: var(--layout-gutter);
  border-block-end: 1px solid var(--color-line-strong);
  background-color: var(--color-paper);
}

.site-nav {
  display: flex;
  flex-wrap: wrap;
  gap: var(--space-md);
  align-items: center;
  /* The wordmark at one end of the row and everything else at the other. The
     auto margin on the wordmark below is what does that; this is what the
     second line falls back on once the row wraps, and it is why the pair are
     not the space-between that did the job while the row never wrapped in
     practice. A wrapped line here carries one item — the menu button, on a
     narrow phone — and space-between would leave it at the near end, under the
     wordmark, rather than under the call to action it belongs beside. Nothing
     moves at 860px and wider: the auto margin takes the free space, and there
     is none left for either of them to distribute. */
  justify-content: flex-end;
  /* The content column, and the wordmark's left edge is its left edge: the mark
     is the first thing in .site-nav__wordmark, the anchor has no padding of its
     own, and the name follows at the mockup's 12px gap. See .site-header above
     for why the gutter is not on this rule. */
  max-width: var(--layout-max);
  margin-inline: auto;
  /* The mockup's 26px, on the 4px grid. The bar was half that and read as a
     strip rather than as the top of a page. */
  padding-block: var(--space-md);
}

.site-nav__wordmark {
  display: inline-flex;
  /* The mockup's 12px between the mark and the name. */
  gap: var(--space-xs);
  align-items: center;
  /* See .site-nav: this is what holds the wordmark at its end of the row and
     everything else at the other. */
  margin-inline-end: auto;
  color: var(--color-ink);
  /* The display voice, like the headings: the wordmark is the one piece of the
     shell that is a name rather than a piece of interface, and the serif is
     what tokens.css keeps for it. */
  font-family: var(--font-serif);
  /* The mockup's 23px, 500, tracked open by .06em. It was 19px in the 600 with
     the letters pulled together, which is the same words drawn as a heading
     rather than as a name on a plate — and the tracking was the wrong way
     round: a wordmark opens up, it does not close. */
  font-size: var(--text-xl);
  font-weight: var(--weight-medium);
  letter-spacing: var(--tracking-open);
  text-decoration: none;
}

/* The lighthouse. `flex: none` so it keeps its size when the row is tight,
   rather than being squeezed into an ellipse beside the name it belongs to.

   The lit brass, which is the colour the mockup draws its own spark in —
   `.spark path{stroke:var(--brass-lit)}`, and the one its navTurn loop returns
   to at the top of every cycle. It was the plain brass, a step under it, which
   is the drift this pass is here to take out. Not the mint either: the mint is
   the one colour on the page that is not the brand's, and tokens.css keeps it
   for the word the headline emphasises and the pipeline's finished nodes.
   11.6:1 on the page, well past what WCAG 2.1 AA 1.4.11 asks of a mark.

   One colour and one declaration, because the drawing names none: every fill in
   the wordmark block is currentColor, so this is the whole of what makes the
   mark lit brass here and the footer's copy of it its own colour there.

   THE NINE SECONDS ARE DECLARED HERE, on the mark itself, because two pieces of
   it turn on them: the beams and the lamp. A custom property inherits, so both
   read this one — declared on either of them it would be a number the other
   could not see, and two copies of a duration are two things to keep in step.
   See .site-nav__spark-beams below for what the loop is in step with. */
.site-nav__spark {
  --spark-breath: 9s;

  flex: none;
  color: var(--color-accent-bright);
}

/* THE MARK'S BOX IS ONE EM, IN BOTH COPIES, and that is what lines it up with
   the name beside it.

   The mockup ties the two together — `.spark{width:23px;height:23px}` beside
   `font-size:23px` — so the mark is exactly as tall as the type it stands in,
   and the mockup's own drawing occupies rows 13 to 52 of its 64-unit box, which
   is the middle 61% of it. Centred on the line box the two share, that puts the
   lantern's roof on the cap height and the tower's foot on the baseline of the
   words.

   This was a fixed 24px against 22px type, with a drawing that filled its own
   box rather than sitting in the middle of it: the mark came out half again as
   tall as the capitals and hung two pixels below the line the letters stand on.
   The drawing is now the mockup's, air and all — see the wordmark block in the
   layout — and this is the other half of the arithmetic. In em rather than
   pixels, so a wordmark set at another size takes the mark with it and the two
   cannot come apart again. Nothing else moves the mark: there is no margin, no
   translate and no padding on it anywhere, because with the mockup's drawing in
   a 1em box there is no difference left for one to make up.

   The 24px width and height on the svg are the intrinsic size behind this: what
   a browser draws the mark at with no stylesheet, and nothing else.

   AND THE MARK IS A STROKED DRAWING, NOT A FILLED ONE. The five paint
   properties under the box are the mockup's `.spark path` rule: fill none, the
   brass at 2.4 with round ends and round corners. It was a set of currentColor
   fills written onto each shape in the markup, which is what a silhouette needs
   and a line drawing does not.

   They are set here, on the svg, rather than on the paths, because all five are
   inherited: every path in the mark takes them, and the beams below can still
   carry the mockup's own thinner line by setting one of them on their group.
   Written as `.site-nav__spark path` the direct match would beat that
   inheritance and there would be one stroke width for the whole mark.

   currentColor rather than the token, because the colour is the row's: the bar
   and the footer each set it once on their own copy — above, and in the
   footer's own section — and the drawing itself names nothing. */
.site-nav__spark,
.site-footer__spark {
  inline-size: 1em;
  block-size: 1em;
  fill: none;
  stroke: currentColor;
  stroke-width: 2.4;
  stroke-linecap: round;
  stroke-linejoin: round;
}

/* The three layers that turn, in both copies of the mark. It is one drawing
   rendered twice — see the wordmark block in the layout — so what each layer is
   worth is written once here rather than in the bar's section and again in the
   footer's, and the two cannot come apart.

   THE MOCKUP'S OWN THREE RANGES, one per layer, each written as the pair of
   custom properties the breath below reads:

   The beams are navBeam — nothing at the ebb, half at the top — and the
   mockup's own 1.8 stroke, a thinner line than the tower's 2.4: they are the
   light and the tower is the mark, and beams at the tower's weight read as a
   bow tie rather than as a lamp lit. They bottom out at zero because the ebb is
   the lamp pointed away and there is nothing left of a beam to see.

   The lantern pane is navLamp — the lit brass at a quarter when it is on and
   nothing when it is not. It is the one filled thing in the mark and carries no
   stroke of its own, so the whole element can be breathed by opacity and the
   pane comes up as glass lighting rather than as an outline blinking.

   The tower is navTurn, which the mockup writes as a colour: it swings the
   stroke between a darker brass at the ebb and the lit brass at the top. Here
   it is the same event as an opacity, so the palette stays in tokens.css and
   there is no second brass typed into this file to keep in step with it. 0.45
   is where the mockup's darker tone lands — the lit brass at 0.45 over the page
   reads at the lightness that tone does, by the 0.2126/0.7152/0.0722 weighting
   — and the tower never goes out, because it is the mark. */
.site-nav__spark-beams,
.site-footer__spark-beams {
  --spark-beam-dim: 0;
  --spark-beam-lit: 0.5;

  opacity: var(--spark-beam-lit);
  stroke-width: 1.8;
}

.site-nav__spark-lamp,
.site-footer__spark-lamp {
  --spark-beam-dim: 0;
  --spark-beam-lit: 0.25;

  opacity: var(--spark-beam-lit);
  fill: currentColor;
  stroke: none;
}

.site-nav__spark-tower,
.site-footer__spark-tower {
  --spark-beam-dim: 0.45;
  --spark-beam-lit: 1;

  opacity: var(--spark-beam-lit);
}

/* The breath, and only in the bar: the footer's copy of the mark is at the foot
   of the page under the last row of links, where a light turning is something
   moving in the corner of the eye for no reason. The rule above is what leaves
   it standing at the lit end.

   THE NINE SECONDS, AND WHAT THEY ARE IN STEP WITH. The same duration as
   .hero-lighthouse's --lighthouse-breath, with no animation-delay on either:
   both start at the document's timeline origin and neither is ever restarted,
   so the mark in the bar and the illustration in the hero breathe together
   without anything synchronising them. Give either a delay and the pair is
   broken; give either a different duration and it is broken more slowly. The
   two numbers are written down twice because the two sections own their own
   motion — if one moves, the other moves with it.

   One cycle in nine seconds is 0.11Hz, three hundred times under the three
   flashes a second WCAG 2.1 AA 2.3.1 draws the line at, and the ease either
   side means there is no edge in it to flash on.

   THREE LAYERS, ONE LOOP, ONE SET OF KEYFRAMES. The mockup turns all three on
   the same nine seconds with the same stops — navBeam, navLamp and navTurn — so
   they are written as three rules running one animation over the pair of custom
   properties each declares for itself, which is the shape the hero
   illustration's own layers are written in. The duration is --spark-breath,
   inherited from .site-nav__spark above, so no rule carries a number another
   could drift from. */
.site-nav__spark-beams {
  animation: site-nav-spark-breathe var(--spark-breath) var(--ease-in-out) infinite;
}

.site-nav__spark-lamp {
  animation: site-nav-spark-breathe var(--spark-breath) var(--ease-in-out) infinite;
}

.site-nav__spark-tower {
  animation: site-nav-spark-breathe var(--spark-breath) var(--ease-in-out) infinite;
}

/* A light turning: down, full, down, over the nine seconds. The two ends are
   read off the layer being animated rather than written in here, which is the
   shape the hero's own keyframes are written in — the numbers belong with the
   layer that runs them, and one keyframe pair gives the beams their nought to a
   half, the lantern its nought to a quarter and the tower its dimmed brass back
   to full. */
@keyframes site-nav-spark-breathe {
  from,
  to {
    opacity: var(--spark-beam-dim);
  }

  50% {
    opacity: var(--spark-beam-lit);
  }
}

/* Asked for less motion: the mark is still, and it is all there. Every one of
   the three layers is drawn and held at the lit end of its own range, which is
   the value the rules above already carry — the only thing taken away is the
   loop. `animation: none` rather than the blanket rule at the foot of this
   file, which collapses the duration to a hundredth of a millisecond and so
   leaves a loop running very fast rather than one not running at all. The
   opacity is restated under it so what is served here reads as a state rather
   than as whatever the cascade leaves behind. */
@media (prefers-reduced-motion: reduce) {
  .site-nav__spark-beams {
    animation: none;
    opacity: var(--spark-beam-lit);
  }

  .site-nav__spark-lamp {
    animation: none;
    opacity: var(--spark-beam-lit);
  }

  .site-nav__spark-tower {
    animation: none;
    opacity: var(--spark-beam-lit);
  }
}

.site-nav__links {
  display: flex;
  flex-wrap: wrap;
  /* The mockup's 34px between the links. */
  gap: var(--space-lg);
  align-items: center;
  margin: 0;
  padding: 0;
  list-style: none;
}

/* The three text links, in the mockup's treatment: the sans in capitals at the
   smallest step, tracked open, in the muted cream — and not the sentence-case
   17px semibold they were, which read as body copy that happened to be in a bar.
   The size and the tracking are what tell them from the ghost call to action
   beside them, which is one step wider at .13em and is the only thing in this
   row with an edge round it.

   Brass under the pointer, which is the mockup's own hover and is the move the
   ghost button beside them makes with its border — one idea of what hovering a
   thing in this bar looks like. Both ends of it clear WCAG 2.1 AA 1.4.3 on the
   page: the muted cream is 9.3:1 there and the lit brass 11.6:1. */
.site-nav__link {
  color: var(--color-ink-muted);
  font-size: var(--text-2xs);
  font-weight: var(--weight-regular);
  letter-spacing: var(--tracking-caps);
  text-decoration: none;
  text-transform: uppercase;
  transition: color var(--duration-fast) var(--ease-out);
}

.site-nav__link:hover {
  color: var(--color-accent-hover);
}

/* The one button in the bar sits tighter than a button in a band: the mockup
   pulls .nav .btn in to 11px 20px from the 15px 28px it draws everywhere else,
   so the row stays the height of the wordmark rather than the height of a call
   to action. Nothing else about it is this section's — the face, the ring and
   the type are the button system's. */
.site-nav__cta {
  padding: var(--space-xs) var(--space-sm);
}

/* The three text links leave the row below the breakpoint, where the panel
   carries them instead. Only the copy inside .site-nav__links is hidden: the
   list item without the class is the call to action, which stays in the bar.

   The class on the bar is app.js's, and this rule waits for it on purpose. A
   visitor whose JavaScript never arrives is never shown the menu button —
   which would open nothing — so the links have to stay where they are for
   them, and the row wraps with all four destinations on it as it did before
   there was a menu at all. */
.site-nav--collapsible .site-nav__links > .site-nav__item {
  display: none;
}

/* The menu button. Its glyph is the only thing in it, so the padding is what
   makes it a target rather than a 24px square: 48px, which clears WCAG 2.2's
   24px minimum several times over. It used to stand the same height as the
   47px ghost button beside it; the button system's 12px type makes that one
   about 41px now. STILL OWED: the shell re-theme was colour, type and rule work
   on the existing structure and was told to re-lay-out nothing, so the seven
   pixels are still there — squaring the row up is a padding change and belongs
   to whoever owns the bar's measurements. Muted ink to full ink under the
   pointer, like the links it opens.

   `border: 0` and `background-color: transparent` are the <button> element's
   own face being taken off — it is the links' colours it wears, not a
   control's. */
.site-nav__toggle {
  display: inline-flex;
  align-items: center;
  justify-content: center;
  padding: var(--space-xs);
  border: 0;
  border-radius: var(--radius-md);
  background-color: transparent;
  color: var(--color-ink-muted);
  cursor: pointer;
  transition: color var(--duration-fast) var(--ease-out);
}

.site-nav__toggle:hover {
  color: var(--color-ink);
}

/* The panel: the three links stacked in reading order under the bar, in the
   bar's own type and colours. `flex-basis: 100%` is what gives it a line of
   its own — .site-nav wraps, and this is the only thing in it asking for the
   whole width — and the nav's own gap is the space above it.

   Each link is a block rather than a word, so a tap that lands beside the text
   still lands on the link. */
.site-nav__menu {
  display: flex;
  flex-basis: 100%;
  flex-direction: column;
  gap: var(--space-2xs);
  margin: 0;
  padding: 0;
  list-style: none;
}

.site-nav__menu .site-nav__link {
  display: block;
  padding-block: var(--space-2xs);
}

/* The button and the panel are both `hidden` in the markup, and the two
   display rules above would otherwise beat the browser's own `[hidden]` rule —
   author styles win over the user agent's whatever their specificity. Without
   this the button would be on the page before app.js could take charge of it
   and the panel would be open before anything opened it. */
.site-nav__toggle[hidden],
.site-nav__menu[hidden] {
  display: none;
}

/* THERE IS NO RING OVERRIDE IN THIS SECTION ANY MORE, and that is the whole of
   what used to be here. The bar carried `outline-color: var(--color-focus-
   inverse)` because the blue ring was 2.8:1 on the white page's dark slab and
   could not be seen on it. The bar is the page now and the site's one ring is
   the mockup's lit brass at 11.6:1 there, so the :focus-visible rule at the top
   of this file is the ring the wordmark, every link and the menu button in the
   bar get, and there is one fewer thing that can come apart from it (WCAG 2.1
   AA 2.4.7).

   The ghost call to action wears the button system's own copy of that ring,
   which is the same 1px held the same 0.25rem off — see .button:focus-visible
   for why the name it reads stays a separate one. */

/* THE FIRST @container RULE, AND THE NOTE FOR ALL OF THEM.

   This is where the site's layout changes shape, and it asks the band it is in
   how wide the band is rather than asking the browser how wide the window is.

   WHY NOT `@media (min-width: 860px)`, WHICH IS WHAT THIS WAS. Two reasons,
   and the second is the one that matters.

   The small reason is that 860 was never the number anything here cared
   about. The bar collapses because a wordmark, three links and a button stop
   fitting on one line, which happens at a width of the bar; the hero splits in
   two because there is room for a column of copy and a column of drawing,
   which is a width of the hero. The window was standing in for both, and it
   stood in badly: every band has a gutter either side of it, so the thing
   being measured was always about 50px narrower than the thing being asked
   about, and nobody could say which 50px.

   The large reason is that a rule keyed to the window is only correct where it
   was first written. Put the quote band in a narrower page, a sidebar or a
   two-column layout later and it is still asking the window, so it still
   splits into two columns in a 400px column and overflows. A rule keyed to the
   container is correct wherever the component is put, which means the
   component can be put somewhere else without anybody rereading its
   stylesheet.

   HOW IT IS WIRED. Each band carries `container: band / inline-size`, which
   names it and says its inline size can be queried. `@container band (…)`
   then resolves to the nearest ancestor with that name, so every rule below
   reads the band it is actually inside. The thresholds are in rem, which in a
   container query is the root font size — the reader's own — so a reader at
   20px gets the wider layout a little sooner, which is the right way round.

   AND THE THRESHOLDS ARE DIFFERENT FROM EACH OTHER ON PURPOSE. There is no
   single number any more and there should not be: 34rem is what a row of
   footer links needs, 44rem is what five pipeline nodes need, 47rem is what
   two columns of anything need. Under the old rule all three were 860px
   because 860px was the only number available. */

@container band (min-width: 44rem) {
  /* HP-02's bar, and nothing of the collapsed one: the three text links are
     back in the row, and neither the button nor the panel is drawn.

     `display: none` on the panel is also what closes a menu that was opened on
     a narrow window which is then widened — the links are in the row again, so
     the copy in the panel goes out of the tab order and out of the
     accessibility tree with it, and there is no resize listener to write. */
  .site-nav--collapsible .site-nav__links > .site-nav__item {
    display: revert;
  }

  .site-nav__toggle,
  .site-nav__menu {
    display: none;
  }
}

/* ---- Hero ------------------------------------------------------------- */

/* The copy column and its two calls to action. The headline underline is the
   section below this one, and the pipeline animation the one after it.

   The page, and the first band of the ladder the home page runs down: page,
   page, frame, page, frame, page. It used to be the slab — the dark rectangle a
   white page needed to make the top of the site read as anything — and there is
   nothing left for that rectangle to do now that the page is the warm night
   itself. The bar above it is the same surface and is told apart by its
   hairline; the quote band below it is one step up, which is what makes it a
   band.

   The ink is the body's. Nothing here is inverted, so no rule in this section
   names an -inverse token and the site's own focus ring is the one the two
   calls to action stand on. */

/* The band, and the fog in the corner of it.

   The three declarations above the padding are here for the wash below and for
   nothing else. `position: relative` is what the pseudo-element is placed
   against; `overflow: hidden` is what keeps a 40rem circle hung off the
   top-right corner from widening the document into a horizontal scroll; and the
   `z-index: 0` makes this band a stacking context, which is what lets the wash
   sit at -1 and so behind the headline rather than over it. None of the three
   takes the hero out of the flow or moves a pixel of what is in it. */
/* The band is a query container, so what is inside it can ask how much room it
   has without either of them knowing how wide the window is. See the note over
   the first @container rule below. */
.hero {
  container: band / inline-size;

  position: relative;
  z-index: 0;
  overflow: hidden;

  /* THE ONE PLACE ON THE PAGE THAT READS THE WINDOW'S HEIGHT, and the reason
     it does is the defect that started this pass.

     Every other distance on this page is decided by how wide the window is,
     which is right for a column of text and wrong for exactly one thing: the
     band a visitor sees before they scroll. The hero is a headline, a
     paragraph, two buttons and a five-node stepper, and whether all of that
     is above the fold is a question about height. A 1920x1080 monitor is the
     common case where the two disagree — 1.7x the mockup's width, 1.2x its
     height — and on it the old rule scaled the hero by the width and pushed
     'Send your requirements' off the bottom of the screen.

     8svh is the whole fix: about 86px of padding top and bottom on a 1080px
     screen, 64px on a short laptop, 128px on a tall desktop, and the band's
     own content deciding the rest. The clamp's ends are the spacing scale's,
     so this is still the site's air and not a number invented here.

     svh and not vh, because vh on a phone is the viewport with the browser's
     own chrome hidden — the large viewport — so a vh-padded band is taller
     than the screen it is on until the address bar scrolls away. svh is the
     small viewport, which is what is actually visible when the page loads. */
  padding-block: clamp(var(--space-2xl), 8svh, var(--space-4xl));
  padding-inline: var(--layout-gutter);
  background-color: var(--color-paper);
}

/* THE FOG. The mockup's .hero::after, read off it as it renders: a 640px circle
   of brass at 16%, its centre held 260px above the top of the band and 160px
   past the right of it, fading to nothing at two thirds of its radius.

   IT IS THE CORNER AND NOT THE LAMP. That is the whole point of it and the
   reason it is a band-level layer rather than another circle inside the
   illustration: the light in the drawing rings the lantern, and this fills the
   corner of the page the lantern stands in, so the two read as one lamp lit in
   a haze rather than as a halo pinned to a picture. The circle is deliberately
   larger than the illustration and deliberately off the top of the band.

   UNDER EVERYTHING, AND IT INTERCEPTS NOTHING. `z-index: -1` inside the
   stacking context .hero opens puts it above the band's own background and
   below every word on it, so the copy column's contrast is the contrast the
   band tests measure and not that plus a sixth of a brass. Pointer events are
   off, so every click in the corner reaches whatever is under it, and it
   carries no content and nothing in the accessibility tree.

   It does not breathe. The three layers inside the illustration do — see the
   hero illustration section — and a fourth on the same loop would be the corner
   of the page pulsing, which is a much larger area of screen than anything the
   nine-second loop is meant to move. */
.hero::after {
  content: "";
  position: absolute;
  z-index: -1;
  /* The mockup's -260, -160 and 640, in the root unit: the fog fills the corner
     of the page the lantern stands in, so it has to grow with the drawing and
     with the band it is hung off rather than staying a 640px circle in a corner
     four fifths larger. */
  inset-block-start: -16.25rem;
  inset-inline-end: -10rem;
  inline-size: 40rem;
  block-size: 40rem;
  background-image: radial-gradient(
    circle,
    var(--color-accent-fog),
    transparent 66%
  );
  pointer-events: none;
}

.hero__inner {
  display: grid;
  gap: var(--space-xl);
  max-width: var(--layout-max);
  margin-inline: auto;
}

/* The eyebrow over the headline: the line that says what this is, before the
   headline says what it is about.

   READ OFF THE MOCKUP AS IT RENDERS, NOT OFF ITS .eyebrow RULE. This is the
   element the ticket names as the worked example of why, and it is worth
   spelling out. The mockup's .eyebrow says 11px, weight 400, --brass, 14px
   below. It also says the line is a <p> inside .hero, and .hero p — one class
   and one type, against .eyebrow's one class — beats it on every property the
   two share. So what a browser actually draws is 17px, weight 300, --cream-2,
   44px below, and the only things left of .eyebrow are the two properties
   .hero p does not set: the capitals and the .2em they are tracked at.

   That is a different line from the small brass label the rule reads like. It
   is a wide, quiet, open-tracked line the width of the copy column, and it is
   what the headline drops out of. The brass 12px version this file carried was
   built from the rule in isolation while the mockup was not on main, and it is
   exactly the class of drift this pass exists to take out.

   The four numbers, rounded onto the scales tokens.css keeps, because a section
   is not the place to type a value the scale has no name for:

     17px  is --text-base, which is the scale's own base and the size the hero's
           pitch below is set at. The two lines are the same size in the mockup
           and are the same size here.
     300   is --weight-light, which is what the body is set in now.
     44px  is --space-xl, which is 48px and the nearest step on the 4px grid —
           32px is twelve away and 48px four.
     .2em  is --tracking-widest, which the mockup's own value is added to
           tokens.css as. The button system's --tracking-wider is 0.13em and
           closes the letters up enough that the line reads as a button's label.

   No family. The sans is the body's — Jost, and the mockup's eyebrow inherits
   its own sans exactly this way — and the serif on the h1 below is the heading
   rule's in the document section, so neither voice is this band's to name.

   The muted cream is 9.3:1 on --color-paper, the surface the hero stands on, so
   it clears WCAG 2.1 AA 1.4.3 with room and there is no substituted token to
   record here. TestHeroEyebrowHoldsContrastOnTheBandItSitsOn is where the
   figure comes from.

   A paragraph and not a heading — see home.html: the page has one h1 and this
   line sits above it rather than inside it, so the outline is unchanged. */
.hero__eyebrow {
  margin-block-end: var(--space-xl);
  color: var(--color-ink-muted);
  font-size: var(--text-base);
  font-weight: var(--weight-light);
  letter-spacing: var(--tracking-widest);
  text-transform: uppercase;
}

/* The headline. The size, the leading and the tracking are all the mockup's —
   80px at the breakpoint over 1.04, closed up by five thousandths of an em —
   and the weight is the 300 the heading rule sets for every heading on the
   page. The tracking is named here rather than in that rule because the mockup
   tracks its h1 and leaves its h2s alone. */
.hero__headline {
  font-size: var(--text-5xl);
  letter-spacing: var(--tracking-tight);
  line-height: var(--leading-tight);
}

/* The emphasis in the headline: mint, and the element the underline strokes
   are hung off.

   Positioned, so the absolutely placed svg inside it is measured against these
   two words rather than against the page. `inline-block` rather than a plain
   relative inline, because an inline that wraps is laid out as two fragments
   and an absolutely positioned child of it is placed against the box round
   both — which would draw one underline across two lines of headline. Made
   atomic it cannot wrap: "best price." is about 4.8em, which is 250px of the
   312px a 360px phone has between its gutters at the headline's size, so the
   words move to a line of their own rather than overflowing.

   ITALIC, AND THE 400 WITH IT, which is the mockup's `.hero h1 .hl` and is the
   whole of what makes these two words a different voice rather than the same
   voice in another colour. The headline round them is the light upright; the
   emphasis is the italic, one cut heavier. Cormorant Garamond's 400 italic
   is on disk — see the @font-face rules at the top of this file — so nothing
   here is a slant the browser drew itself. */
.hero__headline-accent {
  position: relative;
  display: inline-block;
  color: var(--color-mint);
  font-style: italic;
  font-weight: var(--weight-regular);
}

/* The second cream step, which is 9.3:1 on the page: the pitch is the aside to
   the headline above it, and it clears WCAG 2.1 AA 1.4.3 with room.

   The mockup's .hero p, which is also what the eyebrow above renders as: 17px
   over 1.78, held to 60ch. It was 19px over the body's leading and running to
   the site's full 68ch measure, so it read a size over the eyebrow instead of
   the same size and broke its lines four or five characters later. The gap
   above it is the mockup's 28px, rounded down onto the grid. */
.hero__pitch {
  max-width: var(--measure-lede);
  margin-block-start: var(--space-md);
  color: var(--color-ink-muted);
  font-size: var(--text-base);
  line-height: var(--leading-loose);
}

/* The mockup's 12px between the two calls to action, and its 44px above them —
   which is the bottom margin its .hero p carries, rounded onto the grid the
   same way the eyebrow's is. */
.hero__ctas {
  display: flex;
  flex-wrap: wrap;
  gap: var(--space-xs);
  margin-block-start: var(--space-xl);
}

/* The right-hand column, which holds the engraved lighthouse — see the section
   of that name below for the drawing itself.

   OFF THE PAGE BELOW 860px, AND THIS IS THE RULE THAT DOES IT. Written the way
   round the rest of the file is written: gone in the base rules, revealed in
   the one 860px block, so a phone never lays the illustration out and never
   paints its blur. The other way round — drawn by default and hidden in a
   narrow-width block — would have every phone build the filter and then throw
   it away, which is the whole cost with none of the picture.

   `display: none` and not a visibility or an opacity: the column is a grid
   item, and a hidden one still takes its track and the gap beside it. Below the
   breakpoint .hero__inner is a single column, so a display: none child leaves
   no empty row, no gap and nothing to scroll past — the copy is the whole
   hero, exactly as it was before this ticket. */
.hero__aside {
  display: none;
}

/* THERE IS NO RING OVERRIDE IN THIS SECTION ANY MORE, for the reason the bar
   above has none: the blue was 2.8:1 on the white page's dark slab and is 6.7:1
   on the page the hero is now, so the site's one ring is the ring. The two
   calls to action are buttons and carry the button system's own lit-brass ring,
   which is not this section's to set either. */

@container band (min-width: 47rem) {
  .hero__inner {
    /* The copy on the left; .hero__aside is the deliberately empty column on
       the right, which is what holds the copy to its share of the width.
       minmax(0, …) so a long word cannot widen the copy past it. */
    grid-template-columns: minmax(0, 7fr) minmax(0, 5fr);
    align-items: center;
  }

  /* And the column the second track holds, which is off the page below this
     width. The ratio above is not this ticket's and is not touched. */
  .hero__aside {
    display: block;
  }
}

/* ---- Headline underline ------------------------------------------------ */

/* The two hand-drawn strokes under "best price.", drawn left to right once as
   the page loads and then left alone. No script and no library: two paths, a
   dash pattern and one keyframe pair.

   THE STROKES SHOW NOTHING AT ALL BEFORE THEY DRAW, which is the whole reason
   this is not a one-line animation, and it takes both halves of the rule below.

   A dash offset on its own is not enough. The usual undrawn state — a dash as
   long as the path, pushed off it by an equal offset — leaves the dash's end
   sitting exactly on the path's start, and a round cap there is drawn as a dot:
   a visitor sees two full stops appear under the headline and wait half a
   second before growing into lines. So the gap is twice the path rather than
   equal to it, and the strokes are `visibility: hidden` until the keyframe that
   draws them turns them on.

   That is also why the fill mode is `forwards` and not `both`. `backwards`
   would apply the first keyframe — visibility included — through the delay,
   which is precisely the half second there must be nothing on the page. With
   `forwards` alone the rule's own values hold until the animation starts, and
   the last keyframe's hold after it ends.

   It runs once. There is no hover, focus or scroll rule anywhere that names
   these strokes, nothing in app.js touches them, and a filled animation does
   not restart — so scrolling away and back, or tabbing through the two calls to
   action, leaves a drawn underline drawn.

   Someone who has asked for less motion gets the finished underline instead,
   from the first paint: the block at the foot of this section, which the
   blanket rule at the foot of the file cannot stand in for. */

.hero__underline {
  /* The four numbers the whole thing is timed by, in one place, and all four
     are the mockup's own: the first stroke starts at 550ms and takes 620ms, so
     it lands at 1170ms; the second follows 310ms behind it and takes 500ms, so
     it lands at 1360ms — inside the 1.5s the page has. The pair used to run
     600ms each 200ms apart, which is the same gesture drawn by a faster hand. */
  --underline-delay: 550ms;
  --underline-draw: 620ms;
  --underline-draw-second: 500ms;
  --underline-stagger: 310ms;

  position: absolute;
  /* Below the line box, so the strokes clear the descender on the p. The
     mockup hangs its own underline .14em into the line box instead and takes
     the descender crossing it; this is the one piece of the mark's geometry
     that is not the mockup's, and the note in the closing summary says so.

     The overhang is: the mockup's -2% and 104%, so each stroke starts a little
     before the b and ends a little after the full stop, the way a hand drawing
     one would. */
  inset-block-start: 100%;
  inset-inline-start: -2%;
  inline-size: 104%;
  /* The viewBox is 250 by 14 and the words are about 4.8em wide, so this is
     the height that scales the drawing by the same factor in both directions:
     preserveAspectRatio="none" stretches it to the words, and a stroke stays a
     stroke rather than being squashed into a hairline. In em, so the mark grows
     with the headline at the breakpoint without a second rule. The mockup's own
     height is .30em, which is what this is now. */
  block-size: 0.3em;
  pointer-events: none;
}

.hero__underline-stroke {
  fill: none;
  /* THE MINT, WHICH IS THE MOCKUP'S. Its `.uline path` is `stroke:var(--mint)`,
     the same colour the two words above the strokes are set in: the mark is the
     emphasis carried under the words rather than a second colour drawn beside
     them, and the mint stops at the end of the phrase it belongs to.

     It was the lit brass, on the reasoning that a mark under a word is the
     brand's colour. That was a decision taken with the mockup off main, and the
     mockup decides it the other way. 10.5:1 on the page the hero is, past WCAG
     2.1 AA 1.4.11's 3:1 for a graphic several times over. */
  stroke: var(--color-mint);
  /* The mockup's 3, and 2.2 on the second stroke below: the pen presses harder
     on the way out and lifts on the way back. */
  stroke-width: 3;
  stroke-linecap: round;
  stroke-linejoin: round;

  /* pathLength="1" in the markup makes each path one unit long, so this is a
     dash the length of the whole stroke followed by a gap twice as long, and
     the offset below holds the whole dash clear of the path. */
  stroke-dasharray: 1 2;
  stroke-dashoffset: 1;
  visibility: hidden;

  animation-name: hero-underline-draw;
  animation-duration: var(--underline-draw);
  animation-timing-function: var(--ease-out);
  /* Read the note above before changing this to `both`. */
  animation-fill-mode: forwards;
}

.hero__underline-stroke--first {
  animation-delay: var(--underline-delay);
}

/* Not at the same moment as the first: a hand draws one line and then the
   other, and the two starting together reads as a printed rule appearing.

   It is the lighter of the two in every way the mockup's second stroke is —
   thinner, faster and held at seven tenths — so the pair reads as one gesture
   returning rather than as two rules. The mockup carries the .7 in its own
   draw2 keyframes; here it is the rule's, so it holds before the stroke draws,
   after it lands, and for anybody served the still underline below. */
.hero__underline-stroke--second {
  animation-delay: calc(var(--underline-delay) + var(--underline-stagger));
  animation-duration: var(--underline-draw-second);
  opacity: 0.7;
  stroke-width: 2.2;
}

/* Both keyframes turn the stroke on, so it is visible for the whole draw and
   for nothing before it. The offset walking from 1 to 0 is the pen. */
@keyframes hero-underline-draw {
  from {
    visibility: visible;
    stroke-dashoffset: 1;
  }

  to {
    visibility: visible;
    stroke-dashoffset: 0;
  }
}

/* Asked for less motion: the underline is already drawn when the page paints,
   and nothing about it ever moves.

   The blanket rule at the foot of this file is not enough on its own, in two
   ways. It collapses the duration but leaves the delay, so the strokes would
   still spend half a second off the page and then snap on — a jump is still
   motion. And the state they spend that half second in is `visibility: hidden`,
   which is the rule's own value and not a keyframe's: with the animation
   effectively gone there is nothing left to turn them on, and someone who has
   asked for less motion would get no underline at all rather than a still one.
   That is the failure this block exists to prevent, so clearing the visibility
   is the line to keep if any of them is ever in doubt.

   `animation: none` rather than a duration of zero: the shorthand drops the
   delay along with the rest, and it is one declaration that cannot be half
   done. The three that follow are the last keyframe written out by hand — the
   finished stroke, served rather than arrived at. There is no transition on
   these paths and this ticket is not adding one; `transition: none` is here so
   that a later hover or theme rule cannot fade a stroke that is meant to be
   still.

   Nothing above is touched, so the drawing is exactly as it was for everyone
   whose system does not ask for this. */
@media (prefers-reduced-motion: reduce) {
  .hero__underline-stroke {
    animation: none;
    transition: none;
    visibility: visible;
    stroke-dashoffset: 0;
  }
}

/* ---- Hero illustration ------------------------------------------------- */

/* The engraved lighthouse in the hero's right-hand column: the halo behind the
   lamp, the two blurred beams, the line art and the bloom on the lamp.

   The drawing is in templates/pages/home.html and the paint is here, which is
   the split the headline underline above is written with — and here it earns
   itself twice over. Every colour in the picture is a brass token read at paint
   time, so the illustration moves with the palette and there is not one hex in
   the markup; and the two layers that move do so from one rule and one set of
   keyframes, so the light in the lantern and the light leaving it cannot come
   apart from each other.

   NOTHING IN HERE IS DRAWN BELOW 860px. .hero__aside — the Hero section above —
   is display: none in the base rules, so on a phone none of the rules below
   match anything on the page: no gradient is resolved, no filter region is
   allocated and no blur is painted. That is deliberate and it is where the
   mobile cost of this ticket went. The rules themselves are unconditional
   because there is nothing left for a media query to save: a rule that matches
   no element costs a selector match.

   No script anywhere. The breathing is a CSS loop with no delay, so it is in
   step from the first paint whether or not app.js ever arrives — see the
   animation rule below for what it is in step with. */

.hero-lighthouse {
  /* THE NINE SECONDS, AND THE ONE PLACE THEY ARE WRITTEN DOWN. The beams and
     the bloom breathe on the same loop as the spark in the bar: same duration,
     and no animation-delay on either, which is the whole of what keeps them
     phase-locked. Both start at the document's timeline origin and neither is
     ever restarted, so they do not drift and there is nothing to synchronise.
     Give one of them a delay and the pair is broken; give one of them a
     different duration and it is broken more slowly.

     The other half of the pair is .site-nav__spark-beams in the site header
     section: the mark in the bar took this duration and no delay when the
     lighthouse replaced the diamond, so the two are in step from the first
     paint with nothing else to do. Both numbers are written where the section
     that owns the motion can see them — if one moves, the other moves with
     it. */
  --lighthouse-breath: 9s;

  /* The three breathing layers each declare their own --lighthouse-dim and
     --lighthouse-lit further down, because the three ranges differ; there is
     deliberately no pair here for them to inherit. A layer that forgot to
     declare one would animate to nothing rather than quietly to somebody else's
     number, which is the failure that is worth seeing. */

  /* The engraving's own weight. Reduced, because these are the lines of a
     drawing beside the copy and not a mark that says anything: at full strength
     the brass competes with the headline in the column next to it. */
  --lighthouse-stroke-opacity: 0.5;

  display: block;
  /* As wide as the column gives it, up to the width the drawing was set at.
     The viewBox is 320 by 420, so the cap is also what holds the picture to
     about the height of the copy beside it — a taller drawing would set the
     hero's height rather than sit inside it.

     HELD TO THE RIGHT OF ITS COLUMN, which is the mockup's `justify-self: end`
     on .hero-art and is the other half of the content line. The right-hand edge
     of the column is the content container's right-hand edge, so the drawing
     ends where "Get a quote" in the bar above it ends. The one auto margin is
     what does that: the width the picture does not take goes to its left, where
     the copy column is, rather than being split either side of it. Both auto —
     which is what this was — centred the drawing in its track and left it about
     a sixth of a gutter short of the line at 1440 and 1280, so the bar and the
     art missed each other on the right the way the wordmark and the eyebrow
     missed each other on the left. No offset and no negative margin: the edge is
     the container's. Below the breakpoint .hero__aside is display: none and
     there is nothing here to align. */
  inline-size: 100%;
  /* The 340px the drawing was set at, in the root unit: the cap is what holds
     the picture to about the height of the copy beside it, and the copy grows
     with the root, so a cap that did not would leave the drawing shrinking away
     from the headline it stands next to at every width over 1120. */
  max-inline-size: 21.25rem;
  block-size: auto;
  margin-inline-start: auto;
}

/* Every line of the drawing, in the brass. It is decoration and carries nothing
   — the headline and the pitch beside it say everything the picture says — so
   WCAG 2.1 AA 1.4.11's 3:1 is not asked of these strokes, and they are set at
   the weight the engraving wants rather than at the weight a mark would need.
   The round cap and join are what stop the hatching and the railing from
   reading as cut wire at this size. */
.hero-lighthouse__strokes {
  fill: none;
  stroke: var(--color-accent);
  stroke-width: 1.4;
  stroke-linecap: round;
  stroke-linejoin: round;
  opacity: var(--lighthouse-stroke-opacity);
}

/* The lit point at the middle of the lamp: the one filled shape in the drawing,
   and the brightest thing on it. The lit brass rather than the brass — this is
   the source the halo and the beams are the light from. */
.hero-lighthouse__lamp {
  fill: var(--color-accent-bright);
}

/* The gradient stops. Both are the palette read at paint time — a gradient is
   the one place a drawing can name a colour without a rule, and naming one
   there is a colour that will not move when the brass does. How far each stop
   sits along its gradient and how much of it survives are in the markup, which
   is the shape of the light; which brass it is, is here. */
.hero-lighthouse__stop--lit {
  stop-color: var(--color-accent-bright);
}

/* The plain brass. Nothing in the drawing reads it since the reconciliation
   pass: the mockup paints every stop of its blHalo and both of its beam
   gradients in the lit brass, so the light is one tone thinning rather than two
   tones blending. The rule is kept because it is the other half of the pair a
   gradient stop can be — a stop is the one place a drawing may name a colour
   without a rule, and the day one wants the darker brass it asks for this
   rather than typing a hex into the markup. */
.hero-lighthouse__stop--brass {
  stop-color: var(--color-accent);
}

/* The palest brass, and the one stop it is spent on: the middle of the bloom
   inside the lantern, which is the mockup's blBloom centre. Everything else in
   the light is one of the two brasses above — the mockup uses this third tone
   in exactly one place and so does this. */
.hero-lighthouse__stop--bloom {
  stop-color: var(--color-accent-bloom);
}

/* The breath. THREE layers, one rule and one set of keyframes: the halo, the
   beams and the bloom are one light seen in three places, and three animations
   would be three things to keep in step.

   The halo is in here and is the reason the loop can be seen at all. It is the
   widest area of the three by a long way — a circle most of the width of the
   drawing, against two thin beams and a ball the size of the lantern — so it is
   the layer that carries the motion, and a loop that moved the other two and
   left it standing read as a still picture with a flicker in it. That was the
   fault this rule was widened to fix.

   Each layer runs its own range and all three run the same keyframes, which is
   what the two custom properties below are for: the keyframes animate
   --lighthouse-dim to --lighthouse-lit, and each layer says what those two are
   for itself. One timeline, three depths of fade — and the ranges cannot drift
   apart into three animations, because there is only one.

   `infinite` with no delay and no fill mode. There is nothing to hold before or
   after — the loop runs from the first paint for as long as the page is open —
   and the rule's own opacity is what a layer stands at if the animation is ever
   taken off it, which is exactly what the reduced-motion block below does. It
   is the lit end rather than a fourth number per layer: a still illustration
   should be the picture at the top of its breath, which is the frame it is most
   legible in.

   The property that moves is opacity and only opacity: no filter is
   re-evaluated per frame, no geometry is re-laid out, and the blurred beams are
   composited once and then faded. */
.hero-lighthouse__halo,
.hero-lighthouse__beams,
.hero-lighthouse__bloom {
  opacity: var(--lighthouse-lit);
  animation: hero-lighthouse-breathe var(--lighthouse-breath) var(--ease-in-out) infinite;
}

/* The three ranges. The halo and the beams come up to full and the bloom stops
   short of it: the bloom is the ball of light inside the lantern and the lamp's
   lit point is drawn on top of it, so a bloom at full opacity swallows the point
   it is meant to be coming from.

   The floors differ for the same kind of reason. None of them is nought — the
   ebb is the beam swung away, not the lamp failed — but the beams fall furthest
   because two hard-edged shapes left faintly on at the bottom of the loop read
   as two grey wedges pinned to the lantern, and the halo holds the highest floor
   because it is the haze in the air that a lamp still lit would leave. */
.hero-lighthouse__halo {
  --lighthouse-dim: 0.14;
  --lighthouse-lit: 1;
}

.hero-lighthouse__beams {
  --lighthouse-dim: 0.07;
  --lighthouse-lit: 1;
}

.hero-lighthouse__bloom {
  --lighthouse-dim: 0.1;
  --lighthouse-lit: 0.85;
}

/* A light turning: down, full, down, over the nine seconds.

   THE TWO VALUES ARE READ OFF THE LAYER BEING ANIMATED, NOT WRITTEN HERE. A
   keyframe value may be a var(), and it is resolved against the element the
   animation is running on — so this one pair of keyframes gives the halo its
   0.14 to 1, the beams their 0.07 to 1 and the bloom its 0.1 to 0.85, from one
   timeline with one origin. Three sets of keyframes with the numbers baked into
   them would be the same picture and three things to keep in step.

   IT EBBS ALMOST TO NOTHING, AND THAT IS THE POINT OF THE RANGE. A beacon is a
   beam swinging past you: it arrives, it fills, and it goes again. The narrow
   swing this started at — a little over half, up to full — is what a light
   breathing looks like on paper and what nothing at all looks like on a screen,
   because four and a half seconds is long enough for the eye to take the new
   brightness as the brightness and stop seeing the change.

   One cycle in nine seconds is 0.11Hz, three hundred times under the three
   flashes a second WCAG 2.1 AA 2.3.1 draws the line at, and the ease either
   side means there is no edge in it to flash on. Someone who does not want it
   moving at all is served the still picture — see the block below. */
@keyframes hero-lighthouse-breathe {
  from,
  to {
    opacity: var(--lighthouse-dim);
  }

  50% {
    opacity: var(--lighthouse-lit);
  }
}

/* Asked for less motion: the illustration is still, and it is all there.

   STILL, AND NOT GONE. All four layers are drawn — the strokes, the halo, the
   beams and the bloom — and the three that breathe are held at the lit end of
   their own range, which is the value the rule above already carries and the
   frame the picture is most legible in. The only thing taken away is the loop.
   Hiding the picture, dropping a layer or fading it out would be answering
   "less movement" with "less page", which is a different request.

   `animation: none` rather than the blanket rule at the foot of this file. That
   one collapses the duration to a hundredth of a millisecond, which is a loop
   still running very fast rather than a loop that is not running; the shorthand
   is one declaration that cannot be half done. The opacity is restated under it
   for the same reason the underline restates its finished stroke: what somebody
   is served here should be readable as a state, without having to work out what
   the cascade leaves behind once the animation is gone. */
@media (prefers-reduced-motion: reduce) {
  .hero-lighthouse__halo,
  .hero-lighthouse__beams,
  .hero-lighthouse__bloom {
    animation: none;
    opacity: var(--lighthouse-lit);
  }
}

/* ---- Pipeline stepper ------------------------------------------------- */

/* The five-node animation below the hero copy.

   app.js owns the sequence and writes three things: `data-state` on each node —
   one of queued, building, ready or paid — how far along the rail the line has
   reached, as `--pipeline-fill` and the `--pipeline-fill-duration` it has to
   get there in, and the text of the running tally in the footer. Everything
   below is what those look like, so the whole visual side of the animation is
   here and the whole timing side is there.

   The state attribute picks the colour *and* the visible label, which is why
   the labels are all in the markup rather than written in by script: there is
   no way to move the hue without moving the words with it (WCAG 2.1 AA 1.4.1).

   Written narrow first, like the rest of the file: the base rules below are
   the two-column wrap with no rail, and the `@container` block at the foot of
   this section is the single row with the line running through it. It asks the
   hero — the band the stepper is inside — for 44rem, which is what five nodes
   need before their names start breaking.

   The finished state for `prefers-reduced-motion` is the last block in this
   section: every node paid, the rail full and the still tally in place of the
   one app.js writes, with nothing in the stepper left to move. */

.pipeline {
  /* The dot's size is also where the rail is drawn: the track is centred on
     the dot's middle, so changing one moves the other. The mockup's .nd is
     32px across with a 1.5px ring and its rail is a 1.5px track under a 2.5px
     stroke; both were a size up here, which made the row of nodes heavier than
     the row of names under it.

     The track and the line are two thicknesses and not one, which is the other
     half of the mockup's rail: the road is a hairline and the progress along it
     is a stroke, so the line reads as something laid over the track rather than
     as the track changing colour.

     ALL THREE ARE THE ROOT UNIT. The dot always was; the two rail thicknesses
     are the mockup's 1.5 and 2.5 written as the fractions of 16 they are, so the
     rail keeps its weight against the dots it runs between rather than thinning
     to a scratch under a 32px dot drawn at 57. Neither is a hairline: a hairline
     divides something and these two draw a road and the progress along it. */
  --pipeline-dot-size: 2rem;
  --pipeline-rail-thickness: 0.09375rem; /* the mockup's 1.5px */
  --pipeline-rail-fill-thickness: 0.15625rem; /* the mockup's 2.5px */
  /* How many nodes the template renders, which is the one thing about the
     stepper this file cannot see for itself: the wide layout takes its columns
     from the markup — `grid-auto-flow: column` — so nothing here counts them,
     and where the rail starts and stops is half a column in from each edge.
     Five, and it is the same five app.js reads off the list as `nodes.length`
     to work out how far along the rail each node sits.
     TestPipelineRailStartsAndEndsOnTheNodeCentres is what holds the two
     numbers together, so a sixth node added to home.html fails a test here
     rather than quietly moving the rail's ends off the dots. */
  --pipeline-nodes: 5;
  /* How far along the rail the line has reached, 0 to 1, and how long it has
     to get there. app.js moves the line from one node to the next and gives it
     the beat between them to travel; the values here are the empty, still rail
     the page is served with. */
  --pipeline-fill: 0;
  --pipeline-fill-duration: 0ms;

  max-width: var(--layout-max);
  /* The mockup's 74px between the hero copy and the first row of nodes. */
  margin-block-start: var(--space-2xl);
  margin-inline: auto;
}

.pipeline__rail {
  position: relative;
  display: grid;
  /* Two columns on a phone: Release 1 and 2, then Release 3 and 4, then Launch
     across the last row. minmax(0, …) so a long word in a node cannot widen
     its own column and push the list past the gutter.

     No padding, at any width: a padding on the list shortens the columns
     without shortening the rail, and the line the wide layout draws would stop
     beside each dot rather than on it. */
  grid-template-columns: repeat(2, minmax(0, 1fr));
  /* Rows only. What holds two nodes apart across a row is each node's own
     padding, which is also what does it at the wide layout — so there is one
     thing to say about the columns there, and it is that they have no gap
     between them at all. */
  row-gap: var(--space-lg);
  margin: 0;
  padding: 0;
  list-style: none;
}

/* Launch, the fifth of five: it spans the last row rather than sitting alone in
   the left-hand cell. That is a decision and not a bug — a node on its own
   leaves a lopsided hole beside it, and a centred fifth node lines up with
   neither column above it.

   The selector says the same thing as that sentence: only a last node that is
   also the odd one out is stretched, so a node count that came out even needs
   nothing undone here. */
.pipeline__node:nth-child(odd):last-child {
  grid-column: 1 / -1;
}

/* The rail: the unfilled track, and the fill drawn over it. Both are one
   element spanning the row of nodes rather than a segment between each pair of
   nodes, so there is a single thing to advance and nothing to keep in step.

   WHERE THE RAIL BEGINS AND ENDS. On the first dot and the last one, and not on
   the edges of the list. The rail is the connection between the releases:
   before Release 1 and after Launch there is nothing to connect, and a length
   of pipe out there turns five nodes into five beads threaded on a rod. The
   mockup draws this same line as an SVG path across a 1000-unit box: both of
   its paths are `M100 16 H900` — first centre to last, and never M0 … H1000 —
   and 100 and 900 are that box half a column in from each edge.

   Half a column is what is written here rather than the mockup's own two
   numbers, because our rail is a pair of pseudo-elements on the list and not a
   stretched viewBox: the arithmetic is the same either way. Each node has an
   equal, ungapped share of the list — 100% / --pipeline-nodes — and its dot
   sits halfway along its own share, so the first centre is half a column in
   from the start and the last is half a column in from the end. At five nodes
   that is 10% and 90%, which is the mockup's 100 and 900 of 1000.

   The list itself is not narrowed and the nodes do not move: this is an inset
   on the two lines, so the grid the dots are laid out on still spans the whole
   width and the percentages above are shares of the same width the columns are
   cut from. A margin on the list, or a shorter list, would shorten the columns
   too and move every dot inwards with the rail's ends.

   Neither is drawn below the breakpoint, where the nodes sit in two columns and
   a horizontal line straight through them would say nothing. `display: none`
   rather than hidden or transparent, so neither of them holds a strip of empty
   space between the two rows. The 860px block below is what draws them.

   Nothing is left behind by that: they are pseudo-elements, so there is no node
   in the document either way, and what app.js writes to move the line is two
   custom properties on the list itself — which is there at every width. It
   keeps writing them on a phone, they are simply inherited by no rail. */
.pipeline__rail::before,
.pipeline__rail::after {
  content: "";
  display: none;
  position: absolute;
  z-index: 0;
  /* Half a column, from each end: (100% / --pipeline-nodes) / 2. */
  inset-inline: calc(50% / var(--pipeline-nodes));
  inset-block-start: calc(var(--pipeline-dot-size) / 2);
  block-size: var(--pipeline-rail-thickness);
  border-radius: var(--radius-pill);
  transform: translateY(-50%);
}

/* The unfilled track: the hairline, which is the token the mockup draws this
   very line in — its rail is `stroke: var(--rule)`, and --color-line is what
   --rule is called here.

   It was --color-line-inverse, the last -inverse token in this file, held here
   while the shell re-theme moved the bands under it. That name says a dark
   thing on a light page and there is no light page left: the rail is drawn on
   the hero, and the hero is the page.

   THE LIT HAIRLINE IS THE ONE THIS IS NOT, and it is worth saying why, because
   the value that just left was the lit one. Everywhere else on this site a rule
   is --color-line-strong: the bands, the quote card's header, the listing's
   rows. Those divide something, and a division nobody can see has not divided
   anything. This one is a road, not a rule — it is there for the mint line to
   run along, and the fainter it is the more plainly the line's progress along
   it reads. 7.1:1 between the two, against 4.7:1 if the track took the lit
   hairline.

   Neither end of that is held to 4.5:1: the track carries no word, sits inside
   the aria-hidden list, and every word the stepper says is in the nodes above
   it (WCAG 2.1 AA 1.4.3 is about text). What it has to do is be findable, at
   1.5:1 on the page — which is the mockup's own reading of the same line on the
   same surface, and it is checked at 1440 and at 360 rather than argued
   from. */
.pipeline__rail::before {
  background-color: var(--color-line);
}

/* The line. app.js points it at a node — node / (nodes - 1), a share of the
   rail and not of the list, because the rail now starts on the first dot and
   ends on the last — so it comes to rest on the dot, and gives it the beat
   between two nodes to travel, so it arrives as the next node starts building.
   Scaled rather than widened: a transform animates without laying the row out
   again.

   The two halves of that fraction have to agree: the rail's ends are set half a
   column in above and the line's stops are measured along what is left, so a
   change to one without the other leaves the mint stopping short of a dot or
   running past it. The rule over --pipeline-nodes says where both come from.

   Linear, and the one thing on this page that is not eased. The last stretch
   of each journey is spent behind the dot the line is arriving at — the dot is
   opaque and covers the final tenth of the distance between two nodes — so an
   ease-out crawls that stretch invisibly: the line looks like it landed a
   third of a beat before it did, and the node reads as sitting idle before it
   starts building. At a constant speed the line reaching the dot and the node
   lighting up are the same moment. */
.pipeline__rail::after {
  /* A pixel over the track it runs along — see --pipeline-rail-fill-thickness.
     The pair share the block-start above, so both are still centred on the
     dot's middle whatever either is worth. */
  block-size: var(--pipeline-rail-fill-thickness);
  background-color: var(--color-mint);
  transform: translateY(-50%) scaleX(var(--pipeline-fill));
  transform-origin: left center;
  transition: transform var(--pipeline-fill-duration) linear;
}

.pipeline__node {
  /* Above the rail, which runs behind the dots. */
  position: relative;
  z-index: 1;
  display: grid;
  justify-items: center;
  /* The mockup's 4px between the release name and the state word under it. The
     18px it holds between the dot and the name is the name's own margin above,
     so the two gaps in a node can differ the way the mockup's do. */
  gap: var(--space-3xs);
  /* What keeps two nodes' labels apart, in place of a gap on the rail above:
     padding sits inside the column, so it moves nothing the line is aimed
     at. */
  padding-inline: var(--space-2xs);
  text-align: center;

  /* THREE PROPERTIES, BECAUSE THE MOCKUP DRAWS A NODE WITH THREE. The state
     rules below replace all three at once and no rule reaches past them:

       --pipeline-node-color  the word under the dot, and the dot's own fill
                              once it is paid.
       --pipeline-node-edge   the ring round the dot.
       --pipeline-node-glow   the ring outside that ring, which is the mockup's
                              `box-shadow: 0 0 0 7px` on a node that is working
                              or waiting. 0.4375rem is that 7px in the root
                              unit: the glow is a halo round a dot that grows
                              with the page, so a fixed 7px would be a thinner
                              and thinner rim at every width over 1120.

     Queued is the one state where the first two differ: the mockup rings a
     queued node in its lit hairline and sets the word under it in the third
     cream, so a node nothing has happened to yet is drawn twice as quietly as
     the pair-of-one-colour rule this replaced had it. The word takes
     --color-ink-faint rather than the mockup's own --cream-3, which is 4.3:1 on
     the top of the surface ladder; see the note on that token in tokens.css.
     6.7:1 on the page the hero is.

     There is no glow on a queued node and none on a paid one — the mockup
     switches its shadow off when the node fills — so the resting value is a
     shadow with no colour in it rather than `none`, which would make the
     property un-transitionable on the way in. */
  --pipeline-node-color: var(--color-ink-faint);
  --pipeline-node-edge: var(--color-line-strong);
  --pipeline-node-glow: 0 0 0 0.4375rem transparent;
}

/* Building: the lit brass, and not the plain brass this read before. The
   mockup's `.step.building` rings the node in --brass-lit and sets the word in
   it too, which is a step brighter than the brass the button faces are. */
.pipeline__node[data-state="building"] {
  --pipeline-node-color: var(--color-accent-bright);
  --pipeline-node-edge: var(--color-accent-bright);
  --pipeline-node-glow: 0 0 0 0.4375rem var(--color-accent-glow);
}

.pipeline__node[data-state="ready"] {
  --pipeline-node-color: var(--color-sky);
  --pipeline-node-edge: var(--color-sky);
  --pipeline-node-glow: 0 0 0 0.4375rem var(--color-sky-glow);
}

.pipeline__node[data-state="paid"] {
  --pipeline-node-color: var(--color-mint);
  --pipeline-node-edge: var(--color-mint);
  --pipeline-node-glow: 0 0 0 0.4375rem transparent;
}

.pipeline__dot {
  display: grid;
  place-items: center;
  inline-size: var(--pipeline-dot-size);
  block-size: var(--pipeline-dot-size);
  /* The mockup's 1.5px ring, in the root unit like the rail's own two
     thicknesses: it is the edge of a drawn dot and grows with it. */
  border: 0.09375rem solid var(--pipeline-node-edge);
  border-radius: var(--radius-pill);
  /* The dot's fill is what breaks the rail running behind it, so it has to be
     the surface the stepper is drawn on — the hero, which is the page now and
     was the slab while the page was white. It is also what the check is drawn
     in once the dot itself goes mint. */
  background-color: var(--color-paper);
  /* The glow the two working states put round the dot, and nothing at all in
     the two that are not working: see --pipeline-node-glow above. */
  box-shadow: var(--pipeline-node-glow);
  color: var(--color-paper);
  transition: background-color var(--duration-base) var(--ease-out),
    border-color var(--duration-base) var(--ease-out),
    box-shadow var(--duration-base) var(--ease-out);
}

/* Paid and live: the dot fills, and the check inside it appears. */
.pipeline__node[data-state="paid"] .pipeline__dot {
  background-color: var(--pipeline-node-color);
}

.pipeline__check {
  opacity: 0;
  transition: opacity var(--duration-base) var(--ease-out);
}

.pipeline__node[data-state="paid"] .pipeline__check {
  opacity: 1;
}

/* The node's name — Release 1 to 4, then Launch — in the display serif the
   mockup sets them in. One rule for all five: the names are the only thing in
   the stepper that changes face, and no node declares a font of its own.

   The size steps up with the family, the way every other pairing of the two
   faces on this page does: Cormorant Garamond runs small beside Jost, so the
   sans's --text-sm here would read a size under the state word below it rather
   than a size over. The state words, which are the sans, are untouched. */
.pipeline__name {
  margin-block-start: var(--space-sm);
  color: var(--color-ink);
  font-family: var(--font-serif);
  font-size: var(--text-lg);
  /* The mockup's .lbl: the 500, opened by .02em. It was the 600 with no
     tracking, which is the same name a cut heavier and a shade tighter. */
  font-weight: var(--weight-medium);
  letter-spacing: var(--tracking-slight);
}

/* The state word: the mockup's .stt, which is the small uppercase label the
   whole page sets a status in — 11px, the regular, tracked .14em. It was 13px
   sentence case, which read as a second name under the first. */
.pipeline__state {
  color: var(--pipeline-node-color);
  font-size: var(--text-2xs);
  font-weight: var(--weight-regular);
  letter-spacing: var(--tracking-label);
  line-height: var(--leading-snug);
  text-transform: uppercase;
  transition: color var(--duration-base) var(--ease-out);
}

/* Every node carries one label per state; the one matching the node's
   data-state is the one shown. The same attribute picked the colour above, so
   the two cannot come apart — a node with no label showing would be a node
   app.js had put into a state that does not exist. */
.pipeline__state-label {
  display: none;
}

.pipeline__node[data-state="queued"] .pipeline__state-label[data-pipeline-label="queued"],
.pipeline__node[data-state="building"] .pipeline__state-label[data-pipeline-label="building"],
.pipeline__node[data-state="ready"] .pipeline__state-label[data-pipeline-label="ready"],
.pipeline__node[data-state="paid"] .pipeline__state-label[data-pipeline-label="paid"] {
  display: block;
}

/* The caption and the tally slot. Stacked here: on a phone the sentence has a
   line of its own and the tally sits under it, rather than the two of them
   sharing a row narrow enough to break the sentence into four. They go side by
   side at the breakpoint. */
.pipeline__footer {
  display: flex;
  flex-direction: column;
  gap: var(--space-sm);
  /* The mockup's .pipe-cap: 42px above the rule, 22px under it, and the plain
     hairline drawn between — the seam that closes the stepper off from the band
     below rather than a divider between two things. */
  margin-block-start: var(--space-xl);
  border-block-start: 1px solid var(--color-line);
  padding-block-start: var(--space-md);
}

/* The sentence under the nodes, in the mockup's own voice for it: the serif
   italic at 15px in the third cream, which is the treatment this page gives an
   aside — the work section's disclosure and the quote card's terms line are the
   same three declarations. It was the upright sans in the second cream, which
   read as a second paragraph of body copy under an animation.

   --color-ink-faint and not the mockup's --cream-3, which is 4.3:1 on the top
   of the surface ladder; 6.7:1 on the page the stepper stands on. */
.pipeline__caption {
  max-width: var(--measure);
  color: var(--color-ink-faint);
  font-family: var(--font-serif);
  font-size: var(--text-sm);
  font-style: italic;
}

/* The running invoiced-so-far figure. app.js writes the whole line into the
   slot — the amount and the words after it — and the slot is served empty, so
   there is nothing here for a page without JavaScript to lay out.

   Full-strength cream against the caption's muted step: it is the one thing on
   the stepper that adds up, and the sentence beside it is the aside.

   The mockup's own treatment for the line: the small uppercase label, tracked
   .14em, and never broken across two lines. The third cream rather than the
   full one — the sentence beside it is the caption, and this is the note in the
   margin beside the picture.

   ONE COLOUR FOR THE WHOLE LINE, WHICH IS THE ONE THING HERE THAT IS NOT THE
   MOCKUP'S. Its markup wraps the figure in a <b> and paints that alone in the
   lit brass, leaving "invoiced so far" in the third cream. app.js writes this
   whole line as one text node — see PIPELINE_TALLY_TEXT there, and the note
   over showTally about why the words are the script's rather than the markup's
   — so there is no element in here to paint separately, and inventing one would
   be a second copy of the sentence to keep in step for the sake of two words'
   colour. The still line below carries the same treatment for the same reason.

   Tabular figures, because the number is rewritten five times a cycle and gains
   a digit as it goes: proportional ones would shuffle the words after them
   sideways on every tick. The body now asks for them too — this is the rule
   that stops the pair coming apart if it ever stops. */
.pipeline__tally {
  color: var(--color-ink-faint);
  font-size: var(--text-2xs);
  font-weight: var(--weight-regular);
  font-variant-numeric: tabular-nums;
  letter-spacing: var(--tracking-label);
  text-transform: uppercase;
  white-space: nowrap;
}

/* The same line, finished and standing still, which the page renders from the
   quote file's total. It is off the page for everybody the animation runs for
   — display: none, so it takes no space in the footer row and is out of the
   accessibility tree along with the pixels — and the reduced-motion block at
   the foot of this section is the only thing that ever shows it. */
.pipeline__tally--still {
  display: none;
}

@container band (min-width: 44rem) {
  /* One row again: one equal column per node, taken from the markup rather
     than counted here. minmax(0, …) so a long word in a node cannot widen its
     own column.

     No column gap: the columns have to be equal shares of the list for a dot
     to sit exactly halfway along its own column, which is what both ends of
     the rail and every stop the line makes are measured from. The row gap the
     base rule sets is left alone — there is only one row here for it to have no
     effect on. */
  .pipeline__rail {
    grid-template-columns: none;
    grid-auto-flow: column;
    grid-auto-columns: minmax(0, 1fr);
  }

  /* Five columns in a line, so nothing spans anything. */
  .pipeline__node:nth-child(odd):last-child {
    grid-column: auto;
  }

  /* The nodes are in a line, so the line through them is worth drawing. */
  .pipeline__rail::before,
  .pipeline__rail::after {
    display: block;
  }

  /* The caption on the left and the tally on the right, sitting on the same
     baseline. Wrapping, so a caption long enough to need the width gets it. */
  .pipeline__footer {
    flex-direction: row;
    flex-wrap: wrap;
    align-items: baseline;
    justify-content: space-between;
  }

  /* The slot the running tally is written into by its own ticket. The auto
     margin holds it against the right edge even once the caption wraps. */
  .pipeline__tally {
    margin-inline-start: auto;
  }
}

/* Asked for less motion: the stepper is served finished, and nothing in it
   moves at any point.

   This is one half of that and app.js is the other. Here is what the finished
   stepper looks like, written as a state rather than reached by running the
   sequence quickly — so it is on screen at the first paint whether or not the
   script arrives at all. There is nothing to start and stop, and no frame in
   which a queued rail is shown before something corrects it.

   What app.js does is refuse to schedule the loop, which is why every rule
   below is written against the state the server renders — `data-state="queued"`
   on all five nodes — rather than against the state the sequence would have
   left them in. The attribute selectors are not reading the state: they are
   there to weigh the same as the four state rules above, which are one class
   and one attribute deep, so the finished paint wins on source order.

   Nothing here is a size, a position or a layout. The stepper occupies exactly
   what it occupies for everybody else, because moving it is the one thing
   somebody who asked for less movement would notice.

   The animated path above is untouched. */
@media (prefers-reduced-motion: reduce) {
  /* The rail full to the end of its run, in the one property the line's length
     is drawn from — so it is drawn full rather than drawn at all. */
  .pipeline {
    --pipeline-fill: 1;
  }

  /* Every node paid and live: the dot's ring, its fill and the words under it
     read the first two, and the third takes the glow off — the mockup drops the
     shadow on a node that has filled, and every node here has. */
  .pipeline__node[data-state] {
    --pipeline-node-color: var(--color-mint);
    --pipeline-node-edge: var(--color-mint);
    --pipeline-node-glow: 0 0 0 0.4375rem transparent;
  }

  .pipeline__node[data-state] .pipeline__dot {
    background-color: var(--pipeline-node-color);
  }

  .pipeline__node[data-state] .pipeline__check {
    opacity: 1;
  }

  /* And the words that go with the colour, which is the whole reason the
     labels are in the markup (WCAG 2.1 AA 1.4.1): the paid label — "Paid and
     live", and "Live" under Launch — in place of the queued one the server
     rendered, so a mint node cannot be sitting over the word Queued. */
  .pipeline__node[data-state] .pipeline__state-label[data-pipeline-label] {
    display: none;
  }

  .pipeline__node[data-state] .pipeline__state-label[data-pipeline-label="paid"] {
    display: block;
  }

  /* The finished figure, rendered from the quote file, in place of the slot
     app.js counts into. The slot goes rather than being left empty beside it:
     an empty flex item still takes a gap in the stacked footer. */
  .pipeline__tally {
    display: none;
  }

  .pipeline__tally--still {
    display: block;
  }

  /* And nothing eases into any of it. The blanket rule at the foot of this file
     collapses a duration to 0.01ms, which is a hundredth of a millisecond of
     movement rather than none; `none` is one declaration that cannot be half
     done, and these four are every transition the stepper has. */
  .pipeline__rail::after,
  .pipeline__dot,
  .pipeline__check,
  .pipeline__state {
    transition: none;
  }
}

/* ---- Quote band ------------------------------------------------------- */

/* The band under the hero: the explainer on the left, the sample quote on the
   right.

   It is the frame step, one above the page the hero is, and that single step is
   the whole of what makes it a band — no inversion, no rule, and nothing here
   that was drawn to be read against white. It is the first of the two
   alternating bands on this page; the closing call to action is the other, and
   the two carry the same token so they cannot drift apart.

   Narrow first, like the rest of the file: the base rules stack the two
   columns with the explainer above the card, and the `@container` block at the
   foot of this section is the side-by-side pair, at the 47rem two columns of
   anything need.

   The card that fills the right-hand column has a section of its own below
   this one; what is here is the column it sits in and the footnote under it. */

/* The band is a query container, so what is inside it can ask how much room it
   has without either of them knowing how wide the window is. See the note over
   the first @container rule below. */
.quote-band {
  container: band / inline-size;

  /* The section is the target of the nav's "How it works" link and the hero's
     "See how it works" CTA, so the margin is pinned here rather than left to
     the blanket [id] rule at the top of this file: what that rule is worth to
     a heading someone lands on directly is this section's problem, and the
     band's own top padding sits below it. */
  scroll-margin-block-start: var(--space-xl);

  padding-block: var(--section-padding-block);
  padding-inline: var(--layout-gutter);
  /* The seam the mockup draws over every band after the hero: the plain
     hairline, which is a change of surface said twice rather than a divider
     doing the work on its own. */
  border-block-start: 1px solid var(--color-line);
  background-color: var(--color-paper-sunk);
}

.quote-band__inner {
  display: grid;
  /* The mockup's 64px between the explainer and the card. */
  gap: var(--space-2xl);
  max-width: var(--layout-max);
  margin-inline: auto;
}

/* The mockup holds this heading to fifteen characters, so "A quote that fits
   your budget, fast." breaks into three short lines rather than running the
   width of the column — which is what makes it read as a heading set for a
   printed page. */
.quote-band__headline {
  max-width: var(--measure-headline-short);
  font-size: var(--text-3xl);
}

.quote-band__body {
  max-width: var(--measure-aside);
  margin-block-start: var(--space-md);
  color: var(--color-ink-muted);
  font-size: var(--text-sm);
}

/* The chip row under the body copy. The list itself is the row: its own margin
   is what holds it off the paragraph, and the browser's list indent and bullets
   are dropped, because the chips are pills rather than a bulleted list.

   flex-wrap and nothing else about the width. Three chips are wider than the
   explainer column at either layout, so the last one drops to a second line and
   the gap between the two rows is the gap between the chips. That is the whole
   of the responsive behaviour here: the rest of it belongs to the tickets that
   own the breakpoint. */
.quote-band__chips {
  display: flex;
  flex-wrap: wrap;
  gap: var(--space-2xs);
  margin-block: var(--space-lg) 0;
  padding: 0;
  list-style: none;
}

/* A chip, in the mockup's treatment: an outline and nothing inside it, cut to
   the 2px corner the buttons are, carrying the small uppercase label at .14em.

   NO FILL, WHICH IS THE CHANGE. It stood on --color-paper-raised-3, two steps
   above its own band, which drew three filled pills in a row under the body
   copy — a heavier thing than the mockup has, and a heavier thing than three
   words nobody can press should be. The mockup's .chip has a border and no
   background at all: what tells it from the band is its edge. The muted cream
   on the band is 6.8:1, which clears WCAG 2.1 AA 1.4.3 as small text.

   The pill corner went with the fill: this is a card's corner rather than a
   tag's, and --radius-xs is the 2px every cut corner on this site is.

   Nothing here says it can be pressed. There is deliberately no :hover, no
   :focus, no cursor: pointer and no transition on this rule — the markup has no
   control in it, and a chip that lit up under the pointer would promise one. */
.quote-band__chip {
  padding-block: var(--space-2xs);
  padding-inline: var(--space-xs);
  border: 1px solid var(--color-line-strong);
  border-radius: var(--radius-xs);
  color: var(--color-ink-muted);
  font-size: var(--text-2xs);
  font-weight: var(--weight-regular);
  letter-spacing: var(--tracking-label);
  text-transform: uppercase;
}

@container band (min-width: 47rem) {
  /* The explainer on the left and the card on the right. The card carries a
     row of line items with a figure at the end of each, so it takes the larger
     share; minmax(0, …) so a long word in either column cannot widen it past
     its share and push the band into a horizontal scroll.

     The proportions have had that pass now: the mockup's .band is .85fr to
     1.15fr, and 5 to 7 is .833 to 1.167 — the same split to within a fifth of a
     percent of the column, which is under a pixel at 1024. */
  .quote-band__inner {
    grid-template-columns: minmax(0, 5fr) minmax(0, 7fr);
    align-items: center;
  }
}

/* ---- Sample quote card ------------------------------------------------ */

/* The illustration in the right-hand column of the band, drawn as a printed
   menu: a two-part header row over a hairline, two courses in brass small caps
   with a tag apiece, five lines each running label, dotted leader, price, then
   the subtotal, the total, the terms and the footnote.

   THE LEADER IS DRAWN HERE AND NOWHERE ELSE. .quote-card__leader is an empty,
   aria-hidden span in the markup with not one period in it; everything it is
   comes from the rule below. Each label cell holds a flex row — the label text,
   then the leader taking `flex: 1` with a dotted bottom border — so the dots
   run from the end of the label to the start of the price at whatever width the
   card happens to be. A row of typed periods would be read out as a mouthful of
   dots, could not stretch, and would break the moment a label reflowed.

   NOTHING HERE IS A CONTROL. There is deliberately no :hover, no :focus, no
   cursor and no transition in this whole section: the markup holds no anchor,
   no button and nothing focusable, and a card that lit up under the pointer
   would promise one. It is a picture of a quote.

   One layout at both widths. The card is a table and a table reflows on its
   own — the amount column is as wide as its figures and the label column takes
   what is left — so there is nothing for the 860px block to rearrange and no
   rule from this section is in it. At 360 the label wraps and the leader, whose
   flex basis is zero, is squeezed out of the row rather than pushing the price
   off the card. The footnote is a sibling of the card inside the same wrapper,
   which is what keeps it beside the card at 360px and at 1180px alike.

   Every colour, size and step here is a token. */

/* THE CARD IS SET INTO THE BAND, NOT LIFTED OFF IT, and that is the largest of
   this section's reconciliations. The mockup prints its .quote on --frame
   inside a band that is --panel: the card is a step *down* from the surface
   round it, enclosed by the lit hairline and cut to the same 2px corner as
   everything else, with no shadow anywhere near it. This file had it a step up
   with a soft shadow under it, which is a card floating over a page — the
   language of an application, not of a printed quotation laid on a table.

   So: --color-paper, which is the step below the band's --color-paper-sunk and
   the same relationship the mockup draws; --color-line-strong, which is the
   mockup's --rule-lit round the card; --radius-xs; and no box-shadow at all.
   Every ratio quoted in this section is measured against --color-paper now, and
   all of them went up when the surface went down. */
.quote-card {
  padding: var(--space-lg);
  border: 1px solid var(--color-line-strong);
  border-radius: var(--radius-xs);
  background-color: var(--color-paper);
}

/* The header row: the quotation number at one end, the date it was issued at
   the other, and a hairline under the pair of them. It wraps rather than
   overflowing — at 360 there is not always room for both on one line — and the
   date keeps its end of the row either way, which is what the auto margin is
   for rather than space-between. */
.quote-card__header {
  display: flex;
  flex-wrap: wrap;
  align-items: baseline;
  gap: var(--space-3xs) var(--space-sm);
  padding-block-end: var(--space-sm);
  /* The mockup closes this row with the plain hairline, not the lit one: the
     lit one is round the card, and a rule inside a box does not have to be as
     strong as the box's own edge. */
  border-block-end: 1px solid var(--color-line);
  margin-block-end: var(--space-md);
}

/* The quotation number, in the display serif at the mockup's 500 and opened by
   .02em: it is the card's title line, and the one name on it. The cream is
   15.8:1 on the card's face. */
.quote-card__number {
  color: var(--color-ink);
  font-family: var(--font-serif);
  font-size: var(--text-xl);
  font-weight: var(--weight-medium);
  letter-spacing: var(--tracking-slight);
}

/* And the date, small and quiet at the other end of the row: the mockup's
   .quote-hd span, which is the same tracked uppercase label the sums at the
   foot of the card are set in. The third cream is 6.7:1 on the card's face,
   which clears WCAG 2.1 AA 1.4.3 as small text. */
.quote-card__issued {
  margin-inline-start: auto;
  color: var(--color-ink-faint);
  font-family: var(--font-sans);
  font-size: var(--text-2xs);
  letter-spacing: var(--tracking-caps);
  text-align: end;
  text-transform: uppercase;
  white-space: nowrap;
}

.quote-card__table {
  inline-size: 100%;
  /* Collapsed, so the rules above the subtotal and the total are single
     hairlines rather than a pair of adjacent cell borders. */
  border-collapse: collapse;
}

/* The column headers. Their text is clipped by .visually-hidden inside them,
   so the cells are empty boxes and this is what stops them holding a blank row
   open above the first group. The cells themselves stay: taking a th out of the
   row would leave the table with two columns of data and one column header. */
.quote-card__columns th {
  padding: 0;
  border: 0;
}

/* A course heading: the name of the group, and the tag beside it. It spans both
   columns and heads the rows under it — see scope="rowgroup" in the markup.

   Small caps drawn rather than borrowed: uppercase and letter-spaced, in the
   brass. `font-variant: small-caps` is deliberately not used — the two faces on
   disk carry no small-cap set, so it would be synthesised into shrunken
   capitals of a different weight to the rest of the card. The brass is 6.5:1 on
   the card's face, which clears WCAG 2.1 AA 1.4.3 as small text. */
.quote-card__group-heading {
  padding-block-end: var(--space-2xs);
  color: var(--color-accent);
  font-size: var(--text-2xs);
  font-weight: var(--weight-regular);
  letter-spacing: var(--tracking-widest);
  text-align: start;
  text-transform: uppercase;
}

/* The gap between the two groups, set on the second one rather than under the
   first: the first heading sits directly under the header row, which has its
   own space below it. The mockup's 26px, rounded onto the grid. */
.quote-card__group + .quote-card__group .quote-card__group-heading {
  padding-block-start: var(--space-md);
}

/* The tag beside a course name: "Start here", "Add any, or none". The mockup's
   .grp .tag, and it is not a pill: it is a line of serif italic set beside the
   tracked capitals of the heading, the way a menu writes "market price" beside
   a dish. The wash and the rounded corners this carried were a second chip in
   the middle of a printed card.

   The lit brass is 11.6:1 on the card's face, well past WCAG 2.1 AA 1.4.3. */
.quote-card__tag {
  margin-inline-start: var(--space-2xs);
  color: var(--color-accent-hover);
  font-family: var(--font-serif);
  font-size: var(--text-sm);
  font-style: italic;
  font-weight: var(--weight-regular);
  letter-spacing: var(--tracking-normal);
  text-transform: none;
  white-space: nowrap;
}

/* The second of the two: the mockup drops its "Add any, or none" to the third
   cream, so the group a client may leave off entirely says so more quietly than
   the one they cannot. 6.7:1 on the card's face. */
.quote-card__tag--optional {
  color: var(--color-ink-faint);
}

/* A line's label. It is a th — the row's header — so the weight and the
   alignment a browser gives one are both undone: it reads as the sentence it
   is, not as a heading over the figure beside it.

   The full width is claimed here so the label column takes every pixel the
   amount column does not, which is what leaves the leader something to fill. */
.quote-card__label {
  inline-size: 100%;
  padding-block: var(--space-2xs);
  padding-inline-end: var(--space-2xs);
  color: var(--color-ink);
  /* The mockup's .line is 15px in the 300 and its `em` is the full cream: a
     line on this card reads as a dish on a menu, not as a row header. Without
     the size it inherited the body's 17px, which is a size above every other
     word in the card. */
  font-size: var(--text-sm);
  font-weight: var(--weight-light);
  text-align: start;
}

/* The flex row inside a label cell: the words, then the leader. It is a span
   inside the th rather than the th itself, because a table cell told to be a
   flex container stops being a cell — and the row header is half of what ties a
   line to its price for a screen reader. */
.quote-card__label-row {
  display: flex;
  align-items: baseline;
  gap: var(--space-2xs);
}

/* The words. They wrap; the leader does not. */
.quote-card__label-text {
  flex: 0 1 auto;
}

/* And the leader itself: no content, no text node, nothing to announce — a
   dotted rule that takes whatever room is left between the label and the price.
   The basis is zero, so at 360, where the label already fills the row, it is
   squeezed to nothing instead of pushing the price off the card.

   Drawn in the mockup's own colour for it, which is the lit hairline: its
   `.line .dots` is `1px dotted var(--rule-lit)`, and the dots this file drew in
   the third cream were a rule as strong as the words either side of it. Nudged
   up four pixels, also the mockup's, so the row of dots runs through the middle
   of the gap rather than sitting on the baseline the label ends on — in the root
   unit, because it is a quarter of the line's own size and has to stay a quarter
   of it at every width. The dots themselves are a hairline and stay 1px. */
.quote-card__leader {
  flex: 1 1 0;
  min-inline-size: 0;
  border-block-end: 1px dotted var(--color-line-strong);
  transform: translateY(-0.25rem);
}

/* The italic "optional" after a label, from the line's own flag. The mockup's
   .line .opt: the third cream, so it reads as an aside to the label rather than
   as part of it, at 14px with 9px of air before it. 6.7:1 on the card's face.

   The serif, because it is the family with an italic on disk: Jost is held
   upright only, so an italic asked of it is one the browser slants itself. */
.quote-card__optional {
  margin-inline-start: var(--space-2xs);
  color: var(--color-ink-faint);
  font-family: var(--font-serif);
  font-size: var(--text-sm);
  font-style: italic;
}

/* And a line's figure. The mockup sets it in the sans at the line's own size
   and weight, in the second cream: a price on a menu is part of its line and
   not a heading over it, and the serif is kept for the two sums at the foot of
   the card. This was the serif a size larger in the full cream, which drew five
   prices louder than the five things they were prices for.

   Tabular numerals so the columns of digits line up down the card, and nowrap
   so "$11,200" is never folded across two lines. 9.3:1 on the card's face. */
.quote-card__amount {
  padding-block: var(--space-2xs);
  color: var(--color-ink-muted);
  font-family: var(--font-sans);
  font-size: var(--text-sm);
  font-variant-numeric: tabular-nums;
  text-align: end;
  white-space: nowrap;
}

/* The subtotal and the total: a rule across the card, and the label beside the
   figure set as the small tracked capitals the mockup's .sub and .total use.
   The border is on the cells rather than on the row, because the table's
   borders are collapsed and a row border is drawn by the cells anyway. */
.quote-card__sum > * {
  border-block-start: 1px solid var(--color-line);
  padding-block-start: var(--space-sm);
}

/* The label at the near end of a sum — "Minimum viable build", "Full build".
   The mockup sets both in the same 11px uppercase at .16em; what differs is
   the cream, and that is set on each of the two rows below. */
.quote-card__sum .quote-card__label {
  color: var(--color-ink-muted);
  font-size: var(--text-2xs);
  font-weight: var(--weight-regular);
  letter-spacing: var(--tracking-caps);
  text-transform: uppercase;
}

/* And the figure beside it: back into the display serif, at the mockup's 26px
   in the regular. The two sums are the only figures on this card the serif is
   spent on, which is what makes them read as sums rather than as two more
   lines. 15.8:1 on the card's face. */
.quote-card__sum .quote-card__amount {
  color: var(--color-ink);
  font-family: var(--font-serif);
  font-size: var(--text-2xl);
  font-weight: var(--weight-regular);
}

/* The last row, and the one figure the card is read for. */
.quote-card__sum--total > * {
  border-block-start-color: var(--color-line-strong);
}

/* Its label drops a cream: the mockup sets the subtotal's in --cream-2 and the
   total's in --cream-3, so the bigger number is the louder half of its own row.
   6.7:1 on the card's face. */
.quote-card__sum--total .quote-card__label {
  color: var(--color-ink-faint);
}

/* THE TOTAL IS THE LIT BRASS AND NOT THE MINT, which is the mockup's `.total b`
   read as it renders. The mint is the colour this site keeps out of the brass
   family on purpose, and the brief spends it in two places: the two words the
   headline emphasises with the strokes under them, and the pipeline's finished
   nodes. The price at the foot of this card is neither — it is the figure the
   whole page is pointed at, and the brand's own brightest colour is what the
   mockup puts it in. 11.6:1 on the card's face.

   42px in the regular, tracked open by a hundredth: the mockup's own three
   numbers for it, and a step over the 22px semibold it was.

   THE 42px IS THE MOCKUP'S AT THE BREAKPOINT AND SCALES BELOW IT, and that is
   the responsive pass's one change to this card. The table is auto-laid-out, so
   the amount column is as wide as the widest figure in it — and the widest is
   this one, which does not wrap. At 360px the card has 246px inside its border
   and its padding, and a 42px "$18,400*" is 140 of them: the price column took
   57% of the card, the five labels were left 106px to break across three and
   four lines each, and every dotted leader was squeezed to nothing because
   there was no gap left for one to run through. The card stopped reading as a
   printed menu at exactly the width the ticket asks about.

   A clamp rather than a media query, which is what the one-breakpoint rule asks
   for: the figure is the mockup's 42px from about 857px up — 4.9vw is 42.1px at
   860 — ramps down with the viewport under that, and floors at --text-2xl,
   which is the size the subtotal above it is already set in and so the point
   below which shrinking this one buys the labels nothing. Nothing at or above
   the breakpoint moves, so the frame the mockup draws is unchanged.

   The 4.9 is --text-4xl over the breakpoint's own width and is a viewport
   fraction because there is no other unit here that can see the width: the card
   is a table cell inside a grid track inside a band, and none of those is
   something a length can be measured against without a container query. */
.quote-card__sum--total .quote-card__amount {
  color: var(--color-accent-hover);
  /* 5.6vw and not the 4.9vw this was, and the extra is not a change of
     design. The ceiling used to be a flat 42px, so 4.9vw reached it at 858px
     and the figure settled exactly where the band splits in two. --text-4xl is
     a ramp now — 42px on a phone, 52px at 1440 — so the same 4.9vw never
     catches a ceiling that is climbing with it, and the total would have gone
     on growing with the window instead of settling into the card. 5.6vw meets
     the ceiling at the same place it always did, which is the width the card
     stops being a full-width block. See
     TestTheQuoteCardsTotalSettlesOnceTheCardHasRoom. */
  font-size: clamp(var(--text-2xl), 5.6vw, var(--text-4xl));
  letter-spacing: var(--tracking-slight);
}

/* The footnote's marker on the total. It is aria-hidden in the markup, so this
   is the whole of what it is: a raised star that is not read out — and it is
   the mockup's `.total sup`, back in the sans at 15px in the third cream, so it
   does not grow with the 42px figure it hangs off. */
.quote-card__asterisk {
  /* The mockup's 2px of air before the star, in the root unit. */
  margin-inline-start: 0.125rem;
  color: var(--color-ink-faint);
  font-family: var(--font-sans);
  font-size: var(--text-sm);
  vertical-align: super;
}

/* The terms line under the total, inside the card: the mockup's .terms, which
   is the serif italic in the third cream — the same aside treatment the
   stepper's caption and the work section's disclosure carry. 6.7:1 on the
   card's face. */
.quote-card__terms {
  margin-block-start: var(--space-md);
  color: var(--color-ink-faint);
  font-family: var(--font-serif);
  font-size: var(--text-sm);
  font-style: italic;
}

/* And the footnote, outside the card and immediately under it — the mockup
   keeps it inside, under the terms, and the note in the closing summary says
   why this page does not. The treatment is the mockup's .terms .fn either way:
   back in the sans, upright, at the smallest step, opened by a fiftieth. The
   third cream is 6.4:1 on the band's surface, which it sits on rather than on
   the card's face. */
.quote-band__footnote {
  margin-block-start: var(--space-sm);
  color: var(--color-ink-faint);
  font-size: var(--text-2xs);
  letter-spacing: var(--tracking-slight);
}

/* ---- Work ------------------------------------------------------------- */

/* The section under the quote band: the heading, the disclosure that qualifies
   every card in it, and the row of three concept builds.

   Back on the page, one step down from the band above it and one step below the
   closing call to action under it, which is what the alternation down this page
   is: page, page, frame, page, frame, page. The surface is named here rather
   than inherited even though it is the body's own colour, because a band that
   does not say which step it is on is a band the next reader has to work out.

   The cards inside it are the panel step, so the row lifts off the page by a
   step and a hairline. Nothing in this section is drawn to be read against
   white and nothing in it is inverted.

   Narrow first, like the rest of the file — and this section has no second
   block at all. The row is `auto-fit` with a `minmax` floor, so it goes from
   one column to two to three on its own as there is room; see the note over
   .work__cards. */

.work {
  /* The section is the target of the nav's "Work" link, so the margin is pinned
     here rather than left to the blanket [id] rule at the top of this file:
     what that rule is worth to a heading someone lands on directly is this
     section's problem, and the section's own top padding sits below it. */
  scroll-margin-block-start: var(--space-xl);

  padding-block: var(--section-padding-block);
  padding-inline: var(--layout-gutter);
  /* The seam over the band, like the quote band above it. */
  border-block-start: 1px solid var(--color-line);
  background-color: var(--color-paper);
}

.work__inner {
  max-width: var(--layout-max);
  margin-inline: auto;
}

/* The mockup's .sec h2 is 32px, a step under the quote band's 40px: this
   section is a list of three things and the band above it is the page's
   argument, so the two headings are deliberately not the same size. */
.work__headline {
  font-size: var(--text-2xl);
}

/* The disclosure under the heading. Ordinary page copy — §6 keeps it visible in
   the reading flow — and the mockup's .sec-note treatment for it: the serif
   italic at 15px in the third cream, sitting close under the heading, which is
   the voice this page gives a qualification. It was the sans at 19px in the
   second cream, a step from what the heading itself is.

   --color-ink-faint and not the mockup's --cream-3, which is 4.3:1 on the top
   of the surface ladder; 6.7:1 on the page this section is. */
.work__disclosure {
  max-width: var(--measure);
  margin-block-start: var(--space-2xs);
  color: var(--color-ink-faint);
  font-family: var(--font-serif);
  font-size: var(--text-sm);
  font-style: italic;
}

/* The row the cards sit in. One column here, three at the breakpoint. The two
   numbers are the mockup's 34px under the note and 22px between the cards. */
/* THE ONE LAYOUT ON THE PAGE THAT ASKS NOTHING AT ALL, which is the shape to
   reach for before either a container query or a media query.

   `auto-fit` with a `minmax` floor says what the cards need rather than where
   the row changes: a card is unreadable under 15rem, so fit as many 15rem
   columns as there is room for and let them share what is left over. Three
   cards land as one column on a phone, two in the middle and three from about
   800px, and nothing had to be told those numbers. `auto-fit` rather than
   `auto-fill` so the empty tracks a wide row would leave are collapsed and the
   three cards stretch to fill the width instead of huddling at the left.

   This used to be `repeat(3, minmax(0, 1fr))` inside the 860px block, which
   is the same row for the one case where the section has exactly three cards
   and a full-width page to draw them on. A fourth card would have gone under
   the first, alone, and nobody would have found out until it did. */
.work__cards {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(15rem, 1fr));
  gap: var(--space-md);
  margin-block-start: var(--space-lg);
}

/* A card: the swatch, the name and the blurb.

   NOTHING HERE IS A CONTROL. The markup holds no anchor, no button and nothing
   focusable, and there is deliberately no pointer cursor and no focus state in
   this section — a card cannot take focus, so a focus style would be dead
   weight that also promised one.

   The hover lift is the exception, and it is the mockup's affordance and
   nothing else: the card rises four pixels under the pointer and that is the
   whole of what happens. There are no case-study pages in v1, so there is
   nothing behind it to click through to. When those pages exist the card
   becomes the link and this rule is what it will already look like. The
   transition is collapsed with the rest of the motion at the foot of this file
   for anyone who asks for less of it. */
/* NO PADDING AND NO SHADOW, WHICH IS THE MOCKUP'S CARD. Its .wk is a panel with
   its corners cut at 2px, `overflow: hidden`, and the swatch running edge to
   edge inside it — the padding is on the body under the swatch, not on the card
   round both. A padded card leaves a margin of panel showing round the
   placeholder, which is not what a screenshot in a card looks like. The shadow
   went with it: nothing on the mockup's first frame casts one.

   The hover is the mockup's pair rather than the lift alone: the edge comes up
   to the brass as the card rises three pixels, over the .22s the mockup eases
   both in. */
.work-card {
  overflow: hidden;
  border: 1px solid var(--color-line);
  border-radius: var(--radius-xs);
  background-color: var(--color-paper-raised);
  transition: border-color var(--duration-base) var(--ease-out),
    transform var(--duration-base) var(--ease-out);
}

.work-card:hover {
  border-color: var(--color-accent);
  /* The mockup's three pixels of lift, in the root unit: the lift is how far the
     card rises off the page and a card four fifths larger has to rise four
     fifths further for the move to read as the same one. */
  transform: translateY(-0.1875rem);
}

/* The placeholder a screenshot will one day be, and it is the mockup's diagonal
   panel stripe now rather than the flat block of the slab it was: an angled
   band of the two panel steps, repeated across the same box, at the same fixed
   ratio, so the card is the height it will be once there is an image in it.

   IT IS DRAWN AND NOT FETCHED. A gradient is a background-image the browser
   paints from these two tokens, so the stripe costs the page no request, no
   file and no byte of transfer — which is what the ticket asked of it and what
   the Lighthouse 95 bar is kept with. There is no image, no SVG and no data URI
   here, and there is nothing to add: this is the whole of the drawing.

   THE STRIPE MOVED THE SWATCH UP THE LADDER. The block used to be the slab, one
   step below the card's own face, so it read as a well set into it; the panel
   steps are one and two steps above that face, so it reads as a panel on the
   card. That is the mockup's, and it is why --color-slab is no longer named
   here — it is the token for something set into a lighter face, and this is not
   that any more. The slab still names the internal bar, in internal.css.

   HARD STOPS, AND A PITCH THAT DOES NOT SCALE WITH THE BOX. Both are what keeps
   the stripe the same at 1440, 768 and 360: the repeat is a fixed distance, so
   a wider card carries more bands rather than wider ones, and each band is one
   flat colour rather than an interpolation — the two panel steps are eleven,
   nine and seven values apart per channel, and a soft ramp of that over the
   width of a card is exactly the gradient that bands visibly.

   The background-color under it is the step the stripe stands on, named for the
   same reason every band on this page names its own: a box that does not say
   which step it is on is a box the next reader has to work out.

   It is a flex box only so the label can sit at the foot of it; the ratio is
   what holds the block open, and a label that wraps at a narrow width grows it
   rather than spilling out of it — aspect-ratio yields to content. */
.work-card__swatch {
  /* The stripe's geometry: the angle the bands run at, and the distance from
     one band to the next. Both are shape rather than palette — like the ratio
     below, the scale has no token for either — and they are held here so the
     gradient reads as one stripe instead of four numbers. 135deg puts the
     bands on the rising diagonal; half the pitch each is an even stripe. */
  --work-stripe-angle: 135deg;
  --work-stripe-pitch: 1.25rem;

  display: flex;
  align-items: flex-end;
  aspect-ratio: 16 / 10;
  /* The mockup's 18px from the left edge and 14px from the bottom, as one
     padding on the box the label sits at the foot of. */
  padding: var(--space-sm);
  /* Square, and closed with the mockup's own hairline: the card round it is
     `overflow: hidden` now and the swatch runs edge to edge inside it, so what
     separates the picture from the words under it is a rule rather than a gap.
     The rounded corner it carried was the corner of a box inside a padded
     card. */
  border-block-end: 1px solid var(--color-line);
  background-color: var(--color-paper-raised-2);
  background-image: repeating-linear-gradient(
    var(--work-stripe-angle),
    var(--color-paper-raised-2),
    var(--color-paper-raised-2) calc(var(--work-stripe-pitch) / 2),
    var(--color-paper-raised-3) calc(var(--work-stripe-pitch) / 2),
    var(--color-paper-raised-3) var(--work-stripe-pitch)
  );
}

/* The label on it. The small uppercase treatment the rest of the page gives a
   label, in the lit brass — and it has to clear WCAG 2.1 AA 1.4.3 against both
   halves of the stripe behind it, not against an average of them: 9.6:1 on
   --color-paper-raised-2 and 8.5:1 on --color-paper-raised-3, so the darker
   band and the lighter one both carry it as small text several times over. No
   pill behind it — the stripe is already the surface it reads against.

   The plain brass and not the lit one: the mockup sets this label in --brass,
   which is a step under the lit brass this carried. 5.3:1 on the lighter band
   of the stripe and 6.0:1 on the darker, so both halves clear 4.5:1. And the
   regular at .18em rather than the 600 at .08em — a semibold at 12px with the
   letters that close together is a label shouting, and this one names a card. */
.work-card__label {
  color: var(--color-accent);
  font-size: var(--text-2xs);
  font-weight: var(--weight-regular);
  letter-spacing: var(--tracking-widest);
  text-transform: uppercase;
}

/* The card's body: the name and the blurb, padded by the mockup's 20px each
   side and its 20px over and 24px under. The card itself has no padding — see
   .work-card — so the two lines carry it, which is what lets the swatch above
   them run to the card's own edge.

   The name is the 500, one of the three places on the page that weight is
   spent: the heading rule sets every h1 to h4 in the 300, and a work card's
   name is the mockup's .wk b rather than a display heading. */
.work-card__name {
  margin-block: var(--space-md) 0;
  margin-inline: var(--space-md);
  font-size: var(--text-xl);
  font-weight: var(--weight-medium);
}

.work-card__blurb {
  margin-block: var(--space-2xs) var(--space-md);
  margin-inline: var(--space-md);
  color: var(--color-ink-muted);
  font-size: var(--text-sm);
}

/* ---- Closing call to action -------------------------------------------- */

/* The last band before the footer: a heading, one line under it and the brass
   call to action.

   The frame step, the same token the quote band takes: the two are the page's
   two alternating bands and reading one token keeps them from drifting apart.
   The work section above it is a step down and the footer below it is a step
   down again, so this band is told from both of its neighbours by the ladder
   alone — no rule, and nothing inverted. What the brass button on it contrasts
   against is the button system's to hold, not this section's.

   NOTHING HERE DRAWS THE BUTTON. Its face is .button and .button--primary at
   the top of this file, which is the hero's call to action as well: the two
   are one set of styles, and this section sets the space above the button and
   no more. A colour, a radius or a padding added here is a second primary
   button, which is the thing the ticket rules out.

   One layout at both widths. The band is a single column of three stacked
   pieces at 360px and at 1180px alike, so no rule of this section is in the
   860px block; the type sizes and the gutter grow there on their own, from the
   tokens. */

/* CENTRED, WHICH IS THE MOCKUP'S AND WAS THE LARGEST THING WRONG WITH THIS
   BAND. Its .close is `text-align: center` with the heading and the line under
   it held to twenty and fifty-two characters and centred in the column; this
   band was left-aligned against the gutter, which is the same three pieces laid
   out as another section rather than as the end of the page. One declaration
   here does the text, and the two auto margins below do the blocks. */
.closing-cta {
  padding-block: var(--section-padding-block);
  padding-inline: var(--layout-gutter);
  border-block-start: 1px solid var(--color-line);
  background-color: var(--color-paper-sunk);
  text-align: center;
}

.closing-cta__inner {
  max-width: var(--layout-max);
  margin-inline: auto;
}

/* The mockup's 42px over twenty characters, which breaks the sentence into
   three centred lines. */
.closing-cta__headline {
  max-width: var(--measure-headline);
  margin-inline: auto;
  font-size: var(--text-4xl);
}

/* The line under it, set like the body copy in the band above: the muted cream,
   which is 8.9:1 on the frame step and clears WCAG 2.1 AA. The mockup holds it
   to 52ch and --measure-aside is 46ch; see the note on that token for why it
   does not earn a fourth measure six characters from the third. */
.closing-cta__body {
  max-width: var(--measure-aside);
  margin-block-start: var(--space-sm);
  margin-inline: auto;
  color: var(--color-ink-muted);
  font-size: var(--text-sm);
}

/* The block the one call to action sits in. Its margin is the whole of what
   this rule is for — the button is an inline-block, so it is already the width
   of its own words rather than of the column, and the centring is the band's
   text-align reaching it. The mockup's 32px. */
.closing-cta__action {
  margin-block-start: var(--space-lg);
}

/* THERE IS NO RING OVERRIDE IN THIS SECTION ANY MORE, like the bar and the hero
   above it: the blue was 2.8:1 on the white page's dark slab, and the mockup's
   lit brass that replaced it is 11.0:1 on the frame step this band is, past
   WCAG 2.1 AA 1.4.11's 3:1 (2.4.7). The one focusable thing in the band is the
   call to action, and a button carries the button system's copy of that same
   ring wherever it stands. */

/* ---- Site footer ------------------------------------------------------ */

/* One row at the bottom of every page: the wordmark, the copyright line and the
   three links.

   The page, and a lit hairline along the top of it — the bar's rule, upside
   down, and there for the same reason. The footer used to be the slab, which is
   what made it a footer while the page was white; on a warm-night page it is
   the page's own foot, and the rule is what says the page has ended. On the home
   page the closing call to action above it is already a step up, so the hairline
   is a seam rather than the only thing there; on /quote, /privacy and /terms
   what sits above it is the page too, and the hairline is all of it. One rule
   for both, because this footer is the shell's and is served on every page.

   The ink is the body's. Nothing here is inverted, so no rule in this section
   names an -inverse token and the site's own focus ring is what the three links
   take.

   Narrow first, like the rest of the file. In a footer under about 34rem the
   three pieces stack in reading order against the gutter — at 360px there is
   nowhere near room for the row, and stacked left-aligned lines are what
   wrapping sensibly looks like there. The `@container` block at the foot of
   this section is the row: the wordmark at one end, the links at the other,
   and the copyright beside the wordmark. Its threshold is the lowest on the
   page, because a row of four short links is the easiest thing here to fit. */

/* The inset on the band and the width on the wrapper, which is the bar's own
   split and every other band's — see .site-header for the whole of why. This
   footer carried the bar's bug as well, and it had to: the two are the shell's
   pair, written from the same shape, so the wordmark at the foot of the page
   started 48px inside the wordmark at the top of it and neither stood on the
   line the bands between them do. */
/* The band is a query container, so what is inside it can ask how much room it
   has without either of them knowing how wide the window is. See the note over
   the first @container rule below. */
.site-footer {
  container: band / inline-size;

  padding-inline: var(--layout-gutter);
  border-block-start: 1px solid var(--color-line-strong);
  background-color: var(--color-paper);
}

.site-footer__inner {
  display: flex;
  flex-direction: column;
  gap: var(--space-sm);
  align-items: flex-start;
  max-width: var(--layout-max);
  margin-inline: auto;
  padding-block: var(--space-lg);
}

/* The wordmark, at the bar's own size and weight. It is a mark here and not a
   link — see the layout — so there is no hover and no focus treatment on it,
   only the type. */
.site-footer__wordmark {
  display: inline-flex;
  gap: var(--space-xs);
  align-items: center;
  /* The display voice, like the bar's copy of it: one mark, one face — and the
     bar's own size, weight and tracking, which are the mockup's .wordmark. */
  font-family: var(--font-serif);
  font-size: var(--text-xl);
  font-weight: var(--weight-medium);
  letter-spacing: var(--tracking-open);
}

/* The lighthouse, in the bar's brass — see .site-nav__spark for why it is no
   longer the mint. `flex: none` so it keeps its size when the row is tight,
   rather than being squeezed into an ellipse beside the name.

   It is the same drawing the bar carries, and it names no colour of its own, so
   this one declaration is the whole of what makes it brass down here — the
   strokes it paints are inherited from the box rule beside the bar's copy. What
   its three layers are worth is set there too, in one rule each for both
   copies; the loop that breathes them is the bar's alone. */
.site-footer__spark {
  flex: none;
  color: var(--color-accent-bright);
}

/* The copyright line. The muted cream, which is 9.3:1 on the page and so clears
   WCAG 2.1 AA 1.4.3's 4.5:1 with room to spare — this row is the smallest type
   on the page and is where that margin is worth having. */
.site-footer__copyright {
  color: var(--color-ink-muted);
  font-size: var(--text-sm);
}

/* The three links. They wrap among themselves before the row stacks, so a
   narrow window breaks the line between two of them rather than clipping the
   third. */
.site-footer__links {
  display: flex;
  flex-wrap: wrap;
  gap: var(--space-2xs) var(--space-md);
  align-items: center;
  margin: 0;
  padding: 0;
  list-style: none;
}

/* Muted ink at rest and full ink under the pointer, which is the move the bar's
   own text links make. The browser's underline is left on, unlike the bar's,
   and that is the one difference: these are prose-sized words in a row that is
   otherwise all prose, and the underline is what says they are links at all
   without the colour having to (WCAG 2.1 AA 1.4.1). */
.site-footer__link {
  color: var(--color-ink-muted);
  font-size: var(--text-sm);
  transition: color var(--duration-fast) var(--ease-out);
}

.site-footer__link:hover {
  color: var(--color-ink);
}

/* THERE IS NO RING OVERRIDE IN THIS SECTION ANY MORE, for the reason the bar,
   the hero and the closing call to action have none: the blue was 2.8:1 on the
   white page's dark slab and is 6.7:1 on the page this footer is. The three
   links take the site's one ring (WCAG 2.1 AA 2.4.7). */

@container band (min-width: 34rem) {
  /* The row. The auto margin on the links is what holds them at their end of
     it and the wordmark and the copyright at the other — the same shape the
     bar is built with, and for the same reason: nothing here distributes free
     space, so a line that wraps still reads left to right. */
  .site-footer__inner {
    flex-direction: row;
    gap: var(--space-md);
    align-items: center;
  }

  .site-footer__links {
    margin-inline-start: auto;
  }
}

/* ---- Legal pages ------------------------------------------------------ */

/* /privacy and /terms: a heading and a block of text each, in the shell every
   other page is served in. The narrow column the intake page uses, because
   both are prose and prose wants a readable line; the measure on the body is
   the second half of that, holding the text short of the column when the
   column is wider than a comfortable line. */

.legal {
  padding-block: var(--section-padding-block);
  padding-inline: var(--layout-gutter);
}

.legal__inner {
  max-width: var(--layout-narrow);
  margin-inline: auto;
}

.legal__headline {
  font-size: var(--text-4xl);
}

/* The paragraphs. The gap between them is set on the block rather than on each
   one, so copy that arrives as three paragraphs rather than two needs no rule
   added here. */
.legal__body {
  display: grid;
  gap: var(--space-md);
  max-width: var(--measure);
  margin-block-start: var(--space-md);
  color: var(--color-ink-muted);
  /* The body's own size. It was --text-lg, a step over it, from a scale written
     before the mockup was readable; nothing on the mockup sets running prose
     larger than the base. */
  font-size: var(--text-base);
}

/* ---- Intake page ------------------------------------------------------ */

/* The /quote page: the heading, the lead and the panel the form is written
   into. Same palette, same spacing steps and same shell as the home page —
   what differs is the column, which is narrower here so a long form keeps a
   readable line.

   /quote/received wears these same classes, which is what makes the
   confirmation page read as the last screen of the intake rather than a page
   of its own design. Every rule below except .intake__form's is what that page
   is drawn from, so there is one section to keep in step rather than two.

   THE PAGE, AND ONE PANEL ON IT. Both pages are --color-paper — the step the
   bar above and the footer below them are, so a visitor scrolls the intake
   without meeting a band edge that says nothing — and the surface is named here
   rather than left to the body, for the reason the work section names its own:
   a band that does not say which step it is on is a band the next reader has to
   work out.

   The form is the one thing lifted off it: --color-paper-raised, the card face
   the work cards take, with the enclosing hairline that goes with it. It is
   1.1:1 against the page, so what actually draws the panel is the hairline —
   there is no shadow under it any more, because nothing on the mockup's first
   frame casts one and the quote card it used to share that shadow with does not
   either. The step matters anyway, because it is what the controls inside are
   measured against: they sit a step above it again.

   The corner is the 2px every cut corner on this site is now. */

.intake {
  padding-block: var(--section-padding-block);
  padding-inline: var(--layout-gutter);
  background-color: var(--color-paper);
}

.intake__inner {
  max-width: var(--layout-narrow);
  margin-inline: auto;
}

.intake__headline {
  font-size: var(--text-4xl);
}

.intake__lead {
  max-width: var(--measure);
  margin-block-start: var(--space-md);
  color: var(--color-ink-muted);
  font-size: var(--text-base);
}

/* The panel the form is written into, and the gap above it, which is set here
   so the first field lands in the same place however the form inside is built.
   The padding is --space-md and not the quote card's --space-lg: at 360px the
   column has 312px between the gutters and the wider step would take 64 of them
   off every control in the form.

   The element is the region the page already served the form inside — see
   templates/pages/quote.html — so this is the panel appearing under markup that
   has not moved. */
.intake__form {
  margin-block-start: var(--space-xl);
  padding: var(--space-md);
  border: 1px solid var(--color-line);
  border-radius: var(--radius-xs);
  background-color: var(--color-paper-raised);
}

/* The way back on the confirmation page: the one thing under its heading, and
   the only rule in this file written for that page alone. Only the gap is set —
   the anchor inside is the document's own accent-coloured link, 7.2:1 on the
   page it stands on, and it takes the site's focus ring like every other one,
   so there is no new link treatment here to keep in step.

   Everything else the confirmation page is drawn from is the three rules above:
   the section's surface and padding, the column and the headline. It carries no
   .intake__form, so the panel is not drawn on it. */
.intake__back {
  margin-block-start: var(--space-lg);
}

/* ---- Intake form ------------------------------------------------------ */

/* The intake form: the two fieldsets, the fields inside them and the submit
   button under them.

   One column at every width. The form is inside .intake__inner, which is held
   to --layout-narrow, so a field is already at a readable width on a desktop
   and there is nothing for the breakpoint to rearrange — no rule in this
   section is inside the 860px block.

   THE THREE STEPS THIS FORM IS BUILT ON, and they are the whole of its colour:
   the page under everything, .intake__form's panel over it, and each control a
   step above the panel again on --color-paper-raised-2, which tokens.css names
   for a panel on a card. A control drawn on the page — which is what this
   section did while the page was white and the field was the white — sits two
   steps below the panel around it and reads as a hole rather than as a field.

   The words on all three are the cream pair: the label and a control's value in
   --color-ink, the hint under the label and the Required/Optional flag beside
   it in --color-ink-muted. Nothing in the form is set in the third step, which
   is deliberate — a hint is the sentence somebody reads to fill the field in,
   not an aside to it, and 8.4:1 is what that is worth.

   THE ONE THING THAT IS NOT A CREAM OR A SURFACE IS THE CONTROL'S EDGE, and it
   is the one place this section could fail an audit quietly. A field's border is
   the only thing saying where the field is, so WCAG 2.1 AA 1.4.11 asks 3:1 of it
   against what is behind it — and it has two things behind it here, the control's
   own fill and the panel the control sits on. Neither hairline clears that on
   either: the mockup's lit hairline is 1.8:1 and 2.0:1, the plain one 1.2:1 and
   1.3:1. --color-line-control is the token that does, at 3.9:1 and 4.2:1, and
   the measurement is recorded in its comment in tokens.css.

   The refused state is at the foot of this section: a message under the
   control and a border on the control itself, both hung off the markup that is
   already there rather than replacing any of it.

   The ring is the button system's rather than the site's; the rule on the
   control below says why the form takes the brass one. */

.intake-form {
  display: grid;
  gap: var(--space-xl);
}

/* A fieldset arrives with a border, a padding and a margin of the browser's
   own choosing, none of which the design has. It also defaults to
   min-inline-size: min-content and refuses to shrink below it, which is what
   would push a long unbroken line past the gutter at 360px. */
.intake-form__group {
  display: grid;
  gap: var(--space-lg);
  min-inline-size: 0;
  margin: 0;
  border: 0;
  padding: 0;
}

/* And the rule between the two halves of the form. The work is one fieldset and
   the person is the other, and inside the panel there is nothing else saying
   where one ends — the form's own gap is the same gap that holds two fields
   apart, so without this the legend "About you" reads as a fourth field label.

   --color-line-strong and not --color-line: this divides, so it has to be seen
   rather than felt, which is the same call the bar's underline and the quote
   card's header rule make. It is 2.0:1 on the panel, which is what a hairline is
   worth and is not held to 1.4.11 — the fieldsets it separates are not controls
   and the legends above them say the same thing in words.

   The padding is the form's own gap repeated below the rule, so the rule sits
   halfway between the last field of one group and the legend of the next rather
   than crowding the legend. Set on the second group rather than under the first,
   for the reason the quote card sets its group spacing the same way round. */
.intake-form__group + .intake-form__group {
  border-block-start: 1px solid var(--color-line-strong);
  padding-block-start: var(--space-xl);
}

/* The legend is the group's heading in everything but element: it names the
   half of the form under it, and a screen reader reads it with each control
   inside. It is not an h2 — the page's outline is the heading levels', and a
   legend is what a fieldset is labelled by.

   The margin below it is not the fieldset's gap: a legend is laid out in the
   fieldset's border area rather than as a grid item inside it, so the gap that
   separates the fields from each other never reaches it. */
.intake-form__legend {
  margin-block-end: var(--space-sm);
  padding: 0;
  font-size: var(--text-xl);
  /* The 500, which is the weight a name on this site is set in — the wordmark,
     a work card's name, the quotation number. It read --weight-bold, which is
     the 700 the heading rule carried before the reconciliation pass and which
     nothing on the public pages is drawn in any more. */
  font-weight: var(--weight-medium);
  letter-spacing: var(--tracking-normal);
}

/* One field: its label, the hint under it and the control under that, in that
   order and in that stack. One gap between all three, so a field with a hint
   and a field without one open their control at the same distance from the
   label above it. */
.field {
  display: grid;
  gap: var(--space-2xs);
}

/* A flex row rather than a block, so the Required or Optional flag sits beside
   the label text and wraps under it on a narrow screen instead of stretching
   the row. */
.field__label {
  display: flex;
  flex-wrap: wrap;
  gap: var(--space-2xs);
  align-items: baseline;
  /* The full cream, named here rather than inherited from the body: the label
     is the one line of a field somebody has to read to answer it, and a rule
     that says which step it is on is a rule the panel under it cannot quietly
     move. 14.2:1 on that panel. */
  color: var(--color-ink);
  font-weight: var(--weight-medium);
}

.field__flag {
  color: var(--color-ink-muted);
  font-size: var(--text-2xs);
  font-weight: var(--weight-regular);
  letter-spacing: var(--tracking-wide);
  text-transform: uppercase;
}

/* The sentence under a label. It is a real paragraph the label's control points
   at with aria-describedby, not a placeholder: a placeholder disappears the
   moment someone types, which is exactly when it is being read from.

   IT IS ALSO WHERE THE INTAKE'S RULES ARE STATED. The attachments hint carries
   the two size limits, rendered from the same constants internal/intake refuses
   a file by, and it is the only place on the page those rules are visible — the
   #intake-rules block at the foot of the template is application/json, which a
   browser parses as data and draws nothing of. So this is the rules block's own
   treatment as well as the hint's, and it is held to 4.5:1 rather than to what a
   caption would need: 8.4:1 on the panel. */
.field__hint {
  max-width: var(--measure);
  color: var(--color-ink-muted);
  font-size: var(--text-sm);
}

.field__control {
  inline-size: 100%;
  padding: var(--space-2xs) var(--space-xs);
  /* --color-line-control, not one of the hairlines: this border is the only
     thing saying where the field is, so it is held to WCAG 2.1 AA 1.4.11's
     3:1 rather than to what a divider needs — and to it twice, because a
     control's edge has its own fill on one side and the panel on the other.
     3.9:1 and 4.2:1; see the note at the top of this section. */
  border: 1px solid var(--color-line-control);
  border-radius: var(--radius-md);
  /* A step above the panel the form is on, which is what tokens.css keeps
     --color-paper-raised-2 for. It was --color-paper while the page was white
     and the field was the white on it; on a warm-night page that is the darkest
     thing in the file, two steps under the panel around it, and a field drawn
     in it reads as a hole cut in the form rather than as somewhere to type. */
  background-color: var(--color-paper-raised-2);
  color: var(--color-ink);
  /* A form control inherits neither the page's typeface nor its size, so both
     are named here; without them a textarea is set in the browser's monospace
     at 13px. */
  font-family: inherit;
  font-size: var(--text-base);
  line-height: var(--leading-base);
  transition: border-color var(--duration-fast) var(--ease-out);
}

/* Under the pointer the edge comes up a step, from the control token to the
   second cream — 7.7:1 on the control's own fill, so the move is visible and
   the border cannot drop under 1.4.11 on its way. */
.field__control:hover {
  border-color: var(--color-ink-muted);
}

/* THE RING IS THE BUTTON SYSTEM'S, AND IT IS NO LONGER A DEPARTURE FROM THE
   SITE'S ONE RULE. The fields take the 1px lit brass held 0.25rem off, which is
   the outline .button:focus-visible establishes and the submit under them is
   drawn with — and which the accessibility pass made the site's own rule too,
   so what every other focusable thing on the page now takes is the same
   declaration. Both offsets are the root unit and the hairline is a hairline;
   see the note over .button:focus-visible.

   It is one form, and a keyboard runs the fields and the submit in one pass: two
   rings in that pass is two things to read as meaning different amounts. The
   brass is the one both can wear — the blue that used to be the site's is 1.1:1
   against the submit's brass face and could not be the shared one — and it is
   10.4:1 on the panel the offset puts it on, past WCAG 2.1 AA 1.4.11's 3:1
   several times over (2.4.7).

   The 0.25rem offset is also what keeps the ring clear of the control's own
   border, so a refused field shows its danger edge and its ring at once rather
   than one painted over the other.

   :focus-visible and not :focus, like the button system: a pointer click on a
   text field should not paint a ring. */
.field__control:focus-visible {
  outline: 1px solid var(--color-focus-inverse);
  outline-offset: 0.25rem;
}

/* The textareas. Vertical only: a horizontally resized textarea can be dragged
   out past the column and the page with it. `rows` in the markup sets the
   height it opens at, and there is no maximum — the brief is as long as it is. */
.field__control--multiline {
  resize: vertical;
}

/* The submit button wears the primary CTA's face, and adds the one thing
   .button does not have to say for an anchor: a pointer cursor. The typeface
   is not among them any more — .button names --font-sans itself, for exactly
   this control, and a `font-family: inherit` left here would quietly win over
   it and set the one <button> among the calls to action in whatever the body
   happens to carry. */
.intake-form__submit {
  justify-self: start;
  cursor: pointer;
}

/* The message beside a field a submission was refused over.

   It sits in the field's stack under the control, which is where the field's
   own gap puts it, and it is in the markup whether or not there is anything in
   it — hidden when empty, which is what keeps it out of the layout and out of a
   screen reader's announcement until there is something to say. The control
   names it in aria-describedby, so the words are read out with the field.

   Set at the hint's size rather than smaller: it is the one sentence on the
   page someone has to read to get past it, and the refusal colour is 5.9:1 on
   the panel it is read against — WCAG 2.1 AA 1.4.3 with room, which is what that
   token was opened up from the mockup's red for.

   One colour for both halves of the check. The server writes this paragraph on
   a refusal and app.js writes into the same one inline, so what is drawn here is
   the client state and the server state at once; there is no second class and no
   second colour for either. */
.field__error {
  max-width: var(--measure);
  color: var(--color-danger);
  font-size: var(--text-sm);
  font-weight: var(--weight-medium);
}

/* And the control it belongs to. aria-invalid is the selector on purpose: it is
   the attribute a screen reader reads the state from, so the border cannot come
   on without the state being announced, and a class here would let it.

   :hover is overridden alongside it, or a refused field loses its border colour
   under the pointer.

   5.5:1 against the control's own fill and 5.9:1 against the panel behind it, so
   the refused edge clears 1.4.11 on both sides by more than the resting one
   does — which is the right way round for the state that is asking to be looked
   at. The colour is never the only thing saying so: the message under the
   control is words, and aria-invalid is what a screen reader reads it from. */
.field__control[aria-invalid="true"],
.field__control[aria-invalid="true"]:hover {
  border-color: var(--color-danger);
}

/* ---- Intake uploads --------------------------------------------------- */

/* The list of attached files under the upload control, and the running total
   under that. Both are written by app.js and neither exists without it: the
   markup serves them empty and hidden, so a visitor whose script never arrives
   is shown the file input on its own and nothing that does nothing.

   One column at every width, like the rest of the form, and the row itself
   wraps rather than carrying a breakpoint: a long filename at 360px pushes the
   size, the bar and the remove control onto the next line instead of pushing
   the column past the gutter.

   THE ROWS ARE ON THE CONTROLS' OWN STEP. A row is written in directly under the
   file input it was chosen with, so it takes --color-paper-raised-2 as that input
   does: the two read as one thing on the panel rather than as a control and a
   list beside it. The hairline round each row is the enclosing kind, the same
   --color-line the panel and the cards on the home page are drawn with.

   Nothing in this section rings anything. The remove control is a link in every
   way but element and takes the site's own ring, which is now the same 1px lit
   brass held 0.25rem off that the fields above it wear — the mockup puts that
   outline on every anchor it draws, this control included, so there is nothing
   left here for a section rule to say (WCAG 2.1 AA 2.4.7). The ring is 9.6:1
   on the row it is drawn on. */

/* THE BROWSER'S OWN LIST BOX IS TAKEN OFF, and this is what the responsive pass
   found missing here. A <ul> arrives with `padding-inline-start: 40px` and
   `margin-block: 1em`, and this rule dropped the bullets without dropping
   either: every attachment row started 40px inside the line the file input, the
   hint and the refusal message under it all stand on, and was 40px narrower
   than the form panel it sits in. At 1440 that reads as a list indented for no
   reason; at 360 the panel has 262px between its own padding, so the rows were
   laid out in 222 and the filename column — the one thing in a row that gives —
   lost a sixth of itself for nothing. The trailing 1em is the same omission at
   the other end: it put 16px between the last row and the running total where
   the field's own 8px gap is what holds them apart.

   `padding: 0` and not `padding-inline-start: 0`, and the margin written as a
   pair rather than a single edge, because both of those are what every other
   list in this file says — see .site-nav__links, .site-nav__menu,
   .pipeline__rail, .quote-band__chips and .site-footer__links, all of which
   reset the whole box. */
.uploads {
  display: grid;
  gap: var(--space-2xs);
  margin-block: var(--space-2xs) 0;
  padding: 0;
  list-style: none;
}

/* One row: the name, its size, the bar, what is happening to it and the
   control that takes it away. The name is the flexible one, so everything else
   keeps its width and the name is what gives. */
.upload {
  display: flex;
  flex-wrap: wrap;
  gap: var(--space-2xs) var(--space-xs);
  align-items: center;
  border: 1px solid var(--color-line);
  border-radius: var(--radius-md);
  background-color: var(--color-paper-raised-2);
  padding: var(--space-2xs) var(--space-xs);
  font-size: var(--text-sm);
}

/* min-inline-size: 0 so a long unbroken filename shrinks rather than refusing
   to, and overflow-wrap so it breaks instead of running out of the row. */
.upload__name {
  flex: 1 1 12ch;
  min-inline-size: 0;
  overflow-wrap: anywhere;
  font-weight: var(--weight-medium);
}

/* The size and what is happening to the file. The second cream, which is 7.7:1
   on the row — the smallest type in the form, and where that margin over WCAG
   2.1 AA 1.4.3's 4.5:1 is worth having. The status is also the words the
   progress bar's fraction is said in, so it is held to a text ratio rather than
   to a mark's. */
.upload__size,
.upload__status {
  color: var(--color-ink-muted);
  font-size: var(--text-xs);
}

/* The bar. A <progress> is drawn by the browser from three different sets of
   properties depending on the engine, so the appearance is cleared first and
   the two pseudo-elements below paint it: the track for Firefox and the
   element itself for the WebKit and Blink pair. A row that is done or failed
   has nothing left to report, so the bar goes rather than sitting full.

   THE TRACK IS A SURFACE AND THE FILL IS THE BRASS, which is the pair the whole
   file is built from — the track was --color-line, a hairline token spent on an
   area, and that is the light page's answer to a bar drawn on white.

   --color-paper for the track, which is the darkest step in the file and so the
   one the brass reads strongest on: 7.2:1, against 6.0:1 had the track taken the
   panel step immediately under the row. That is the substitution worth naming —
   the ticket asked for a darker panel token, and --color-paper-raised is 1.1:1
   against the row that holds the bar where the page is 1.2:1, so neither draws a
   track on its own and the one that gives the fill more to work with wins.

   None of this is the only thing reporting the upload either way: .upload__status
   beside the bar says the same fraction in words, which is what carries it for
   anybody the bar is a grey line to. */
.upload__progress {
  flex: 0 1 8rem;
  block-size: var(--space-2xs);
  appearance: none;
  border: 0;
  border-radius: var(--radius-pill);
  background-color: var(--color-paper);
  color: var(--color-accent);
}

.upload__progress::-webkit-progress-bar {
  border-radius: var(--radius-pill);
  background-color: var(--color-paper);
}

.upload__progress::-webkit-progress-value {
  border-radius: var(--radius-pill);
  background-color: var(--color-accent);
}

.upload__progress::-moz-progress-bar {
  border-radius: var(--radius-pill);
  background-color: var(--color-accent);
}

.upload[data-state="done"] .upload__progress,
.upload[data-state="failed"] .upload__progress {
  display: none;
}

/* A failed row says so in the same colour a refused field does, and carries the
   same border: it is the one row in the list that needs doing something about.
   The refusal colour is 5.5:1 on the row, so the edge clears WCAG 2.1 AA
   1.4.11's 3:1 and the words in it clear 1.4.3's 4.5:1 from the one token. And
   the colour is not the whole of what says so — the status beside the name is
   the sentence the server refused the file with. */
.upload[data-state="failed"] {
  border-color: var(--color-danger);
}

.upload[data-state="failed"] .upload__status {
  color: var(--color-danger);
  font-weight: var(--weight-medium);
}

/* The remove control is a real button, so it inherits neither the page's
   typeface nor a pointer cursor. It is drawn as a link rather than as a button
   — it is the smallest action on the page and a filled one per row would read
   as five calls to action under the form. The brass is 6.0:1 on the row and the
   lit brass it takes under the pointer is 9.6:1, so both ends of it clear WCAG
   2.1 AA 1.4.3 at this size. The focus ring is the site's. */
.upload__remove {
  margin-inline-start: auto;
  border: 0;
  background: none;
  padding: 0;
  color: var(--color-accent);
  cursor: pointer;
  font-family: inherit;
  font-size: var(--text-xs);
  font-weight: var(--weight-medium);
  text-decoration: underline;
}

.upload__remove:hover {
  color: var(--color-accent-hover);
}

/* The running total under the list. Muted, because it is a figure to glance at
   rather than an instruction — and it is outside the rows, so it is read against
   the form panel rather than against a row: 8.4:1. */
.uploads__total {
  color: var(--color-ink-muted);
  font-size: var(--text-xs);
}

/* The submit button while a file is still going up. It comes back on its own
   the moment the last one lands, so this says "not yet" rather than "no".

   The face is .button:disabled's — a panel step with the muted cream on it.
   The 0.6 opacity that used to be here instead faded the whole control against
   the page and took its text to 3.2:1 with it, which is the one thing a "not
   yet" must not do. What is left here is the pointer, which no anchor needs
   and so is not the shared button's to say. */
.intake-form__submit:disabled {
  cursor: default;
}

/* ---- Motion ----------------------------------------------------------- */

@media (prefers-reduced-motion: reduce) {
  html {
    scroll-behavior: auto;
  }

  *,
  *::before,
  *::after {
    animation-duration: 0.01ms !important;
    animation-iteration-count: 1 !important;
    transition-duration: 0.01ms !important;
    scroll-behavior: auto !important;
  }
}
