/* The story under the street on a laptop, "la plongée" (src/app/street/story.ts, dive.ts, stage.ts;
   docs/decisions/2026-11-19-app-bar-home-list.md, and its first form, the prototype of 18 November:
   docs/decisions/2026-11-18-laptop-mix.md).

   Named by the street's page for laptops only (`media`: LAPTOP in src/app/ui/laptop.ts, said again below): a phone
   fetches it last and never waits for it, and its street is the first screen alone. Built on public/app/app.css,
   public/app/street.css and src/app/DESIGN.md: it adds no token and writes no colour.

   The street is the first screen, whole; the page scrolls on. The car in the middle and its name lift out of the street
   onto a stage kept in view on the left, at one scale for every car; its answers come on the right, one chapter at a
   time, each with its picture on the stage. Nothing is dragged, nothing floats over what is read, nothing scrolls inside
   another thing. The room of the story is there from the first paint (`data-story`, set before it by the page's first
   line), as tall as once it is filled; without scripts there is none.

   The lift is tied to the scroll where the browser can (scroll-driven animations): dive.ts measures the way (`--pl-*`)
   and the animations below run it. Elsewhere, and under prefers-reduced-motion, nothing moves: the street scrolls away
   and the stage scrolls into place, never half way.

   The address says where the reader is (app.ts, "The story's address"): the room is `#recit`, each chapter its answer's
   own anchor (`#par-mois`…). Brought to one of them, the page stands as the way down leaves it: the room under the top
   bar, a chapter in the middle of what the bar leaves of the screen (`scroll-margin-top`, the same place the index's
   questions lead to). */

/* How far the first screen holds while it lets go (below): a length the script reads as the stylesheet says it. */
@property --pl-hold { syntax: "<length>"; inherits: true; initial-value: 0px; }
/* Where the car and its name set off within it (below). */
@property --pl-go { syntax: "<length>"; inherits: true; initial-value: 0px; }

@media (min-width: 1024px) and (min-height: 540px) and (hover: hover) and (pointer: fine) {
  /* The way in under the car is the way down into the story ("Tout savoir sur …"), the same link. */
  :root[data-story] .st-go > :is(.st-go-in, .ic:nth-last-child(2)) { display: none; }
  :root[data-story] .st-go > :is(.st-go-dive, .ic:last-child) { display: block; }

  /* The room: the stage on the left, the chapters on the right. */
  :root[data-story] .pl {
    /* The head of the car takes most of a screen beside the stage it lands on; each answer under it takes less than
       half of one, so that the answer being read and the next one are in view together: calm, not empty (the owner:
       "too much white space… we aint having an art gallery website"). */
    --ch-head: max(62svh, 420px);
    --ch: max(44svh, 340px);
    display: grid; grid-template-columns: minmax(0, 1.08fr) minmax(0, 0.92fr); align-items: start;
    column-gap: clamp(40px, 5.5vw, 112px); max-width: 1600px; margin: 0 auto; padding: 0 clamp(32px, 4.5vw, 88px);
    overflow-anchor: none; scroll-margin-top: -12px;
  }
  /* A chapter in place: in the middle of what the top bar leaves of the screen. Its marks stand where the chapters will
     be while the answers are on their way (story.ts): an address that names one lands there from the first paint. (The
     page keeps the bar and 12 px of air above what it brings into view, app.css `scroll-padding`: the room itself comes
     right under the bar, 12 px higher.) */
  .pl :is(.answer.is-compact, .pl-mark) { scroll-margin-top: calc((100svh - var(--bar-h) - var(--ch)) / 2 - 12px); }
  .pl :is(#st-depth, .dp-answers) { position: relative; }
  .pl-mark { position: absolute; left: 0; top: calc(var(--ch) * var(--k)); width: 1px; height: var(--ch); visibility: hidden; pointer-events: none; }

  /* ── The stage, kept in view ── */
  /* As tall as what it holds: the car and the picture of the chapter being read. */
  .pl-stage {
    grid-column: 1; grid-row: 1; position: sticky; top: var(--bar-h); z-index: 2;
    display: grid; grid-template-columns: minmax(0, 1fr); grid-template-rows: auto auto; pointer-events: none; container-type: inline-size;
  }
  .pl-stage:empty { display: block; }

  /* The cars on each side, one step away: the street's slim memory at the top of the stage. */
  .mx-mini { display: flex; justify-content: space-between; align-items: center; gap: 16px; height: 72px; border-bottom: 1.5px solid var(--line); pointer-events: auto; }
  /* It sticks right under the bar, within the air the page keeps under it: the keyboard coming to it leaves the page
     where it is (app.css says why, of the bar). */
  .mx-near { display: flex; align-items: center; gap: 12px; min-width: 0; max-width: calc(50% - 8px); height: 58px; padding: 0 12px 0 0; border-radius: var(--r-m); color: var(--ink); text-decoration: none; scroll-margin-top: -12px; }
  .mx-near.is-next { flex-direction: row-reverse; padding: 0 0 0 12px; text-align: right; }
  .mx-arrow { flex: none; display: grid; place-items: center; width: 40px; height: 40px; border-radius: 50%; background: var(--card); box-shadow: 0 0 0 1.5px var(--line), var(--lift-1); transition: box-shadow var(--quick); }
  .mx-arrow .ic { width: 20px; height: 20px; }
  .mx-pic { --mm: 0.0165px; flex: none; display: grid; place-items: end center; width: 84px; }
  .mx-words { display: grid; gap: 2px; min-width: 0; font: 500 0.75rem/1.25 var(--body); color: var(--soft); }
  .mx-near.is-next .mx-words { justify-items: end; }
  .mx-words b { max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font: 700 0.9375rem/1.2 var(--display); letter-spacing: -0.008em; color: var(--ink); }
  .mx-words .st-vs { display: grid; max-width: 100%; }
  .mx-words .gaps { max-height: 26px; overflow: hidden; }
  .mx-near.is-next .mx-words .gaps { justify-content: flex-end; }
  .mx-near.is-end { height: auto; padding: 0; font: 500 0.75rem/1.25 var(--body); color: var(--soft); }
  .mx-near:hover .mx-arrow { box-shadow: 0 0 0 1.5px var(--ink), var(--lift-1); }
  .mx-near:hover b { text-decoration: underline; }

  /* The car's make and name, as large as the stage takes, and the car under them. */
  .pl-view { display: grid; grid-template-rows: auto auto; align-content: start; min-height: 0; padding-top: clamp(18px, 5svh, 56px); }
  .pl-who { padding-bottom: clamp(12px, 3svh, 32px); }
  .pl-make { display: flex; flex-wrap: wrap; align-items: baseline; gap: 3px 12px; margin-bottom: 8px; }
  .pl-make > * { white-space: nowrap; }
  .pl-name {
    --w: 3; margin-left: -0.03em; white-space: nowrap; color: var(--ink);
    font: 800 60px/0.88 var(--names); letter-spacing: -0.038em;
    font-size: clamp(40px, min(calc(100cqw / var(--w)), 13svh), 132px);
  }
  .pl-name span { display: inline-block; transform-origin: 0 0; }

  /* One scale for every car on the stage: 5,60 m across its width (a longer car or pair sets its own), never taller
     than a little under a quarter of the screen. The car held stands at the same scale, backs on one line. */
  .pl-lanes {
    --stage-mm: min(calc(100cqw / max(5600, var(--longest, 4500))), calc((100svh - var(--bar-h)) * 0.23 / 1950));
    --mm: var(--stage-mm);
    display: grid; grid-template-rows: auto minmax(0, 1fr); min-height: 0;
  }
  .pl-lane { position: relative; height: calc(1950 * var(--mm)); border-bottom: 1.5px solid var(--edge); }
  .pl-car { position: absolute; left: 0; bottom: 0; width: calc(var(--L) * var(--mm)); transform-origin: 0 0; }
  .pl-car .carfig { display: block; }
  /* The light the car stands in on the stage: it travels with it. */
  .pl-car::before { content: ""; position: absolute; z-index: -1; left: -6%; right: -10%; bottom: 0; height: 52%; background: radial-gradient(50% 100% at 50% 100%, color-mix(in srgb, var(--card) 88%, transparent), transparent 100%); pointer-events: none; }
  .pl-car .carfig.is-nothing { display: grid; place-items: center; width: calc(4300 * var(--mm)); height: calc(1400 * var(--mm)); border: 1.5px dashed var(--edge); border-radius: 16px 22px 6px 6px; }
  .pl-says { position: absolute; inset: 0; pointer-events: none; }
  /* The car held, "this one": the stroke of road paint under its wheels, as in the street. */
  .pl-lane.is-held .pl-car::after { content: ""; position: absolute; z-index: 1; left: 8%; right: 8%; top: calc(100% + 6px); height: 6px; border-radius: 2px; background: var(--paint); box-shadow: 0 0 0 1.5px var(--paint-edge); transform: skewX(-20deg); }
  .pl-nose { position: absolute; top: 8px; bottom: 0; left: calc(var(--at) * var(--mm)); width: 0; border-left: 1.5px dashed var(--ink); opacity: 0; transition: opacity var(--calm) var(--ease); }
  .pl-tag { position: absolute; left: 0; top: calc(100% + 12px); display: none; align-items: center; gap: 7px; white-space: nowrap; font: 500 0.8125rem/1.2 var(--body); color: var(--soft); }
  .pl-tag b { font: 700 0.9375rem/1.2 var(--display); letter-spacing: -0.008em; color: var(--ink); }
  .pl-lane.is-held .pl-tag { top: calc(100% + 20px); }
  /* At the end of the story: the car held on its lane beside the car, backs on one line, the mark at the shorter nose. */
  .pl-stage.has-pair[data-at="end"] .pl-tag { display: flex; }
  .pl-stage.has-pair[data-at="end"] .pl-nose { opacity: 0.55; }
  /* Or the car alone: its length under it, as a dimension line. */
  .pl-len { position: absolute; left: 0; top: calc(100% + 14px); display: none; width: calc(var(--at) * var(--mm)); height: 9px; border: solid var(--edge); border-width: 0 1.5px; }
  .pl-len::before { content: ""; position: absolute; left: 0; right: 0; top: 50%; border-top: 1.5px solid var(--edge); }
  .pl-len i { position: absolute; left: 50%; top: 50%; translate: -50% -50%; padding: 0 8px; background: var(--paper); font: 600 0.78125rem/1 var(--label); font-style: normal; color: var(--soft); white-space: nowrap; font-variant-numeric: tabular-nums; }
  .pl-stage:not(.has-pair)[data-at="end"] .pl-len { display: block; }

  /* Under the car, what the chapter on the right is about: one layer at a time. Only the layer on show is laid out
     (another car's pictures cost the change only that one), and only it takes room: the stage is as tall as what it
     shows, so that the end of the story never pushes it up under the top bar. The one that gives way fades out where
     it stood (`is-leaving`, dive.ts) while the next comes in. */
  .pl-shows { position: relative; display: grid; min-height: 0; margin-top: clamp(28px, 5svh, 48px); container-type: inline-size; }
  .pl-pics, .pl-pics > .answers { display: contents; }
  :is(.pl-show, .a-pics-one) {
    grid-area: 1 / 1; align-self: start; min-width: 0; display: none; opacity: 0; translate: 0 14px;
    transition: opacity var(--calm) var(--ease), translate var(--settle) var(--ease);
  }
  :is(.pl-show, .a-pics-one).is-leaving { display: block; position: absolute; inset: 0 0 auto; }
  :is(.pl-show, .a-pics-one).is-on { display: block; opacity: 1; translate: none; transition-delay: 80ms; }
  @starting-style {
    :is(.pl-show, .a-pics-one).is-on { opacity: 0; translate: 0 14px; }
  }
  .pl-stage.is-waiting .a-pics-one.is-on { opacity: 0.3; }
  .pl-show[data-show="end"] .pl-lane { margin-bottom: 44px; }

  /* The car turns once it has landed (turn.ts): its 3D stage over the flat car, at its place and its scale, in a box
     with the air the viewer keeps around a car; what falls past the column or under the ground is not drawn. The 3D
     fades in over the flat car (public/stage.css), which then gives way under it, and is back at once when the 3D
     goes. How to turn it is said under the car, between its ground and the picture of the chapter. */
  .pl-stage .pl-turn { position: absolute; z-index: 1; max-width: none; margin: 0; display: block; pointer-events: none; }
  .pl-stage .pl-turn .stage-view { width: 100%; height: 100%; aspect-ratio: auto; border: 0; background: none; overflow: visible; content-visibility: visible; }
  .pl-stage .pl-turn canvas {
    clip-path: inset(var(--clip)); pointer-events: auto;
    mask-image: linear-gradient(var(--ink) calc(var(--ground) + 2px), transparent calc(var(--ground) + 18px)), linear-gradient(to left, transparent var(--right), var(--ink) calc(var(--right) + 24px));
    mask-composite: intersect;
  }
  .pl-stage .pl-turn .stage-poster { opacity: 0; }
  .pl-stage .pl-turn .stage-hint { top: calc(var(--ground) + 8px); bottom: auto; }
  .pl-stage.is-turning .pl-lane.is-car > .pl-car .carfig { opacity: 0; }

  /* Each answer's own picture, drawn larger: the plan, the addition, the place, the sheet, the steps. */
  /* One measure for every picture under the car: the plan, the addition, the sheet, the steps take 34 rem; the place
     seen from above stands at the stage's own scale (five metres: about as wide), a pair of places within the same. */
  .pl-stage .a-pic { margin: 0; }
  .pl-stage .a-pic > :not(.a-park) { max-width: 34rem; }
  .pl-stage .a-plan { padding: 20px 22px 18px; border-radius: var(--r-l); }
  .pl-stage .a-plan-stop small { font-size: 0.78125rem; }
  .pl-stage .a-plan-stop b { font: 750 1.375rem/1.1 var(--display); letter-spacing: -0.017em; }
  .pl-stage .a-plan-road i { font-size: 0.84375rem; }
  .pl-stage .a-bill li { padding: 12px 0; font-size: 1.0625rem; }
  .pl-stage .a-bill li b { font-size: 1.0625rem; }
  .pl-stage .a-bill li:first-child b { font: 750 1.25rem/1.2 var(--display); }
  /* The place seen from above, at the stage's own scale and under the car: elevation over plan, backs aligned. */
  .pl-stage .a-park { padding: 0; background: none; border-radius: 0; gap: 12px; overflow: visible; }
  .pl-stage .a-park:not(.is-pair) { --mm: var(--stage-mm); }
  .pl-stage .a-park:not(.is-pair) .a-side { display: none; }
  .pl-stage .a-park.is-pair { --mm: calc((min(100cqw, 34rem) - 48px) / 10800); grid-template-columns: auto auto; column-gap: calc(800 * var(--mm)); }
  .pl-stage .a-park.is-pair .a-park-note { grid-column: 1 / -1; }
  .pl-stage .a-park-note { font-size: 0.78125rem; }
  .pl-stage .a-pill { padding: 8px 14px; font-size: 0.9375rem; }
  .pl-stage .a-pill.is-off { padding: 6.5px 12.5px; }
  .pl-stage .a-cluster-h { font-size: 0.875rem; }
  /* The steps around this version: the one above, this one, the one below; the others are on the car's page. The
     version on the stage is marked in ink: yellow stays the car held's. */
  .pl-stage :is(.a-engine-more, .a-rise > p, .a-step-card .ic, .a-step-here) { display: none; }
  .pl-stage .a-rise > summary::after { content: none; }
  .pl-stage .a-step.is-here .a-step-card { box-shadow: inset 0 -4px 0 var(--ink); }
  .pl-stage .a-steps > .a-step { display: none; }
  .pl-stage .a-steps > :is(.a-step.is-here, .a-step:has(+ .a-step.is-here), .a-step.is-here + .a-step) { display: block; }
  .pl-stage .a-step-name { font-size: 1.125rem; }

  /* The five questions as a quiet index in the right gutter, once the car has landed (dive.ts): the one being read in
     ink, the others soft, each its chapter's way; its question beside it on hover and focus. Never over what is
     read, and not yellow: yellow is the car held. */
  .pl-index {
    grid-column: 2; grid-row: 1; justify-self: end; align-self: start; position: sticky; top: calc(50svh - 80px); z-index: 1;
    display: grid; gap: 2px; margin-right: calc(-1 * clamp(32px, 4.5vw, 88px) + 4px);
    opacity: 0; visibility: hidden; transition: opacity var(--calm) var(--ease), visibility 0s var(--calm);
  }
  .st[data-deep] .pl-index { opacity: 1; visibility: visible; transition: opacity var(--calm) var(--ease); }
  .pl-index a { position: relative; display: grid; place-items: center; width: 32px; height: 32px; border-radius: var(--r-m); color: var(--soft); text-decoration: none; font: 600 0.71875rem/1 var(--label); letter-spacing: 0.06em; transition: color var(--quick); font-variant-numeric: tabular-nums; }
  .pl-index a[aria-current] { color: var(--ink); }
  .pl-index a[aria-current]::after { content: ""; position: absolute; right: 0; top: 9px; bottom: 9px; width: 2px; border-radius: 1px; background: var(--ink); }
  .pl-index-q {
    position: absolute; right: calc(100% + 6px); top: 50%; translate: 0 -50%; padding: 7px 12px; border-radius: var(--r-m);
    background: var(--card); box-shadow: var(--lift-1); color: var(--ink); white-space: nowrap;
    font: 500 0.8125rem/1.2 var(--voice); letter-spacing: -0.01em; opacity: 0; pointer-events: none; transition: opacity var(--quick);
  }
  .pl-index a:is(:hover, :focus-visible) { color: var(--ink); }
  .pl-index a:is(:hover, :focus-visible):not(.is-taken) .pl-index-q { opacity: 1; }
  .pl .answer-q:focus { outline: none; }

  /* ── The chapters, on the right: one at a time, with air ── */
  .pl-chapters { grid-column: 2; grid-row: 1; padding-bottom: 22svh; }
  /* What passes under the top bar on the right dissolves: a short gradient of paper under the bar, over the chapters'
     column only, never over the stage. It comes once the car has landed, and goes at once when it leaves: on its way
     a long name passes over the top of this column, and nothing lies over a name that travels. */
  .pl-chapters::before { content: ""; position: sticky; z-index: 2; top: var(--bar-h); display: block; height: 44px; margin-bottom: -44px; background: linear-gradient(var(--paper), transparent); opacity: 0; pointer-events: none; }
  .st[data-deep] .pl-chapters::before { opacity: 1; transition: opacity var(--calm) var(--ease); }
  /* The first: the car itself, what it costs, and against the car held what changes, as signed chips: they are the
     statement; the sentence that says them again is a screen reader's (the chips are hidden from it). */
  /* Its words a little under the middle of their room: rising on the right while the car's name travels, they pass
     under its last letters, never into them, whatever the length of the name and the pace of the way. */
  .pl-chapters > .st-peek { min-height: var(--ch-head); display: flex; flex-direction: column; justify-content: center; padding-top: 36px; }
  .pl .pk { display: flex; flex-direction: column; align-items: flex-start; }
  .pl .pk-name { font: 600 0.78125rem/1.3 var(--label); letter-spacing: 0.06em; text-transform: uppercase; color: var(--soft); text-wrap: balance; font-variant-numeric: tabular-nums; }
  /* The label is where the way down leaves the keyboard (dive.ts, dock.ts), not a control: it wears no ring. The car's
     name inside it is a link, and wears one when the keyboard comes to it. */
  .pl .pk-name:focus { outline: none; }
  /* The car's name leads to its page: a small label, with a finger's room above and below it. */
  .pl .pk-go { padding-block: 4px; color: inherit; text-decoration: none; }
  .pl .pk-go:hover { color: var(--ink); text-decoration: underline; text-underline-offset: 4px; }
  .pl .pk-price { display: flex; flex-wrap: wrap; align-items: baseline; gap: 4px 14px; margin-top: 14px; }
  .pl .pk-price .price b { font: 800 clamp(2.5rem, 4.4vw, 3.5rem)/1 var(--display); letter-spacing: -0.034em; }
  .pl .pk-price .price small { font-size: 0.9375rem; }
  .pl .pk-list { font: 500 0.84375rem/1.2 var(--label); color: var(--soft); font-variant-numeric: tabular-nums; }
  .pl .pk-facts { margin-top: 18px; font: 500 1rem/1.45 var(--body); color: var(--ink); }
  .pl .pk-more { margin-top: 6px; max-width: 34em; font-size: 0.875rem; line-height: 1.45; color: var(--soft); }
  .pl .pk-more s { font: 500 0.78125rem/1 var(--label); font-variant-numeric: tabular-nums; }
  .pl .pk-voice { position: absolute; width: 1px; height: 1px; margin: -1px; overflow: hidden; clip-path: inset(50%); white-space: nowrap; }
  .pl .pk-gaps { order: 4; margin-top: 22px; }
  .pl .pk-gaps .gap { min-height: 32px; padding: 3px 13px; font-size: 0.9375rem; }
  .pl .pk.is-speaking .pk-facts { order: 2; margin-top: 14px; color: var(--soft); }
  .pl .pk-acts { order: 5; display: flex; flex-wrap: wrap; gap: 8px; margin-top: 30px; }
  .pl .pk-acts .btn { min-height: 52px; padding: 8px 20px; white-space: nowrap; }
  .pl .pk-acts .btn-paint:not(.pk-pin), .pl .pk-face { min-width: 230px; }
  .pl .pk-pin { width: 52px; padding: 0; border-radius: 50%; }
  .pl .pk-acts [data-keep][aria-pressed="true"] .ic { --ic-in: var(--paint); color: var(--ink); }
  .pl .pk-acts .btn-line[aria-pressed="true"] { background: none; color: var(--ink); border-color: var(--ink); box-shadow: inset 0 0 0 1px var(--ink); }

  /* Then each answer: its number, its question in the voice, its figure, then what that figure is made of, as figures:
     the card's own facts row (app.css `.facts`), at the chapter's scale. What the picture under the car says again
     steps aside (`is-again`: the plan of a loan, the addition of what it takes to drive away; and the steps of the
     versions, which name the ones around and their prices): the chapter keeps its figure and what the picture does
     not carry. The card's sentence is a screen reader's, as on a phone's card. A sentence stays in view only where it
     says what no figure says (a verdict, a missing fact, a car's one aside): short, every figure in it set apart in the
     display face, bold (app.ts, `figuresApart`). Against a car held, what changes, as signed chips. */
  .pl .dp { display: block; }
  .pl .dp-aside { max-width: 34em; margin: 0 0 8svh; font-size: 1.0625rem; }
  .pl .dp-answers, .pl .dp-answers > .answers { display: block; counter-reset: pl-chapter; }
  .pl .answer.is-compact {
    min-height: var(--ch); display: flex; flex-direction: column; justify-content: center; align-items: flex-start;
    padding: 0; border-radius: 0; background: none; box-shadow: none; counter-increment: pl-chapter;
  }
  .pl .answer.is-compact::before { content: counter(pl-chapter, decimal-leading-zero); margin-bottom: 16px; font: 600 0.78125rem/1 var(--label); letter-spacing: 0.06em; color: var(--soft); font-variant-numeric: tabular-nums; }
  .pl .answer.is-compact .answer-q { font: 500 clamp(1.375rem, 2.04vw, 1.8125rem)/1.1 var(--voice); color: var(--soft); letter-spacing: -0.01em; }
  .pl .answer.is-compact .a-figline { margin-top: 16px; }
  .pl .answer.is-compact .answer-fig { margin: 0; font: 800 clamp(3rem, 5.4vw, 4.75rem)/0.95 var(--display); letter-spacing: -0.038em; }
  .pl .answer.is-compact .answer-fig small { font: 600 1rem/1.2 var(--body); letter-spacing: 0; color: var(--soft); }
  .pl .answer.is-compact .answer-fig :is(.a-fig-words, .a-fig-end) { font-size: inherit; }
  .pl .answer.is-compact .answer-fig.is-unknown { font-size: clamp(2rem, 3.4vw, 2.75rem); }
  .pl .answer.is-compact .a-facts { width: min(100%, 30rem); margin-top: 24px; }
  .pl .answer.is-compact .fact { padding: 10px 14px 12px 12px; }
  .pl .answer.is-compact .fact-l { font-size: 0.8125rem; }
  .pl .answer.is-compact .fact-f { font-size: clamp(1.25rem, 1.75vw, 1.625rem); }
  .pl .answer.is-compact .fact-f small { font-size: 0.875rem; }
  .pl .answer.is-compact .fact.is-again, .pl .answer.is-compact[data-answer="versions"] .a-facts { display: none; }
  .pl .answer.is-compact .a-facts:not(:has(.fact:not(.is-again))) { display: none; }
  .pl .answer.is-compact .a-line { max-width: 28.5em; margin-top: 20px; font: 400 clamp(1.0625rem, 1.51vw, 1.25rem)/1.25 var(--voice); color: var(--ink); text-wrap: pretty; letter-spacing: -0.005em; }
  .pl :is(.answer.is-compact .a-line, .dp-aside) b { font: 800 1em/1 var(--display); letter-spacing: -0.017em; font-variant-numeric: tabular-nums; }
  .pl .answer.is-compact [data-slot="face"] { margin-top: 22px; }
  .pl .answer.is-compact [data-slot="face"] .gap { min-height: 30px; padding: 3px 12px; font-size: 0.875rem; }
  .pl .answer.is-compact .whence { margin-top: 12px; }

  /* Then the way on: the car's own page, its versions side by side, and where what was said comes from. */
  .pl .dp-acts { display: flex; flex-direction: column; align-items: flex-start; gap: 12px; padding-top: 14svh; }
  .pl .dp-acts .btn { min-height: 56px; padding: 10px 26px; font-size: 1rem; }
  .pl .dp > .whence { max-width: 36em; margin-top: 20px; }

  /* The answers on their way: a quiet skeleton, as tall as what comes, its bars where the first chapter will be. In
     the room as the page came, it stands for the answers and the way on; for another car, for the answers alone. */
  .pl .st-wait { display: grid; align-content: center; gap: 16px; }
  .pl #st-depth > .st-wait { min-height: calc(var(--ch) * 5 + 14svh + 188px); padding-bottom: calc(var(--ch) * 4 + 14svh + 188px); }
  .pl .dp-answers > .st-wait { min-height: calc(var(--ch) * 5); padding-bottom: calc(var(--ch) * 4); }
  /* The answers could not be fetched: said where the first of them would stand, with the way to ask again; the room
     keeps its height, and the stage its car. */
  .pl .dp-answers > .st-fail { display: grid; align-content: center; justify-items: start; gap: 20px; min-height: calc(var(--ch) * 5); padding-bottom: calc(var(--ch) * 4); }
  .pl .st-fail p { max-width: 31em; font: 400 clamp(1.125rem, 1.68vw, 1.5rem)/1.24 var(--voice); text-wrap: pretty; letter-spacing: -0.005em; }
  .pl .st-fail b { font-weight: inherit; }
  .pl .st-fail .btn { min-height: 48px; padding: 8px 22px; }
  .pl .st-wait i { display: block; height: 14px; border-radius: 7px; background: color-mix(in srgb, var(--ink) 8%, transparent); }
  .pl .st-wait i:nth-of-type(1) { width: 32%; }
  .pl .st-wait i:nth-of-type(2) { width: 64%; height: 44px; border-radius: 10px; }
  .pl .st-wait i:nth-of-type(3) { width: 78%; }
}

/* The story moves where the browser can tie a movement to the scroll, and the visitor has not asked for stillness.
   Read step by step (dive.ts, the default), the page plays the way down by itself, in a second and a half, as one
   film: the street holds a moment where it is, under the top bar (`pl-pin`: the page scrolls on, the screen is held
   back by as much), over the hold (`--pl-hold`, 0.15 of a screen); its words fade where they stand before the car
   sets off, and the cars on each side give way sideways, whole, through the street's soft edges, over all of it. At
   0.6 of it (`--pl-go`), the cars on each side still leaving, the car and its name set off and travel to the stage,
   keeping their height on the screen, alone on clean paper, over one screen, while the first chapter rises on the
   right and the stage arrives under them (dive.ts measures the way, `--pl-*`). Back up, the same in reverse. Read
   freely (`?defile=libre`), the hand scrubs the same film: the hold is then 0.45 of a screen and the car sets off at
   its end, for a hand needs the time. Elsewhere the story is plain sections: the stage simply scrolls into place.
   The story's pace (`--pl-pace`, `?allure=`) is a time: it no longer changes any distance here. */
@supports (animation-timeline: scroll()) {
  @media (min-width: 1024px) and (min-height: 540px) and (hover: hover) and (pointer: fine) and (prefers-reduced-motion: no-preference) {
    /* Step by step the scroll is the page's, eased in and out: what is tied to it linearly is eased with it. Read
       freely, the cars on each side ease out themselves (`--pl-part`). */
    :root[data-story] .st { --pl-hold: calc((100svh - var(--bar-h)) * 0.15); --pl-go: calc(var(--pl-hold) * 0.6); --pl-part: linear; }
    :root[data-story][data-defile="libre"] .st { --pl-hold: calc((100svh - var(--bar-h)) * 0.45); --pl-go: var(--pl-hold); --pl-part: cubic-bezier(0.5, 0, 0.9, 0.6); }
    /* The room comes after the runway of the hold, and after one screen of travel (the first screen is one). */
    :root[data-story] .pl { margin-top: var(--pl-hold); }
    /* The first screen holds under the bar while it lets go, then leaves with the page, nothing of it in sight: past the
       hold it is no longer drawn, nor reached by the pointer or the keyboard. Above the stage until then. */
    .st[data-lift] .st-first {
      z-index: 3; animation: pl-pin linear both, pl-gone step-end both; animation-timeline: scroll(root block), scroll(root block);
      animation-range: 0px var(--pl-hold), var(--pl-hold) calc(var(--pl-hold) + 1px);
    }
    /* The car and its name: the same way and the same pace, so that the name stays above the car all along. */
    .st[data-lift] .pl-lane.is-car > .pl-car { --pl-x: var(--pl-cx); --pl-y: var(--pl-cy); --pl-k: var(--pl-ck); }
    .st[data-lift] .pl-name > span { --pl-x: var(--pl-nx); --pl-y: var(--pl-ny); --pl-k: var(--pl-nk); }
    .st[data-lift] :is(.pl-lane.is-car > .pl-car, .pl-name > span) {
      animation: pl-lift linear both, pl-take step-end both; animation-timeline: scroll(root block), scroll(root block);
      animation-range: var(--pl-go) var(--pl-to, 1px), var(--pl-go) calc(var(--pl-go) + 1px);
    }
    /* Until they set off the street's own car and name stand still in their light, the cars on each side before the
       name's foot, as at rest. Then, the words gone and the cars on each side well on their way out, they hand over to
       the ones that travel, in one frame and where they stand (the two are measured to coincide): never the two at
       once, half drawn, nor anything of the first screen over the ones that travel. */
    .st[data-lift] :is(.st-slot.is-here .carfig, .st-name), .st[data-lift] .st-slot.is-here.is-held::after { animation: pl-give step-end both; animation-timeline: scroll(root block); animation-range: var(--pl-go) calc(var(--pl-go) + 1px); }
    /* The light of the car that travels comes after it has taken over, softly. */
    .st[data-lift] .pl-lane.is-car > .pl-car::before { animation: pl-appear linear both; animation-timeline: scroll(root block); animation-range: var(--pl-go) calc(var(--pl-go) + (var(--pl-to, 1px) - var(--pl-go)) * 0.15); }
    /* The words go where they stand, in the first half of the way to where the car sets off: the make, the price, the
       figures or the chips, the acts, the neighbours' names or arrows, and the light and the ground line under the
       cars. The road and the top row by three quarters of it. Whole layers, so that the scroll stays smooth. */
    .st[data-lift] :is(.st-nears, .st-road, .st-top, .st-make, .st-price, .st-info) { will-change: opacity; }
    .st[data-lift] :is(.st-make, .st-price, .st-info, .st-nears), .st[data-lift] .st-view::before, .st[data-lift] .st-view::after { animation: pl-fade linear both; animation-timeline: scroll(root block); animation-range: 0px calc(var(--pl-go) * 0.5); }
    .st[data-lift] :is(.st-road, .st-top) { animation: pl-fade linear both; animation-timeline: scroll(root block); animation-range: 0px calc(var(--pl-go) * 0.75); }
    /* The cars on each side give way sideways, whole, with their names: those before the car to the left, those after
       it to the right, faster and faster, over the whole hold. What is in the slot moves, not the slot: the street
       keeps its places. They leave through the street's own soft edges, opaque wherever the name stands. (Which side a
       car is on is said by the car in the middle's siblings that follow it, never by `:has()`: a step along the street
       then asks the page for no more than the cars after it.) */
    .st[data-lift] .st-slot:not(.is-here, .is-here ~ .st-slot) > * { animation: pl-part-start var(--pl-part) both; animation-timeline: scroll(root block); animation-range: 0px var(--pl-hold); }
    .st[data-lift] .st-slot.is-here ~ .st-slot > * { animation: pl-part-end var(--pl-part) both; animation-timeline: scroll(root block); animation-range: 0px var(--pl-hold); }
    /* A neighbour's name keeps its own way in when the street steps (street.css, `st-cap-in`): it waits until the car
       has moved away from the price. */
    .st[data-lift] .st-slot.is-near:not(.is-here ~ .st-slot) > .st-cap {
      animation: pl-part-start var(--pl-part) both, st-cap-in 0.18s ease-out 0.16s both;
      animation-timeline: scroll(root block), auto; animation-range: 0px var(--pl-hold), normal;
    }
    .st[data-lift] .st-slot.is-here ~ .st-slot.is-near > .st-cap {
      animation: pl-part-end var(--pl-part) both, st-cap-in 0.18s ease-out 0.16s both;
      animation-timeline: scroll(root block), auto; animation-range: 0px var(--pl-hold), normal;
    }
    /* The stroke of road paint under a car held goes with it (it is drawn by the slot, skewed: it moves by `translate`). */
    .st[data-lift] .st-slot.is-held:not(.is-here, .is-here ~ .st-slot)::after { animation: pl-paint-start var(--pl-part) both; animation-timeline: scroll(root block); animation-range: 0px var(--pl-hold); }
    .st[data-lift] .st-slot.is-here ~ .st-slot.is-held::after { animation: pl-paint-end var(--pl-part) both; animation-timeline: scroll(root block); animation-range: 0px var(--pl-hold); }
    /* What the stage says around the car comes once its place is free. The car and its name keep their height on the
       screen while the stage rises under them, and are in their place at 97 % of their travel; the stage then rises
       with them the last few steps. What rides at the stage's top passes behind where they stand, and comes only once
       they are below it: the picture under the car in the last sixth of the travel, the mini-street in the last
       twentieth, the make once the name stands under it. */
    .st[data-lift] .pl-stage :is(.pl-says, .pl-shows) { animation: pl-appear linear both; animation-timeline: scroll(root block); animation-range: calc(var(--pl-go) + (var(--pl-to, 1px) - var(--pl-go)) * 0.82) var(--pl-to, 1px); }
    .st[data-lift] .pl-stage .mx-mini { animation: pl-appear linear both; animation-timeline: scroll(root block); animation-range: calc(var(--pl-go) + (var(--pl-to, 1px) - var(--pl-go)) * 0.945) var(--pl-to, 1px); }
    .st[data-lift] .pl-stage .pl-make { animation: pl-appear linear both; animation-timeline: scroll(root block); animation-range: calc(var(--pl-go) + (var(--pl-to, 1px) - var(--pl-go)) * 0.97) var(--pl-to, 1px); }
    /* Until the car has landed, the mini-street is on its way in: what cannot be seen yet cannot be clicked. */
    .st[data-lift]:not([data-deep]) .mx-mini { pointer-events: none; }
    /* Each chapter rises into place as its words come into view (a chapter keeps room around its words). */
    .pl :is(.pk, .dp-aside) { animation: pl-rise linear both; animation-timeline: view(); animation-range: entry 0% entry 100%; }
    .pl :is(.answer.is-compact, .dp-acts) { animation: pl-rise linear both; animation-timeline: view(); animation-range: entry 22% entry 78%; }
    /* What the keyboard is on is in full view, wherever the scroll stands: the mini-street before the stage has
       landed, a chapter as it rises. */
    .st[data-lift] .pl-stage .mx-mini:focus-within, .pl :is(.pk, .dp-aside, .answer.is-compact, .dp-acts):focus-within { animation: none; }
  }
}
/* The first screen held back by as much as the page scrolls, over the hold: it stays where it is. */
@keyframes pl-pin { to { transform: translateY(var(--pl-hold)); } }
@keyframes pl-gone { from { visibility: visible; } to { visibility: hidden; } }
/* From where they set off (`--pl-go`), the car and its name travel in a straight line to the stage at the pace of the
   scroll, keeping their height on the screen, in their place at 97 % of their travel. They start where the street's
   stand: the stage has risen by as much meanwhile, and the street, held, has not. */
@keyframes pl-lift {
  from { transform: translate(var(--pl-x, 0px), calc(var(--pl-y, 0px) + var(--pl-go))) scale(var(--pl-k, 1)); }
  97%, to { transform: none; }
}
/* The handover, as they set off: the travelling copies are taken up, the street's own are given away, and no longer
   met by a pointer over the ones that travel (the first screen they stand in is still there until the hold ends). */
@keyframes pl-take { from { opacity: 0; } to { opacity: 1; } }
@keyframes pl-give { from { opacity: 1; } to { opacity: 0; visibility: hidden; } }
/* What has faded half way stops taking the pointer: a click never lands on something no longer seen (the keyboard
   still reaches it, and the page scrolls back to it). */
@keyframes pl-fade { to { opacity: 0; pointer-events: none; } }
@keyframes pl-part-start { to { transform: translateX(-52vw); pointer-events: none; } }
@keyframes pl-part-end { to { transform: translateX(52vw); pointer-events: none; } }
@keyframes pl-paint-start { to { translate: -52vw 0; } }
@keyframes pl-paint-end { to { translate: 52vw 0; } }
@keyframes pl-appear { from { opacity: 0; } }
@keyframes pl-rise { from { opacity: 0; translate: 0 26px; } }

@media (min-width: 1024px) and (min-height: 540px) and (hover: hover) and (pointer: fine) and (prefers-reduced-motion: reduce) {
  :is(.pl-show, .a-pics-one), .pl-nose, .mx-arrow { transition: none; }
  :is(.pl-show, .a-pics-one) { translate: none; }
}

/* Another car while the story is read is one calm change of the chapters and the stage together (src/app/street/
   dock.ts). Every part keeps its place and moves to where the new car's stands, in `--calm`. Words that change fade
   through (`dock-words`): the old go in less than a press, the new come in over the rest. What does not change in kind
   stays still and only moves (`dock-still`): the cards themselves, the price and each card's figure, which count from
   the old car's value to the new one's, the acts, the sources. The street is not part of it: it stays alive. */
@media (prefers-reduced-motion: no-preference) {
  .st[data-switching] .pk-name { view-transition-name: dock-name; }
  .st[data-switching] .pk-price { view-transition-name: dock-price; }
  .st[data-switching] .pk-voice { view-transition-name: dock-say; }
  .st[data-switching] .pk-gaps { view-transition-name: dock-voice; }
  .st[data-switching] .pk-facts { view-transition-name: dock-facts; }
  .st[data-switching] .pk-more { view-transition-name: dock-more; }
  .st[data-switching] .pk-acts { view-transition-name: dock-acts; }
  .st[data-switching] .dp-aside { view-transition-name: dock-aside; }
  .st[data-switching] .answer[data-answer="month"] { view-transition-name: dock-month; }
  .st[data-switching] .answer[data-answer="month"] [data-slot="say"] { view-transition-name: dock-month-say; }
  .st[data-switching] .answer[data-answer="month"] [data-slot="face"] { view-transition-name: dock-month-face; }
  .st[data-switching] .answer[data-answer="drive-away"] { view-transition-name: dock-away; }
  .st[data-switching] .answer[data-answer="drive-away"] [data-slot="say"] { view-transition-name: dock-away-say; }
  .st[data-switching] .answer[data-answer="drive-away"] [data-slot="face"] { view-transition-name: dock-away-face; }
  .st[data-switching] .answer[data-answer="fits"] { view-transition-name: dock-fits; }
  .st[data-switching] .answer[data-answer="fits"] [data-slot="say"] { view-transition-name: dock-fits-say; }
  .st[data-switching] .answer[data-answer="fits"] [data-slot="face"] { view-transition-name: dock-fits-face; }
  .st[data-switching] .answer[data-answer="has"] { view-transition-name: dock-has; }
  .st[data-switching] .answer[data-answer="has"] [data-slot="say"] { view-transition-name: dock-has-say; }
  .st[data-switching] .answer[data-answer="has"] [data-slot="face"] { view-transition-name: dock-has-face; }
  .st[data-switching] .answer[data-answer="versions"] { view-transition-name: dock-versions; }
  .st[data-switching] .answer[data-answer="versions"] [data-slot="say"] { view-transition-name: dock-versions-say; }
  .st[data-switching] .answer[data-answer="versions"] [data-slot="face"] { view-transition-name: dock-versions-face; }
  .st[data-switching] .st-wait { view-transition-name: dock-wait; }
  .st[data-switching] .dp-acts { view-transition-name: dock-links; }
  .st[data-switching] .dp > .whence { view-transition-name: dock-whence; }
  .st[data-switching] :is(.pk-name, .pk-voice, .pk-gaps, .pk-facts, .pk-more, .dp-aside, .answer [data-slot="say"], .answer [data-slot="face"], .st-wait, .dp-acts) { view-transition-class: dock dock-words; }
  .st[data-switching] :is(.pk-price, .pk-acts, .answer, .dp > .whence) { view-transition-class: dock dock-still; }
  /* Only what is in view takes part: the chapter being read and the two around it, the car's head while it is near.
     The others change at once, out of sight, and the change costs the screen no more than what it shows. */
  .st[data-deep][data-switching] .answer[data-answer]:not([data-read], :has(+ [data-read]), [data-read] + .answer) { view-transition-name: none; }
  .st[data-deep][data-switching] .answer[data-answer]:not([data-read], :has(+ [data-read]), [data-read] + .answer) [data-slot] { view-transition-name: none; }
  .st[data-deep][data-switching] .pl:not([data-at="intro"], [data-at="month"]) :is(.pk-name, .pk-price, .pk-voice, .pk-gaps, .pk-facts, .pk-more, .pk-acts, .dp-aside) { view-transition-name: none; }
  .st[data-deep][data-switching] .pl:not([data-at="versions"], [data-at="end"]) :is(.dp-acts, .dp > .whence) { view-transition-name: none; }
  /* The stage takes part when its car changes (`data-car-change`, app.ts), quicker than the chapters: the new car is
     readable within a sixth of a second of the press. Its mini-street, make and picture fade through; its car and
     its name change as the first screen's name does (below). */
  .st[data-deep][data-switching][data-car-change] .mx-mini { view-transition-name: stage-mini; }
  .st[data-deep][data-switching][data-car-change] .pl-make { view-transition-name: stage-make; }
  .st[data-deep][data-switching][data-car-change] .pl-name { view-transition-name: stage-name; }
  .st[data-deep][data-switching][data-car-change] .pl-lane.is-car > .pl-car { view-transition-name: stage-car; }
  .st[data-deep][data-switching][data-car-change] .pl-shows { view-transition-name: stage-shows; }
  .st[data-deep][data-switching][data-car-change] :is(.mx-mini, .pl-make, .pl-shows) { view-transition-class: dock stage-words; }
  .st[data-deep][data-switching][data-car-change] .pl-name { view-transition-class: dock stage-move; }
  .st[data-deep][data-switching][data-car-change] .pl-lane.is-car > .pl-car { view-transition-class: dock stage-move stage-ground; }
  /* Only these parts take part: the page itself (and its top bar) is not captured, so the street stays the live page
     under the change, and nothing is painted twice. */
  :root.is-docking, :root.is-docking .app > :is(.bar, .held) { view-transition-name: none; }
  /* What takes part is drawn over the page: under the top bar, as the page itself is, never over it. */
  :root.is-docking::view-transition { pointer-events: none; clip-path: inset(var(--bar-h) 0 0 0); }
  :root.is-docking::view-transition-group(*.dock) { animation-duration: var(--calm); animation-timing-function: var(--ease); }
  /* Words that change go, then come, never both at once: the old ones in 70 ms (linear, seen going at once), the new
     ones from then on, in ink by 300 ms. */
  :root.is-docking::view-transition-old(*.dock-words) { animation: dock-out 70ms linear both; }
  :root.is-docking::view-transition-new(*.dock-words) { animation: dock-in 230ms var(--ease) 70ms both; }
  :root.is-docking::view-transition-old(*.dock-still) { animation: none; opacity: 0; }
  :root.is-docking::view-transition-new(*.dock-still) { animation: none; }
  /* The stage: out in 70 ms, in from then over 180 ms. */
  :root.is-docking::view-transition-group(*.stage-words) { animation-duration: 250ms; }
  :root.is-docking::view-transition-old(*.stage-words) { animation: dock-out 70ms linear both; }
  :root.is-docking::view-transition-new(*.stage-words) { animation: dock-in 180ms var(--ease) 70ms both; }
  /* The stage's car and its name: no morph from one to the other; each is drawn at its own size where it stands (the
     car on its ground), the old leaving toward the side the street moves, the new coming from the other side
     (`data-stepping` on the page, app.ts), in the same times. */
  :root.is-docking::view-transition-group(*.stage-move) { animation: none; }
  :root.is-docking::view-transition-old(*.stage-move), :root.is-docking::view-transition-new(*.stage-move) { inline-size: auto; block-size: auto; }
  :root.is-docking::view-transition-old(*.stage-ground), :root.is-docking::view-transition-new(*.stage-ground) { inset-block-start: auto; inset-block-end: 0; }
  :root.is-docking::view-transition-old(*.stage-move) { animation: dock-out 70ms linear both; }
  :root.is-docking::view-transition-new(*.stage-move) { animation: dock-in 180ms var(--ease) 70ms both; }
  :root.is-docking[data-stepping="next"]::view-transition-old(*.stage-move) { animation-name: stage-out-start; }
  :root.is-docking[data-stepping="next"]::view-transition-new(*.stage-move) { animation-name: stage-in-end; }
  :root.is-docking[data-stepping="prev"]::view-transition-old(*.stage-move) { animation-name: stage-out-end; }
  :root.is-docking[data-stepping="prev"]::view-transition-new(*.stage-move) { animation-name: stage-in-start; }
}
@keyframes dock-out { to { opacity: 0; } }
@keyframes dock-in { from { opacity: 0; } }
@keyframes stage-out-start { to { opacity: 0; translate: -20px 0; } }
@keyframes stage-out-end { to { opacity: 0; translate: 20px 0; } }
@keyframes stage-in-start { from { opacity: 0; translate: -20px 0; } }
@keyframes stage-in-end { from { opacity: 0; translate: 20px 0; } }
