/* runfoundry.dev: the one stylesheet. Tokens first, then the page from top to bottom. */

:root {
  /* palette, kept */
  --floor: #E6EAEC;   /* workshop concrete */
  --paper: #F5F7F8;
  --ink: #14202B;
  --steel: #46627A;
  --line: #B4BFC7;
  --gate: #F4B800;    /* floor-marking yellow: a person decides here, nothing else */
  --green: #1F7A4D;   /* a check passed, a part ran */
  --red: #B23A2B;     /* a check failed */
  /* palette, grown */
  --arc: #2B6FF3;     /* an agent round is running: marks and edges, never body text */
  --glass: rgb(207 227 236 / .45);  /* sealed: #CFE3EC between 35 and 55 % */
  --bay: #0C141B;     /* the dark hall: the closing and the footer only */
  --steel-bay: #5E7D96;  /* steel as a line on bay: #46627A there is 2.9:1, this is 4.3:1. Lines only, never text. */

  /* type */
  --display: "Big Shoulders Display", "Arial Narrow", sans-serif;
  --body: "Hanken Grotesk", system-ui, sans-serif;
  --mono: "JetBrains Mono", ui-monospace, "SFMono-Regular", Menlo, monospace;
  --h1: clamp(2.25rem, 9.6vw, 3.25rem);  /* two lines on a phone; one line from 48rem up, see below */
  --h2: clamp(2rem, 4.5vw, 3.25rem);
  --h3: 1.5rem;
  --text: 1.0625rem;
  --small: .9375rem;  /* 15 px: the one size for small print a reader needs, always in ink */
  --mono-size: .8125rem;
  --measure: 40rem;   /* right edge one: every text block */
  /* right edge two is the figure width: the full content box of .wrap. Figures set max-width: none. */

  /* space */
  --gutter: clamp(1rem, 5vw, 4rem);
  --section: clamp(2.25rem, 4vw, 2.75rem);  /* above and below every section's content: two of them make every gap, 96 px at most */

  /* motion: things slide along the floor's axes, no bounce */
  --ease: cubic-bezier(.2, .7, .2, 1);
  --t-control: 160ms;
  --t-scene: 480ms;
}
@media (min-width: 48rem) {
  :root { --h1: min(5.4vw, 4rem); }
}
@media (prefers-reduced-motion: reduce) {
  :root { --t-control: 0ms; --t-scene: 0ms; }
}
:root[data-motion="off"] { --t-control: 0ms; --t-scene: 0ms; }

* { box-sizing: border-box; }
html { scroll-behavior: smooth; }
@media (prefers-reduced-motion: reduce) { html { scroll-behavior: auto; } }
html[data-motion="off"] { scroll-behavior: auto; }   /* "Pause motion" stops the page's scrolling too */
body {
  margin: 0;
  background: var(--floor);
  color: var(--ink);
  font: 400 var(--text)/1.6 var(--body);
  -webkit-font-smoothing: antialiased;
}
a { color: inherit; text-decoration-thickness: 2px; text-underline-offset: 3px; transition: text-decoration-color var(--t-control) var(--ease); }
a:hover { text-decoration-color: var(--steel); }
:focus-visible { outline: 3px solid var(--ink); outline-offset: 3px; }
p { margin: 0 0 1em; max-width: var(--measure); text-wrap: pretty; }   /* no word alone on a last line */
figcaption, .plate-note, li { text-wrap: pretty; }
h1, h2, h3 { font-family: var(--display); font-weight: 800; margin: 0; text-wrap: balance; }   /* no heading ends on one short word */
h2 { font-size: var(--h2); line-height: 1; margin-bottom: 1.25rem; }
h3 { font-size: var(--h3); font-weight: 700; line-height: 1.1; }
code { font: 400 var(--mono-size)/1.5 var(--mono); }
:is(p, li, td, th, dd) code { white-space: nowrap; }   /* a chip never breaks at its hyphen or space into two grey pieces; the longest on the site is 26 characters */
/* table cells and definitions wrap plainly: pretty pulls two words down well before a short cell's edge */
td, dd { text-wrap: wrap; }
.id, .nw { white-space: nowrap; }   /* REQ-2, C-11: an id never breaks at its hyphen */

.wrap { padding-inline: var(--gutter); max-width: 72rem; margin-inline: auto; }

/* top bar */
.top { display: flex; flex-wrap: wrap; gap: .5rem 2rem; align-items: center; padding-block: .75rem; }
/* the lockup: the mark stands on the baseline and is as tall as the wordmark's ascenders */
.wordmark { display: inline-flex; align-items: baseline; gap: .32em; font: 800 1.75rem/1 var(--display); text-decoration: none; }
/* a target 44 px high: the padding widens what a thumb can hit, the negative margin keeps every row where it was */
.wordmark { padding-block: 8px; margin-block: -8px; }
.wordmark:focus-visible { outline-offset: -3px; }
.mark { flex: none; width: .75em; height: .75em; }
.top nav { display: flex; gap: 0 1.25rem; margin-left: auto; font-size: var(--small); }
.top nav a { flex: none; white-space: nowrap; text-decoration: none; padding-block: .25rem; border-bottom: 2px solid transparent; transition: border-color var(--t-control) var(--ease); }
.top nav a:hover { border-bottom-color: var(--ink); }
.nav-short { display: none; }
/* the way to Marcel, on every width: it opens LinkedIn in one tap and says so (the long words from 64rem up, the short
   ones below). The page's one ink outline style, never yellow: yellow on the first screen belongs to the gates. */
.top-write {
  flex: none; display: inline-flex; align-items: center; min-height: 2.5rem; padding: 0 .9rem;
  border: 2px solid var(--ink); font: 600 var(--small)/1.2 var(--body); text-decoration: none; white-space: nowrap;
  transition: box-shadow var(--t-control) var(--ease);
}
.top-write:hover { box-shadow: 3px 3px 0 var(--ink); }
.top-write:active { box-shadow: none; }
@media (min-width: 64rem) and (max-width: 71.99rem) {
  /* the full nav and the long link in one row: closer together while the bar is this narrow */
  .top { column-gap: 1rem; }
  .top nav { column-gap: .875rem; }
}
@media (max-width: 63.99rem) {
  /* two rows: the wordmark with the way to Marcel, then the five sections under one short word each, spread across
     the full width so the row ends on purpose. Every target is at least 44 px square; nothing scrolls or is cut. */
  .top { justify-content: space-between; gap: 0 1rem; padding-block: .375rem 0; }
  .top-write { min-height: 44px; }
  .top nav { order: 3; flex: none; width: 100%; justify-content: space-between; gap: 0 .5rem; margin-left: 0; }
  /* each link a target 44 px high, padded on both sides; the first and last keep their words on the page's two edges */
  .top nav a { display: inline-flex; align-items: center; justify-content: center; min-width: 44px; min-height: 44px; padding: 0 .5rem; }
  .top nav a:first-child { justify-content: flex-start; padding-left: 0; }
  .top nav a:last-child { justify-content: flex-end; padding-right: 0; }
  .top nav a:focus-visible { outline-offset: -3px; }
  .nav-full { display: none; }
  .nav-short { display: inline; }
}
@media (min-width: 48rem) and (max-width: 63.99rem) {
  /* a tablet has room for the full words: the second row starts on the left line and keeps the desktop's spacing */
  .top nav { justify-content: flex-start; gap: 0 1.75rem; }
  .top nav a:last-child { justify-content: center; }
  .top nav .nav-full { display: inline; }
  .top nav .nav-short { display: none; }
}

/* opening: the headline with air around it, then the floor with its control row and title block. The whole run fits the first screen. */
.open { padding-block: clamp(.75rem, 1.8vw, 1.625rem) var(--section); }
.open h1 { font-size: var(--h1); line-height: .92; margin-bottom: clamp(.875rem, 1.55vw, 1.375rem); }
.open h1 span { display: block; }   /* two sentences, two lines from 48rem up */
/* the proof strip: three dated results under the headline, an ink rule over each, the date in mono. No yellow (nobody
   decides here). One column on the phone, three from 48rem up. Its height is counted in --floor-rest. */
.proof-strip { margin: 0 0 clamp(.875rem, 1.55vw, 1.25rem); }
.ps-h { margin: 0 0 .35rem; font: 500 var(--mono-size)/1.45 var(--mono); }
.ps-h a { font-weight: 600; }
.ps { list-style: none; margin: 0; padding: 0; display: grid; grid-template-columns: minmax(0, 1fr); gap: .45rem; }
.ps li { border-top: 2px solid var(--ink); padding-top: .3rem; font-size: var(--small); line-height: 1.4; }
.ps-t { text-wrap: balance; }
.ps-d { display: block; font: 600 var(--mono-size)/1.45 var(--mono); white-space: nowrap; }
.ps-t a { font-weight: 600; white-space: nowrap; }
@media (min-width: 48rem) {
  .ps { grid-template-columns: repeat(3, minmax(0, 1fr)); column-gap: 1.5rem; }
  .ps li { padding-top: .4rem; }
}
@media (max-width: 47.99rem) {
  /* on the phone the date stands before the sentence on the same line, so three results take about five lines */
  .ps li { padding-top: .2rem; }
  .ps-d { display: inline; margin-right: .4rem; }
}
/* the lede is two paragraphs: who builds foundry and what it is stands before the figure, how a run goes follows the figure */
.open .lede { font-size: 1.125rem; line-height: 1.5; margin: 0 0 1rem; }
.open .lede-a { margin-bottom: .5rem; }
.lede-a strong, .lede-a a { font-weight: 600; }   /* the name, and on the phone the link, carry the weight */

/* the floor: a full-width band of paper, the model stands on it */
.floor-band { background: var(--paper); border-block: 2px solid var(--ink); padding-block: .625rem 1rem; }
.floor-in, .floor-stage { position: relative; }
/* --floor-rest is everything on the first screen that is not the drawing: top bar, headline, the lede's first sentence
   (below 72rem it stands above the drawing), control row, title block */
.floor-in { --floor-rest: 36rem; }   /* 30rem, and 6rem for the proof strip */
/* one column: the stage, the control row, the title block */
.floor { display: grid; grid-template-columns: minmax(0, 1fr); }
.floor-svg { display: block; width: 100%; height: auto; }
@media (min-width: 48rem) {
  /* never taller than the screen allows; 1.567 is the view box */
  .floor-stage { width: min(100%, max(36rem, calc((100svh - var(--floor-rest)) * 1.567))); }
}

.floor-svg .bx rect, .floor-svg .glass rect { stroke: var(--ink); stroke-width: 2.2; stroke-linejoin: round; }
.floor-svg .m-slab .t { fill: #E2E7EA; }  .floor-svg .m-slab .l { fill: #C6CFD6; }  .floor-svg .m-slab .r { fill: #AAB6BF; }
.floor-svg .m-goal .t { fill: #46627A; }  .floor-svg .m-goal .l { fill: #3A5368; }  .floor-svg .m-goal .r { fill: #2C4052; }
.floor-svg .m-plan .t { fill: #F5F7F8; }  .floor-svg .m-plan .l { fill: #E3E8EB; }  .floor-svg .m-plan .r { fill: #CFD7DC; }
.floor-svg .m-steel .t { fill: #D3DAE0; } .floor-svg .m-steel .l { fill: #B7C2CA; } .floor-svg .m-steel .r { fill: #9CAAB5; }
/* posts and beams are <use> copies: their paint is set as attributes in the markup */
/* a task block as an outline: planned, nothing built yet */
.floor-svg .tk rect { fill: var(--paper); fill-opacity: .45; stroke: var(--ink); stroke-width: 1.8; stroke-linejoin: round; stroke-dasharray: 5 4; }
.floor-svg .band { fill: var(--gate); stroke: var(--ink); stroke-width: 1.6; }
.floor-svg .lamp { fill: var(--paper); }
.floor-svg .sh { fill: var(--ink); opacity: .17; }
.floor-svg .lane { fill: #ECEFF1; }
.floor-svg .lane-line { fill: none; stroke: var(--line); stroke-width: 2; }
.floor-svg .chev { fill: none; stroke: var(--steel); stroke-width: 5; opacity: .5; }
.floor-svg .bay { fill: none; stroke: var(--steel); stroke-width: 2; }
.floor-svg .tree { fill: none; stroke: var(--ink); stroke-width: 2; }
.floor-svg .pad { fill: #F0F3F5; stroke: var(--line); stroke-width: 2; }
.floor-svg .slot { fill: none; stroke: var(--steel); stroke-width: 1.6; stroke-dasharray: 5 4; }
.floor-svg .glass .gb { fill: #CFE3EC; fill-opacity: .3; }
.floor-svg .glass .gf { fill: #CFE3EC; fill-opacity: .42; }
.floor-svg .glass .gt { fill: #CFE3EC; fill-opacity: .22; }
.floor-svg .glass .sheen { stroke: none; }  /* its gradient fill is set in the markup, where the id resolves */
.floor-svg .mull { fill: none; stroke: var(--ink); stroke-width: 1.4; opacity: .7; }
.floor-svg .lead path { fill: none; stroke: var(--ink); stroke-width: 1.5; }
.floor-svg .lead circle { fill: var(--ink); }

.floor-svg .tk-id { paint-order: stroke; stroke: var(--paper); stroke-width: 3px; stroke-linejoin: round; }   /* a paper halo */
.floor-svg .nums { display: none; }
.floor-svg .nums circle { fill: var(--ink); }
.floor-svg .nums text { fill: var(--paper); font: 500 44px var(--mono); text-anchor: middle; }  /* on a phone the circle is 21 px, the digit 14 px */

/* The floor moves. A .mv stands at (--x, --z) on the floor. A phase moves it along the lane (--dx), across it (--dz)
   or lifts it (--y); under the isometric matrix a lift is the same step back on both axes. js/floor.js sets data-phase
   on the figure: 0 goal at the entry, 1 goal in the plan bay, 2 split into features, 3 tasks planned and halted at
   gate one (the markup, and the still without JavaScript), 4 approved and in the room. Later phases keep what 4 did;
   what they add is drawn from the part states further down. */
.floor-svg .mv {
  transform: translate(calc((var(--x) + var(--dx, 0) - var(--y, 0)) * 1px), calc((var(--z) + var(--dz, 0) - var(--y, 0)) * 1px));
  transition: transform var(--t-scene) var(--ease), opacity var(--t-control) linear;
}
.floor-svg .tree { transition: opacity var(--t-control) linear var(--t-scene); }
/* the ids come back only once the drawing has zoomed out (2 x --t-scene), and leave as the zoom starts, so they never
   float over a drawing that is scaling under them */
.floor-ids li { transition: opacity var(--t-control) linear calc(var(--t-scene) * 2); }
.floor:is([data-phase="5"], [data-phase="6"], [data-phase="7"], [data-phase="8"], [data-phase="9"], [data-phase="10"], [data-phase="11"], [data-phase="12"], [data-phase="13"], [data-phase="14"], [data-phase="15"], [data-phase="16"], [data-phase="17"], [data-phase="18"], [data-phase="19"], [data-phase="20"], [data-phase="21"], [data-phase="22"]) .floor-ids li { transition-delay: 0s; transition-duration: 120ms; }
.floor-svg :is(.tk, .sl, .tkl) { transition-delay: calc(var(--t-scene) * var(--i) * .2); }  /* row after row; a shell keeps step with its block */
.floor-svg .b-bar1, .floor-svg .b-bar1s { transition-delay: calc(var(--t-scene) * .9); }  /* comes down after the blocks are back */
.floor.floor-cut * { transition: none !important; }  /* floor.js sets the first frame without a tween */

.floor[data-phase="0"] .b-g1 { --dx: -115; }
.floor:is([data-phase="0"], [data-phase="1"]) :is(.b-f1, .b-f2) { --dx: -90; opacity: 0; }
.floor:is([data-phase="0"], [data-phase="1"], [data-phase="2"]) :is(.tk, .tkl) { --dx: -40; opacity: 0; }
.floor:is([data-phase="0"], [data-phase="1"]) .tree-a,
.floor:is([data-phase="0"], [data-phase="1"], [data-phase="2"]) .tree-b,
.floor[data-phase="0"] .floor-ids li,
.floor[data-phase="1"] .floor-ids .on-plate { opacity: 0; }

/* an open barrier stands high above the lane (72), its posts telescoping up in three pieces (a third each) */
.floor:not([data-phase="0"], [data-phase="1"], [data-phase="2"], [data-phase="3"]) .b-bar1 { --y: 72; transition-delay: 0s; }
.floor:not([data-phase="0"], [data-phase="1"], [data-phase="2"], [data-phase="3"]) .b-bar1.rz1 { --y: 24; }
.floor:not([data-phase="0"], [data-phase="1"], [data-phase="2"], [data-phase="3"]) .b-bar1.rz2 { --y: 48; }
.floor:not([data-phase="0"], [data-phase="1"], [data-phase="2"], [data-phase="3"]) .b-bar1s { --dx: 14; opacity: .09; transition-delay: 0s; }
.floor:not([data-phase="0"], [data-phase="1"], [data-phase="2"], [data-phase="3"]) :is(.tk, .sl, .tkl) { --dx: 280; transition-delay: 0s; }
.floor[data-phase="4"] :is(.tk, .sl, .tkl) { transition-delay: calc(var(--t-scene) * (.6 + var(--i) * .2)); }  /* the beam first, then the blocks */
.floor:not([data-phase="0"], [data-phase="1"], [data-phase="2"], [data-phase="3"]) .tree-b { opacity: 0; transition-delay: 0s; }

/* From phase 4 on, js/floor.js also writes what each part shows, and these rules draw it. So a phase is a still here too.
   A task (data-s on .tk): p planned, r a round is running, o reopened, g its check passed.
   Arc blue is the edge of a task while a round runs on it, and nothing else. */
.floor-svg .tk rect { transition: fill var(--t-control) linear, stroke var(--t-control) linear; }
.floor-svg .tk:is([data-s="r"], [data-s="o"], [data-s="g"]) rect { fill-opacity: 1; stroke-dasharray: none; }
.floor-svg .tk:is([data-s="r"], [data-s="o"]) rect:nth-child(1) { fill: #CFD7DC; }
.floor-svg .tk:is([data-s="r"], [data-s="o"]) rect:nth-child(2) { fill: #E3E8EB; }
.floor-svg .tk[data-s="r"] rect { stroke: var(--arc); stroke-width: 3.4; }
.floor-svg .tk[data-s="g"] rect:nth-child(1) { fill: #14502F; }
.floor-svg .tk[data-s="g"] rect:nth-child(2) { fill: #1A6641; }
.floor-svg .tk[data-s="g"] rect:nth-child(3) { fill: var(--green); }
/* its glass shell (data-s on .sl): s sealed over the block, u lifted off it; anything else hangs unseen above */
.floor-svg .sl { --y: 60; opacity: 0; }
.floor-svg .sl[data-s="s"] { --y: 0; opacity: 1; }
.floor-svg .sl[data-s="u"] { --y: 36; opacity: 1; }
/* the check bench. Acceptance tests are marks on its top (data-t1 for F1, data-t2 for F2: r red, m one still red, g green).
   The board's lamps are check results (data-l1 feature F1, data-l2 feature F2, data-l3 the goal: r or g). */
.floor-svg .ts { --y: 14; opacity: 0; fill: var(--red); stroke: var(--ink); stroke-width: 1.6; }
.floor:is([data-t1="r"], [data-t1="m"], [data-t1="g"]) .ts-a,
.floor:is([data-t2="r"], [data-t2="g"]) .ts-b { --y: 0; opacity: 1; }
.floor[data-t1="m"] .ts-a:not(.ts-late), .floor[data-t1="g"] .ts-a, .floor[data-t2="g"] .ts-b { fill: var(--green); }
.floor-svg .lamp, .floor-svg .ts { transition: transform var(--t-scene) var(--ease), opacity var(--t-control) linear, fill var(--t-control) linear; }
.floor[data-l1="r"] .l1 { fill: var(--red); }
.floor[data-l1="g"] .l1, .floor[data-l2="g"] .l2, .floor[data-l3="g"] .l3 { fill: var(--green); }
/* the blame mark: red paint on the floor that points from the bench at one slot */
.floor-svg .blame { fill: none; stroke: var(--red); stroke-width: 4; opacity: 0; transition: opacity var(--t-control) linear; }
.floor[data-blame] .blame { opacity: 1; }
/* a review round (data-review): the reviewer reads frozen work, so the glass of what it reads gets the arc-blue edge of a
   running round. In Review (phase 17) that is F1's four tasks, in the goal check (phase 22) all six. */
.floor-svg .sl { transition: transform var(--t-scene) var(--ease), opacity var(--t-control) linear, stroke var(--t-control) linear; }
.floor[data-review] .floor-svg .sl[data-s="s"] { stroke: var(--arc); stroke-width: 3.4; }
.floor[data-review="f1"] .floor-svg .sl:nth-child(n + 5 of .sl) { stroke: #14202B; stroke-width: 2; }
/* where the blocks stand (data-at): in the room, halted at gate two, on the pallet, gone with it */
.floor[data-at="gate2"] :is(.tk, .sl, .tkl) { --dx: 503; transition-delay: calc(var(--t-scene) * var(--i) * .15); }
.floor[data-at="gate2"] .c2 { --dx: 497; }   /* the second column closes up on the first, so T2 and T4 stand clear of the beam */
.floor:is([data-at="pallet"], [data-at="gone"]) .b-bar2 { --y: 72; }
.floor:is([data-at="pallet"], [data-at="gone"]) .b-bar2.rz1 { --y: 24; }
.floor:is([data-at="pallet"], [data-at="gone"]) .b-bar2.rz2 { --y: 48; }
.floor:is([data-at="pallet"], [data-at="gone"]) .b-bar2s { --dx: 14; opacity: .09; }
.floor[data-at="pallet"] :is(.tk, .sl, .tkl) { --dx: 657; --y: 6; transition-delay: calc(var(--t-scene) * (.6 + var(--i) * .15)); }
.floor[data-at="gone"] :is(.tk, .sl, .tkl) { --dx: 857; --y: 6; }
.floor[data-at="gone"] .b-pal { --dx: 200; }
.floor[data-at="gone"] :is(.tk, .sl, .tkl, .b-pal) { opacity: 0; transition: transform var(--t-scene) var(--ease), opacity var(--t-scene) linear; }

/* From Build to the passed feature check (phases 5 to 16) the drawing moves in on the room and the bench, 1.45 times,
   so the four tasks, their glass and the blame mark read larger while gate two and the bench stay inside the frame;
   for F2 (phases 17 to 20) it stands at 1.25, so F2's two tasks are still seen close. The point at 62 % 54 % of the
   view box (between the room and the bench) stays where it is. On a phone it moves in 2.9 times on the four tasks
   and the bench, so T1 to T4 can be read (about 15 px), and the station key gives way to one line.
   The labels on the drawing fade while it is close, because their places hold only for the whole floor. Its edges
   fade out over 28 px while it is close, so the frame reads as a camera, not a cut. With reduced motion or
   "Pause motion" it cuts. */
.floor-svg .zoom { transform-box: view-box; transform-origin: var(--zo, 62% 54%); transition: transform calc(var(--t-scene) * 2) var(--ease); }
.floor:is([data-phase="5"], [data-phase="6"], [data-phase="7"], [data-phase="8"], [data-phase="9"], [data-phase="10"], [data-phase="11"], [data-phase="12"], [data-phase="13"], [data-phase="14"], [data-phase="15"], [data-phase="16"], [data-phase="17"]) .floor-svg .zoom { transform: scale(var(--zs, 1.45)); }
@media (min-width: 64rem) { .floor { --zs: 1.8; --zs3: 1.8; } }   /* on a desktop the four tasks and their labels read at about 20 px close up */
.floor:is([data-phase="18"], [data-phase="19"], [data-phase="20"], [data-phase="21"]) .floor-svg .zoom { transform: scale(var(--zs2, 1.25)); }
/* the goal check (phase 22) has its own close-up on the bench, so its lamps read; gate two zooms back out */
.floor[data-phase="22"] { --zo: 46% 58%; }
.floor[data-phase="22"] .floor-svg .zoom { transform: scale(var(--zs3, 1.4)); }
.floor-labels li, .floor-svg :is(.nums, .lead) { transition: opacity var(--t-control) linear; }
.floor:is([data-phase="5"], [data-phase="6"], [data-phase="7"], [data-phase="8"], [data-phase="9"], [data-phase="10"], [data-phase="11"], [data-phase="12"], [data-phase="13"], [data-phase="14"], [data-phase="15"], [data-phase="16"], [data-phase="17"], [data-phase="18"], [data-phase="19"], [data-phase="20"], [data-phase="21"], [data-phase="22"])
  :is(.floor-labels .at-gate, .floor-svg .nums, .floor-svg .lead) { opacity: 0; }
@media (min-width: 40.0625rem) {
  .floor:is([data-phase="5"], [data-phase="6"], [data-phase="7"], [data-phase="8"], [data-phase="9"], [data-phase="10"], [data-phase="11"], [data-phase="12"], [data-phase="13"], [data-phase="14"], [data-phase="15"], [data-phase="16"], [data-phase="17"], [data-phase="18"], [data-phase="19"], [data-phase="20"], [data-phase="21"], [data-phase="22"])
    :is(.floor-labels li, .floor-ids li) { opacity: 0; }
  .floor:is([data-phase="5"], [data-phase="6"], [data-phase="7"], [data-phase="8"], [data-phase="9"], [data-phase="10"], [data-phase="11"], [data-phase="12"], [data-phase="13"], [data-phase="14"], [data-phase="15"], [data-phase="16"], [data-phase="17"], [data-phase="18"], [data-phase="19"], [data-phase="20"], [data-phase="21"], [data-phase="22"]) .floor-svg {
    -webkit-mask-image: linear-gradient(to top, transparent, #000 28px), linear-gradient(to right, transparent, #000 28px);
    -webkit-mask-composite: source-in;
    mask-image: linear-gradient(to top, transparent, #000 28px), linear-gradient(to right, transparent, #000 28px);
    mask-composite: intersect;
  }
}
@media (max-width: 40rem) {
  .floor { --zo: 42% 50%; --zs: 2.9; --zs2: 2; --zs3: 2.2; }   /* with view-box the origin counts from the user space's 0 0, not the view box's corner: this is 63.5 % 54.5 % of what is seen */
  /* close up, the five numbers are gone from the drawing: the key says so in one line instead of listing them. The
     line hangs from the first entry, so the key keeps its height and nothing under it moves. */
  .floor-labels li:first-child { position: relative; }
  .floor-labels li:first-child::after {
    content: "Build bay and check bench, close up"; position: absolute; left: 0; top: 0; white-space: nowrap;
    visibility: hidden; opacity: 0; transition: opacity var(--t-control) linear;
  }
  .floor:is([data-phase="5"], [data-phase="6"], [data-phase="7"], [data-phase="8"], [data-phase="9"], [data-phase="10"], [data-phase="11"], [data-phase="12"], [data-phase="13"], [data-phase="14"], [data-phase="15"], [data-phase="16"], [data-phase="17"], [data-phase="18"], [data-phase="19"], [data-phase="20"], [data-phase="21"], [data-phase="22"]) .floor-labels {
    li:not(.at-gate) { visibility: hidden; }
    li:first-child::after { visibility: visible; opacity: 1; }
  }
}
/* the end: the work has left, so the goal and its features fade too and the floor stands empty */
.floor-svg :is(.b-g1, .b-f1, .b-f2) { transition: transform var(--t-scene) var(--ease), opacity var(--t-scene) linear; }
.floor[data-at="gone"] :is(.floor-svg .b-g1, .floor-svg .b-f1, .floor-svg .b-f2, .floor-ids li) { opacity: .3; }

/* station labels and block ids: real text, set on the drawing by percentage of the view box */
.floor-labels, .floor-ids { list-style: none; margin: 0; padding: 0; }
.floor-labels li, .floor-ids li { white-space: nowrap; font: 500 var(--mono-size)/1.25 var(--mono); }
.floor-labels .at-gate, .floor-ids li { position: absolute; left: calc(var(--x) * 1%); top: calc(var(--y) * 1%); }
.floor-labels .at-gate { padding: .1em .5em; background: var(--gate); }
.floor-labels .up { transform: translateY(-100%); }      /* stands on its leader, reads to the right */
.floor-labels .down { transform: translateX(-100%); }    /* hangs from its leader, ends at it */
.floor-ids li { transform: translate(-50%, -50%); font-size: .75rem; font-weight: 400; letter-spacing: -.02em; }   /* G1.F2 inside its plate's top face */
.floor-ids .on-goal { color: var(--paper); }
.floor-ids .on-small { font-size: .6875rem; letter-spacing: -.05em; }   /* G1.F2's plate is the smaller one: its id fits inside the top face */
@media (min-width: 64rem) {
  .floor-labels li { font-size: .9375rem; }   /* the station names read at 15 px on a desktop */
}
@media (min-width: 40.0625rem) {
  .floor-labels li { position: absolute; left: calc(var(--x) * 1%); top: calc(var(--y) * 1%); padding: .1em .5em; }
}

/* the control row: the gate button, what is happening in words, then Back, Next and the motion switch.
   Below 72rem the words get a row of their own above the buttons. */
.floor-ctl { display: grid; grid-template-columns: auto minmax(0, 1fr) auto; align-items: center; gap: .5rem 1.25rem; margin-top: .625rem; }
.floor-ctl [hidden] { display: none; }
/* With a script the buttons will appear: their room is held, unseen, from the first paint, so the legend and the text
   under the control row never jump. Without a script there is no room to hold. With reduced motion the switch stays off. */
.js .floor-ctl .floor-act[hidden] { display: inline-block; visibility: hidden; }
.js .floor-ctl .floor-nav[hidden] { display: flex; visibility: hidden; }
@media (prefers-reduced-motion: no-preference) {
  .js .floor-ctl .floor-pause[hidden] { display: inline-block; visibility: hidden; }
}
.floor-status { grid-area: 1 / 1 / 2 / -1; max-width: none; min-height: 2.8em; margin: 0; font-size: var(--small); line-height: 1.4; text-wrap: pretty; }  /* two lines, so the buttons never move; no last line of one short word */
.floor-step { margin-right: .4rem; font: 500 var(--mono-size)/1.4 var(--mono); white-space: nowrap; }
.floor-act { grid-area: 2 / 1; }
.floor-side { grid-area: 2 / 3; display: flex; justify-content: flex-end; gap: .5rem; }
.floor-nav { display: flex; gap: .5rem; }
/* one ink outline for every button here. Only a gate fills it with yellow. */
.floor-ctl button, .chain-ctl button {
  min-height: 3rem; padding: 0 1.25rem; border: 2px solid var(--ink); border-radius: 0;
  background: transparent; color: var(--ink); font: 600 1rem/1.2 var(--body); cursor: pointer;
  transition: background-color var(--t-control) var(--ease), box-shadow var(--t-control) var(--ease);
}
.floor-ctl button:hover, .chain-ctl button:hover { box-shadow: 3px 3px 0 var(--ink); }
.floor-ctl button:active, .chain-ctl button:active { box-shadow: none; }
/* not live: a ghost. No fill (a grey fill reads as broken), a faint solid steel outline on the box's own edge (dashes
   mean "planned, not built" in Fig. 1's legend, so a control never wears them: review 6) and ink
   words: "not there yet". No change on hover, so it cannot be taken for "Next" beside it. The 2 px border stays,
   unseen, so nothing changes size when a control goes live. Waiting for the work, the gate button carries a small
   steel tick before its words (.floor-act::after), the way the work is moving. */
.floor-ctl button[aria-disabled="true"],
.floor-ctl button[aria-disabled="true"]:hover,
.floor-ctl button[aria-disabled="true"]:active {
  border-color: transparent; background: transparent; color: var(--ink);
  outline: 2px solid color-mix(in srgb, var(--steel) 45%, transparent); outline-offset: -2px; box-shadow: none; cursor: not-allowed;
}
.floor-act[aria-disabled="true"] { padding-left: 2.25rem; }
.floor-act[aria-disabled="true"]::after {
  content: ""; position: absolute; left: 1rem; top: 50%; width: .5rem; height: .5rem; margin-top: -.25rem;
  border-top: 2px solid var(--steel); border-right: 2px solid var(--steel); transform: rotate(45deg);
}
.floor-ctl button[aria-disabled="true"]:focus-visible { outline: 3px solid var(--ink); outline-offset: 3px; }   /* it can still be reached by keyboard, and shows it */
.floor-act { position: relative; min-width: 16.5rem; white-space: nowrap; }   /* "Gate one: approve the plan" on one line, and nothing moves when the label changes */
.floor-act.is-gate { padding-left: 2rem; background: var(--gate); }
.floor-act.is-gate::before {   /* a person decides here: the gate's own stripes */
  content: ""; position: absolute; inset: 0 auto 0 0; width: .75rem; border-right: 2px solid var(--ink);
  background: repeating-linear-gradient(-45deg, var(--ink) 0 5px, var(--gate) 5px 10px);
}
.floor-nav button { min-width: 4.25rem; padding-inline: .9rem; }
.floor-pause { min-width: 9.5rem; }   /* "Resume motion" fits too */
@media (min-width: 40.0625rem) {
  /* The sentence is what makes the drawing readable, so on every width it has a row of its own directly under the
     stage, at body size, the step's name as a small mono label before it. Room is held for two lines and the sentence
     stands on the row's floor, right above the buttons, so a one-line sentence leaves the space above it, not between
     it and the controls. The controls follow in one row. */
  .floor-status { display: flex; flex-wrap: wrap; align-content: flex-end; align-items: baseline; column-gap: .6rem; max-width: 50rem; min-height: 2.9em; font-size: var(--text); line-height: 1.45; }
  .floor-step { flex: none; margin-right: 0; }
  .floor-say { flex: 1 1 0; min-width: 0; }
}

/* the title block of the drawing: what the figure is, then the printed legend. Every colour here means the same on the whole page. */
.floor-key {
  display: grid; grid-template-columns: minmax(0, 1fr);
  max-width: none; margin-top: 1.25rem; border: 2px solid var(--ink);
  color: var(--ink); font-size: var(--small); line-height: 1.4;
}
.floor-cap { max-width: none; margin: 0; padding: .4rem .625rem .45rem; text-wrap: pretty; }
.floor-cap .plate-no { margin-right: .4rem; font: 500 var(--mono-size)/1.4 var(--mono); }
.floor-cap strong, .floor-legend strong { font-weight: 600; }
.floor-cap-note, .floor-legend strong { display: block; }
.floor-legend { list-style: none; margin: 0; padding: 0; display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); border-top: 2px solid var(--ink); }
/* an entry is a swatch and two lines; the swatch stands in the middle of those two (.8125rem down), also beside the
   glass entry, whose second line runs on to a third from 40rem up. So no other entry moves when one grows. */
.floor-legend li { display: flex; align-items: flex-start; gap: .5rem; padding: .4rem .625rem .45rem; }
.lg-more { display: none; }   /* the phone says "Sealed"; from 40rem up: "Sealed: the room, a finished task" */
.floor-legend li:nth-child(even) { border-left: 1px solid var(--line); }
.floor-legend li:nth-child(n + 3) { border-top: 1px solid var(--line); }
.lg { flex: none; width: 1rem; height: 1rem; margin-top: .8125rem; border: 2px solid var(--ink); }
.lg-gate { background: var(--gate); }
.lg-arc { background: #E3E8EB; border: 3px solid var(--arc); }                                   /* the edge of a task while a round runs on it */
.lg-check { background: linear-gradient(135deg, var(--green) 50%, var(--red) 50%); }
.lg-dash { border-style: dashed; background: var(--paper); }                                    /* a task block that is only planned */
.lg-blame { border: 3px solid var(--red); background: var(--paper); }                            /* the blame mark's frame */
/* glass as the shell on the floor shows it: the pale blue face with the white sheen across its corner, so the swatch reads
   as a colour on paper and never as an empty square */
.lg-glass { background: linear-gradient(135deg, rgb(255 255 255 / .75) 0 30%, transparent 30%), #CFE3EC; }
/* All four swatches are in colour from the first paint, in every state of the floor. */
@media (min-width: 40.0625rem) {
  /* six entries in three columns of two rows */
  .floor-legend { grid-template-columns: repeat(3, minmax(0, 1fr)); }
  .lg-more { display: inline; }
  .floor-legend li:nth-child(n) { border-top: 0; border-left: 0; }
  .floor-legend li:not(:nth-child(3n + 1)) { border-left: 1px solid var(--line); }
  .floor-legend li:nth-child(n + 4) { border-top: 1px solid var(--line); }
}
@media (max-width: 40rem) {
  .floor-stage { margin-inline: calc(var(--gutter) * -1); }
  .floor-svg .bx rect, .floor-svg .glass rect { stroke-width: 3.4; }
  .floor-svg .tk rect { stroke-width: 2.8; stroke-dasharray: 8 6; }
  .floor-svg .tk[data-s="r"] rect { stroke-width: 5.5; }
  .floor-svg .blame { stroke-width: 6; }
  .floor-svg .ts { stroke-width: 2.6; }
  .floor-svg .lead path { stroke-width: 3; }
  .floor-svg .tree, .floor-svg .bay, .floor-svg .lane-line { stroke-width: 3; }
  .floor-svg .slot { stroke-width: 2.6; }
  /* only the two gates keep their names on the drawing. The stage is as wide as the screen here, so a label's
     top is --y percent of the drawing's height written in vw (776 / 1216 = .638); the key below adds to the stage's height. */
  .floor-svg .nums { display: inline; }
  .floor-labels .at-gate { top: calc(var(--y) * .63816vw); font-size: .75rem; }
  /* the other five stations: numbers on the drawing, names in this key, set as body text */
  .floor-labels { display: flex; flex-wrap: wrap; gap: .3rem 1rem; padding: .5rem var(--gutter) 0; counter-reset: station; }
  .floor-labels li:not(.at-gate) { counter-increment: station; display: flex; align-items: center; gap: .4rem; transform: none; font: 400 var(--text)/1.4 var(--body); }
  .floor-labels li:not(.at-gate)::before {
    content: counter(station); flex: none; width: 1.5rem; height: 1.5rem; border-radius: 50%;
    background: var(--ink); color: var(--paper); font: 500 var(--mono-size)/1.5rem var(--mono); text-align: center;
  }
  /* the words at body size, under them the gate button across the full width, under it Back, Next and the motion switch in one row */
  .floor-ctl { grid-template-columns: minmax(0, 1fr); }
  .floor-status { min-height: calc(var(--mono-size) * 1.4 + 4.35em); font-size: var(--text); line-height: 1.45; }  /* the label and the longest sentence on three lines */
  .floor-step { display: block; margin: 0; }
  .floor-act { grid-area: 2 / 1; min-width: 0; }
  .floor-side { grid-area: 3 / 1; }
  .floor-nav { flex: 1 1 auto; }
  .floor-nav button { flex: 1 1 auto; min-width: 0; padding-inline: .5rem; white-space: nowrap; }
  .floor-pause { flex: 1 1 auto; min-width: 0; padding-inline: .5rem; }   /* "Resume motion" may take two lines on the narrowest phones */
}
@media (min-width: 40.0625rem) and (max-width: 47.99rem) {
  /* too narrow for the gate button and the three others in one row: the gate button stands alone, the others under it */
  .floor-ctl { grid-template-columns: minmax(0, 1fr); }
  .floor-act { justify-self: start; }
  .floor-side { grid-area: 3 / 1; justify-content: flex-start; }
}
@media (max-width: 40rem) {
  .floor-ids { display: none; }   /* the phone drops G1, G1.F1, G1.F2; from 40rem up they stay, at 13 px */
}
@media (max-width: 47.99rem) {
  /* The phone's first screen names the person, what he builds and what shipped, then shows the floor and the gate button.
     The figure gives its children to one column, in source order: the lede, the drawing with its station key, the
     status sentence and the control row, then the title block and legend. */
  .floor-in { display: flex; flex-direction: column; }
  .floor { display: contents; }
  .floor-in > *, .floor > * { min-width: 0; }
  .open h1 { margin-bottom: 1.25rem; text-wrap: balance; }   /* each sentence balanced on its two lines, 20 px before the proof strip */
  .open h1 span { text-wrap: balance; }
  .open .lede-a { font-size: var(--text); }
  /* the figure's number and title stand above the drawing, as every plate's head does; the legend stays under the controls */
  .floor-key { display: contents; }
  .open .lede-a { order: -2; }
  .floor-cap { order: -1; margin-top: .5rem; padding: .4rem 0 .5rem; border-top: 2px solid var(--ink); }
  .floor-legend { margin-top: 1rem; border: 2px solid var(--ink); }
}
@media (min-width: 48rem) and (max-width: 59.99rem) {
  /* the lede's first paragraph is two lines above the drawing here: balanced, and counted in what the drawing leaves free.
     The stage takes the figure's full width, so the drawing moved in on the room ends at the figure's edge, not in mid-paper. */
  .floor-in { --floor-rest: 37.5rem; }   /* 32rem, 5rem for the proof strip, and the sentence at body size */
  .open .lede-a { text-wrap: balance; }
  .floor-stage { width: 100%; }
}
@media (min-width: 60rem) {
  /* Fig. 1 in two columns (review 8, round 2). Left, the stage, never wider than its column, so nothing of the text
     ever lies on the drawing, zoomed or not. Right, the lede on top and the control row at the stage's foot: the
     sentence, the gate button, then Back and Next and the motion switch. So the gate button is on the first screen of
     every laptop. The title block follows across the full width. The figure gives its children to this grid
     (display: contents), as on the phone. */
  .floor-in {
    --side: 18rem; --floor-rest: 27rem;   /* top bar, headline and proof strip: what stands above the stage */
    display: grid; grid-template-columns: minmax(0, 1fr) var(--side); grid-template-rows: auto 1fr auto auto; column-gap: 1.5rem;
  }
  .floor { display: contents; }
  .floor-in > *, .floor > * { min-width: 0; }
  .floor-stage { grid-area: 1 / 1 / 3 / 2; align-self: start; width: min(100%, max(36rem, calc((100svh - var(--floor-rest)) * 1.567))); }
  .open .lede-a { grid-area: 1 / 2; margin: 0; font-size: var(--text); line-height: 1.55; }
  .floor-ctl { grid-area: 2 / 2; align-self: end; grid-template-columns: minmax(0, 1fr); gap: .5rem; margin-top: 1rem; }
  /* the step's name on its own line, the sentence under it, held at five lines and standing on the gate button */
  .floor-status { grid-area: 1 / 1; display: flex; flex-direction: column; justify-content: flex-end; min-height: calc(var(--mono-size) * 1.4 + 5 * 1.45em + 2px); max-width: none; }
  .floor-step { margin: 0 0 .1rem; }
  .floor-say { flex: none; }
  .floor-act { grid-area: 2 / 1; min-width: 0; width: 100%; text-align: left; }
  .floor-side { grid-area: 3 / 1; flex-wrap: wrap; justify-content: flex-start; }
  .floor-nav { flex: 1 1 100%; }
  .floor-nav button { flex: 1 1 0; }
  .floor-key { grid-area: 3 / 1 / 4 / -1; }
}
@media (min-width: 72rem) {
  .floor-in { --side: 21rem; }
  .floor-status { min-height: calc(var(--mono-size) * 1.4 + 4 * 1.45em + 2px); }   /* the longest sentence takes four lines at 21rem */
  .floor-key { grid-template-columns: minmax(0, 1.9fr) minmax(0, 4fr); }
  .floor-legend { border-top: 0; border-left: 2px solid var(--ink); }
}

.part { padding-block: var(--section); }
/* one divider between sections, as wide as the content box (the grid), not the padded box */
.part { position: relative; }
:is(.part, .design-open) + .part::before { content: ""; position: absolute; top: 0; left: var(--gutter); right: var(--gutter); border-top: 1px solid var(--line); }
.part > :last-child, .run > li:last-child { margin-bottom: 0; }  /* the section's padding is the only space at its end */

/* plate: every diagram, document and picture is a numbered figure */
.plate { margin: 2rem 0 0; max-width: none; background: var(--paper); color: var(--ink); border: 2px solid var(--ink); }
.plate > .plate-head {
  display: flex; flex-wrap: wrap; align-items: baseline; gap: .2rem 1rem;
  max-width: none; margin: 0; padding: .55rem .9rem;
  border-bottom: 2px solid var(--ink);
  font: 400 var(--mono-size)/1.45 var(--mono); color: var(--ink);
}
.plate-no { font-weight: 500; white-space: nowrap; }
.plate-title { flex: 1 1 auto; font: 600 var(--small)/1.45 var(--body); text-wrap: balance; }   /* auto (review 6): the source drops to its own line before the title wraps */
/* the source is small print a reader needs: body type at 15 px, in the plate's own text colour */
.plate-src { margin-left: auto; font: 400 var(--small)/1.45 var(--body); overflow-wrap: anywhere; text-wrap: pretty; }
@media (max-width: 47.99rem) {
  /* wrapped under the title it reads as a second line on the left, not a ragged right one */
  .plate-src { margin-left: 0; flex-basis: 100%; text-align: left; }
}
.plate-kind { display: inline-flex; align-items: center; gap: .5rem; white-space: nowrap; }
.plate-state { flex: none; width: .8rem; height: .8rem;   /* the same square as the status table's .sw */ border: 2px solid var(--ink); align-self: center; }
.plate-state.ran { background: var(--green); border-color: var(--green); }
.plate-state.built { background: var(--steel); border-color: var(--steel); }
.plate-state.mocks { background: linear-gradient(135deg, var(--steel) 50%, transparent 50%); border-color: var(--steel); }
.plate-state.none { border-style: dashed; border-color: var(--steel); }
.plate-body { padding: 1rem; overflow-x: auto; }
.plate-body:focus-visible { outline-offset: -5px; }
.plate-note { max-width: none; margin: 0; padding: .75rem .9rem .85rem; border-top: 1px solid var(--line); font-size: var(--small); }
.plate-note p { max-width: var(--measure); margin: 0; }

figure { margin: 0; }
figcaption { font-size: var(--small); max-width: var(--measure); }

/* the loops (Fig. 4) and the machines (Fig. 8): wide drawings on paper, each with two twins. The wide drawing (.lp-wide)
   stands from 64rem up, where the plate is 890 to 1000 px wide: its text is 14 to 16 px. From 48 to 64rem the same boxes
   stand in two columns (.lp-mid, 732 units), filling the plate, text 14 to 19 px. Below 48rem one stacked column
   (.lp-narrow, 360 units). Ink arrows are the way through; dashed steel ones are what flows back. */
.lp { display: block; width: 100%; height: auto; }
.lp .lp-frame { fill: none; stroke: var(--line); stroke-width: 2; }
.lp .lp-box { fill: #fff; stroke: var(--ink); stroke-width: 2; }
.lp .lp-box.lp-ok { stroke: var(--green); stroke-width: 3; }
.lp .lp-gate { fill: var(--gate); stroke: var(--ink); stroke-width: 2; }
.lp .lp-arrow { fill: none; stroke: var(--ink); stroke-width: 2.4; marker-end: url(#lp-ah); }
.lp .lp-arrow.lp-red { stroke: var(--red); }   /* the one loop inside the build loop: a red check, in the page's red as in Fig. 1 */
.lp .lp-back { fill: none; stroke: var(--steel); stroke-width: 2; stroke-dasharray: 7 5; }
.lp .lp-back.lp-push { stroke-dasharray: none; stroke-width: 1.8; }   /* Fig. 8: what goes to GitHub, solid, so dashes keep one meaning on the page (what flows back) */
.lp .lp-halo { fill: none; stroke: var(--paper); stroke-width: 9; }   /* where two ways cross, the one drawn later passes over */
.lp text { fill: var(--ink); }
.lp .lp-t { font: 400 16.5px var(--body); }
.lp .lp-strong { font-weight: 600; }
.lp .lp-s { font: 400 15.25px var(--body); }
.lp .lp-head { font: 700 21px var(--display); letter-spacing: .02em; }
.lp .lp-note { font: 600 15.25px var(--body); fill: var(--steel); }
.lp-narrow, .lp-mid { display: none; }
@media (max-width: 63.99rem) {
  .lp-wide { display: none; }
  .lp-narrow .lp-t, .lp-mid .lp-t { font-size: 15.5px; }
  .lp-narrow :is(.lp-s, .lp-note), .lp-mid :is(.lp-s, .lp-note) { font-size: 14.5px; }
  .lp-narrow .lp-note, .lp-mid .lp-note { font-weight: 400; }
  .lp-narrow .lp-head, .lp-mid .lp-head { font-size: 21px; }
}
@media (min-width: 48rem) and (max-width: 63.99rem) {
  .lp-mid { display: block; max-width: 46rem; margin-inline: auto; }
}
@media (max-width: 47.99rem) {
  .lp-narrow { display: block; max-width: 28rem; margin-inline: auto; }
}
.loop-cards { list-style: none; margin: 1.75rem 0 0; padding: 0; display: grid; gap: 1.25rem; }
@media (min-width: 64rem) { .loop-cards { grid-template-columns: repeat(3, 1fr); } }
.loop-cards li { border-top: 3px solid var(--ink); padding-top: .75rem; }
.loop-cards h3 { margin-bottom: .5rem; }
/* the products section: one heading per product */
.prod-h { margin: 2.75rem 0 .75rem; }
.loop-cards p { margin: 0; font-size: var(--small); }

/* the run: a line with stations, crossed by two gates */
/* --step-in is where a step title starts; the gate bands start their text on the same line */
.run { --rail: 1.25rem; --rail-pad: 4rem; --step-in: calc(var(--rail) + 3px + var(--rail-pad)); list-style: none; margin: 2.5rem 0 0; padding: 0; counter-reset: step; }
.run > li.step {
  counter-increment: step;
  position: relative;
  padding: 0 0 2.25rem var(--rail-pad);
  border-left: 3px solid var(--ink);
  margin-left: var(--rail);
}
.run > li.step::before {
  content: counter(step);
  position: absolute; left: -1.3rem; top: -.2rem;
  width: 2.5rem; height: 2.5rem; border-radius: 50%;
  background: var(--floor); border: 3px solid var(--ink);
  font: 800 1.35rem/2.2rem var(--display); text-align: center;
}
.run h3 { margin-bottom: .4rem; }
.run p { margin-bottom: 0; }
.run p.step-more { margin-top: .6rem; }

.gate {
  position: relative;
  background: var(--gate);
  margin: 0 calc(var(--gutter) * -1) 2.25rem;
  padding: 1.1rem var(--gutter) 1.1rem calc(var(--gutter) + var(--step-in));   /* as tall as a step row (review 9) */
}
.gate::before, .gate::after {
  content: ""; position: absolute; left: 0; right: 0; height: 8px;
  background: repeating-linear-gradient(-45deg, var(--ink) 0 12px, var(--gate) 12px 24px);
}
.gate::before { top: 0; }
.gate::after { bottom: 0; }
.gate h3 { font-weight: 800; margin-bottom: .4rem; }   /* a step title's size, in the heavier weight */
.gate p { margin: 0; }
/* under gate two, on the page's left line: where the reader who does not build software goes next */
.run-after { margin-top: 1.5rem; }
.run-after a { font-weight: 600; }

/* The chain (Fig. 7): the floor's drawing language in three stills. The view box is 968 wide. A station's place comes
   from its link --i and its chain --k. From 56rem up the two chains run along two lanes on one slab, labels on leaders
   off the back and the front edge. Below that each chain is a column of tiles that runs straight down the page (one
   step down the page is the same step along both ground axes): the SVG is then drawn 968 / 540 as wide as its stage,
   and the stage shows the left 540 units. Parts with .w are drawn only wide, parts with .n only narrow.
   The state is data-still on the figure: 1 as approved, 2 one claim changes, 3 rebuilt. Red and green are check
   results on the test, task and code blocks (.chk), nothing else. Type sizes are in view box units and are chosen so
   that nothing is under 12 px at 390 px or at 56rem. */
.chain-body { position: relative; }
.chain-key { max-width: none; margin: 0; padding: .7rem .9rem 0; font-size: var(--small); }
.chain-stage { position: relative; }
.chain-svg { display: block; width: 100%; height: auto; }
.chain-svg .st { transform: translate(calc(70px + var(--i) * 124px), calc(50px + var(--k) * 120px)); }
.chain-svg .n { display: none; }
.chain-svg .sh { fill: var(--ink); opacity: .17; }
.chain-svg .slab rect { stroke: var(--ink); stroke-width: 2.2; stroke-linejoin: round; }
.chain-svg .slab .t { fill: #E2E7EA; }  .chain-svg .slab .l { fill: #C6CFD6; }  .chain-svg .slab .r { fill: #AAB6BF; }
.chain-svg .ln { fill: #ECEFF1; }
.chain-svg .ln-line { fill: none; stroke: var(--line); stroke-width: 2; }
.chain-svg .chev { fill: none; stroke: var(--steel); stroke-width: 4; opacity: .6; }
.chain-svg .lk { fill: none; stroke: var(--ink); stroke-width: 2; }          /* the link from one block to the next */
.chain-svg path.ld { fill: none; stroke: var(--ink); stroke-width: 1.5; }
.chain-svg circle.ld { fill: var(--ink); }
.chain-svg .bk rect { stroke: var(--ink); stroke-width: 2; stroke-linejoin: round; transition: fill var(--t-control) linear; }
/* a block's three rects are its right face, its left face and its top */
.chain-svg .doc rect:nth-child(1) { fill: #CFD7DC; }
.chain-svg .doc rect:nth-child(2) { fill: #E3E8EB; }
.chain-svg .doc rect:nth-child(3) { fill: #F5F7F8; }
.chain-svg .chk rect:nth-child(1) { fill: #14502F; }
.chain-svg .chk rect:nth-child(2) { fill: #1A6641; }
.chain-svg .chk rect:nth-child(3) { fill: var(--green); }
.chain[data-still="2"] .ca .chk rect:nth-child(1) { fill: #74251B; }
.chain[data-still="2"] .ca .chk rect:nth-child(2) { fill: #932F23; }
.chain[data-still="2"] .ca .chk rect:nth-child(3) { fill: var(--red); }
/* a shell is sealed over its block, or lifted 38 above the floor: the same step back on both ground axes */
.chain-svg .sl { transform: translate(0, 0); transition: transform var(--t-scene) var(--ease); }
.chain[data-still="2"] .lift .sl { transform: translate(-38px, -38px); }
.chain.chain-cut * { transition: none !important; }   /* chain.js sets the first frame without a tween */
/* labels: upright text, set by the inverse of the ground matrix. A label is a link's name and, under it, its id. */
.chain-svg text { fill: var(--ink); }
.chain-svg .ls { font: 600 18px var(--body); }
.chain-svg .li { font: 500 16px var(--mono); }
.chain-svg .ca .lb { transform: translate(-12px, -84px) matrix(.57735, -.57735, 1, 1, 0, 0) translate(4px, -30px); }   /* stands on its leader, reads to the right */
.chain-svg .cb .lb { transform: translate(66px, 138px) matrix(.57735, -.57735, 1, 1, 0, 0) translate(-4px, 18px); text-anchor: end; }   /* hangs from its leader, ends at it: read to the right, a front label would cross the next leader (tried in review 8) */
@media (min-width: 56rem) { .chain-svg .ca .lb-claim { transform: translate(-12px, -84px) matrix(.57735, -.57735, 1, 1, 0, 0) translate(10px, -30px); } }   /* clear of its leader, which runs past the third line */
/* the claim block: C-4 as approved; from still 2 on C-11, with the claim it replaced under it in body type */
.chain-svg .c-sub { font: 400 15px var(--body); }
.chain[data-still="1"] .c-new, .chain:not([data-still="1"]) .c-old { display: none; }
/* the claim that changed is the cause of stills 2 and 3: its block keeps a heavy ink outline from still 2 on */
.chain:not([data-still="1"]) .ca .st:has(> .lb-claim) .bk rect { stroke-width: 3.4; }
/* above the drawing, under the plate's header: the button that steps, and the still in words. The sentence keeps room
   for its longest text, so the drawing under it never moves. */
.chain-ctl { display: grid; grid-template-columns: minmax(0, 1fr); gap: .75rem 1.5rem; align-items: start; padding: .85rem .9rem 1rem; border-bottom: 1px solid var(--line); }
.chain-ctl [hidden] { display: none; }
.chain-status { max-width: none; min-height: 4.4em; margin: 0; font-size: var(--small); line-height: 1.45; }   /* the count and three lines: still 2, the longest, at 48 to 56rem; no empty band under it */
.chain-step { display: block; font: 500 var(--mono-size)/1.6 var(--mono); }
.chain-name { font-weight: 600; }
.chain-next { justify-self: start; min-width: 12.5rem; }   /* wide enough for each of its labels */
@media (min-width: 48rem) { .chain-status { order: -1; } }   /* the words before the button, as in Fig. 1 */
.plate + p { margin-top: 1.5rem; }   /* text that follows a plate keeps the plate's distance */
@media (min-width: 56rem) {
  /* the key stands in the drawing's empty top right corner, under a short ink rule like the yard's */
  /* the key stands above the drawing at every width: in the top right corner it came within 8 px of the source label */
  /* the still's words first, the button after them on the right (review 6): the order of Fig. 1's control row */
  .chain-ctl { grid-template-columns: minmax(0, 1fr) auto; }
  .chain-status { grid-area: 1 / 1; max-width: 46rem; min-height: 5.95em; }   /* the count, then three lines for still 2 */
  .chain-next { grid-area: 1 / 2; }
}
@media (min-width: 72rem) {
  /* The plate is about 1020 px wide from here, so the sentence gets the full width beside the button, about 760 px.
     Still 2, the longest, then takes two lines (about 1400 of the 1520 px they hold), so the count and two lines are
     reserved: no empty band under the shorter stills, and still no jump between them. */
  .chain-status { max-width: none; min-height: calc(var(--mono-size) * 1.6 + 2.9em); }
}
@media (max-width: 55.99rem) {
  .chain-stage { aspect-ratio: 540 / 850; max-width: 30rem; margin-inline: auto; overflow: hidden; }   /* centred: no empty half at 768 */
  .chain-svg { position: absolute; left: 0; top: 0; width: calc(100% * 968 / 540); max-width: none; overflow: visible; }
  /* a link is 146 further down the page than the one before it; the second chain stands 264 to the right of the first */
  .chain-svg .st { transform: translate(calc(-101.4px + var(--i) * 146px + var(--k) * 152.4px), calc(113.4px + var(--i) * 146px - var(--k) * 152.4px)); }
  .chain-svg .ch-wide, .chain-svg .w { display: none; }
  .chain-svg .n { display: inline; }
  .chain-svg .bk rect { stroke-width: 2.4; }
  .chain-svg :is(.ca, .cb) .lb { transform: translate(38.3px, -26.3px) matrix(.57735, -.57735, 1, 1, 0, 0); text-anchor: start; }   /* to the right of its block */
  .chain-svg .ls { font-size: 19px; }
  .chain-svg .li { font-size: 18px; }
  .chain-svg .c-sub { font-size: 18px; }   /* 12 px at 390 */
}
@media (max-width: 47.99rem) {
  /* The chain is taller than a phone screen, so once the script has shown the button (.chain-live) the control row
     stays at the top of the screen for as long as the plate is in view: the button and the blocks it changes are seen
     together. Solid paper, a 1 px ink line under it. First row: the button with the count beside it; under them the
     still's name, with room for two lines so the drawing never moves. The sentence is not drawn here; it stays in the
     live region and is read out. In its place under the plate's header the row covers nothing. */
  .chain-live .chain-ctl { position: sticky; top: 0; z-index: 2; display: block; padding: .6rem .9rem .55rem; background: var(--paper); border-bottom-color: var(--ink); }
  .chain-live .chain-next { float: left; min-width: 11.5rem; margin-right: .9rem; }
  .chain-live .chain-status { min-height: 0; }
  .chain-live .chain-step { line-height: 3rem; white-space: nowrap; }   /* on the button's middle line */
  .chain-live .chain-name { display: block; clear: left; min-height: calc(2.9em + .45rem); padding-top: .45rem; }
  .chain-live .chain-say { position: absolute; width: 1px; height: 1px; margin: -1px; overflow: hidden; clip-path: inset(50%); white-space: nowrap; }
  /* the still's sentence is drawn under the sticky row, at small size, and scrolls away with the page */
  .chain-live .chain-say-out { display: block; min-height: calc(3 * 1.45em + 1.2rem); margin: 0; padding: .6rem .9rem; border-bottom: 1px solid var(--line); font-size: var(--small); line-height: 1.45; }
}
.chain-say-out { display: none; }

/* the gate-one sheet (Fig. 6): a document on paper. Quoted words in Hanken, the file's own field names and ids in mono,
   "…" where lines are left out. The requirement, then under a 2 px ink rule the plan, each across the plate's full
   width. From 64rem up both are set on the same two columns (24rem, then the rest): the requirement's four fields with
   outcome and workflow left, rules and acceptance right, on shared row lines; the plan with its title and words left
   and its mono lines right. Below that everything stacks in source order. The strip at the bottom is the only yellow in
   the section, with the gate's hazard edge: a person decides here. */
.sheet-part { padding: 1.25rem 1.25rem 1.5rem; }
.sheet-part + .sheet-part { border-top: 2px solid var(--ink); }
.sheet-part > h3 { margin: 0 0 .6rem; }
.sheet-title { margin: 0 0 .25rem; font: 600 1.1875rem/1.35 var(--body); }
.sheet-id {
  display: inline-block; margin-right: .45rem; padding: 0 .35rem; border: 1px solid var(--ink);
  font: 500 var(--mono-size)/1.5 var(--mono); white-space: nowrap; vertical-align: .12em;
}
/* the requirement's id, and beside it the page's own words: body type, 15 px, ink */
.sheet-tagline { display: flex; flex-wrap: wrap; align-items: baseline; gap: .2rem .25rem; margin: 0 0 .35rem; }
.sheet-tagline .sheet-id { vertical-align: 0; }
.sheet-tag { font: 400 var(--small)/1.45 var(--body); color: var(--ink); }
.sheet-req { margin: .9rem 0 0; }
.sheet-fields { margin: 0; }
.sheet-fields > div { display: grid; grid-template-columns: 6.25rem minmax(0, 1fr); gap: .2rem 1rem; padding-block: .55rem; border-top: 1px solid var(--line); }
.sheet-fields > div:last-child { border-bottom: 1px solid var(--line); }
.sheet-fields dt { padding-top: .2rem; font: 400 var(--mono-size)/1.5 var(--mono); }
.sheet-fields dd { max-width: var(--measure); margin: 0; }
.sheet-fields ul { margin: 0; padding-left: 1.1rem; }
.sheet-fields li + li { margin-top: .2rem; }
/* the workflow: four numbered steps, one per line at every width */
.sheet-flow { display: grid; gap: .2rem; margin: 0; padding: 0; list-style: none; counter-reset: flow; }
.sheet-flow li { counter-increment: flow; margin: 0; padding-left: 1.3rem; text-indent: -1.3rem; }
.sheet-flow li + li { margin-top: 0; }
.sheet-flow li::before { content: counter(flow); display: inline-block; width: 1.3rem; text-indent: 0; font: 500 var(--mono-size)/1 var(--mono); }
.sheet-fields .sheet-tests { padding-left: 0; list-style: none; }
.sheet-tests li + li { margin-top: .45rem; }
.sheet-mono { max-width: none; margin: .5rem 0 .9rem; padding: .55rem .75rem; background: var(--floor); font: 400 var(--mono-size)/1.6 var(--mono); white-space: pre-wrap; overflow-wrap: anywhere; }
.sheet-h { margin: 0 0 .2rem; font-weight: 600; }
/* the quoted sentence carries the file's ink rule at its left */
.sheet-words { margin: 0; padding: .1rem 0 .1rem .75rem; border-left: 2px solid var(--ink); }
.sheet-words p { margin: 0; }
.sheet .sheet-rev { margin: .9rem 0 0; font-weight: 500; }
/* under the revision, the page's own words: body type, 15 px, ink, outside the file's grey */
.sheet-rev-note { margin: .4rem 0 0; font: 400 var(--small)/1.45 var(--body); color: var(--ink); }
/* the plate's one footer, as in Fig. 4, under the yellow strip */
.sheet > .plate-note { border-top: 0; }
.sheet-ok {
  position: relative; max-width: none; margin: 0;
  padding: calc(12px + .75rem) 1.25rem .8rem;
  border-top: 2px solid var(--ink); background: var(--gate); color: var(--ink);
  font: 800 clamp(1.375rem, 3vw, 1.75rem)/1.05 var(--display);
}
.sheet-ok::before {
  content: ""; position: absolute; top: 0; left: 0; right: 0; height: 12px;
  background: repeating-linear-gradient(-45deg, var(--ink) 0 12px, var(--gate) 12px 24px);
}
@media (min-width: 64rem) {
  .sheet-part { padding: 1.5rem 1.5rem 1.6rem; }
  .sheet-req, .sheet-plan { display: grid; grid-template-columns: 24rem minmax(0, 1fr); column-gap: 3rem; }
  /* the requirement: one list of four fields on one grid. Row 1 holds outcome and rules, row 2 the workflow and the
     acceptance tests, so both columns start and end on the same lines. */
  .sheet-req > div { grid-template-columns: 5.5rem minmax(0, 1fr); column-gap: .75rem; align-content: start; }
  .sheet-req > .sf-outcome { grid-area: 1 / 1; }
  .sheet-req > .sf-rules { grid-area: 1 / 2; }
  .sheet-req > .sf-flow { grid-area: 2 / 1; border-bottom: 1px solid var(--line); }
  .sheet-req > .sf-acc { grid-area: 2 / 2; }
  /* the plan: the heading across, then title and words down the left. The file's lines stand right, top to bottom:
     goal and status beside the title, the revision, the page's note under it. The last row takes up any difference
     in height, so nothing can overlap. */
  .sheet-plan { grid-template-rows: auto auto auto auto 1fr; }
  .sheet-plan > h3 { grid-area: 1 / 1 / 2 / -1; }
  .sheet-plan > * { align-self: start; }
  .sheet-plan > .sheet-title { grid-area: 2 / 1; margin-bottom: .5rem; text-wrap: balance; }
  .sheet-plan > .sheet-said { grid-area: 3 / 1 / 6 / 2; }
  .sheet-plan > .sheet-mono { grid-column: 2; margin: 0; }
  .sheet-plan > pre.sheet-mono { grid-row: 2; }
  .sheet-plan > .sheet-rev { grid-row: 3; margin-top: .75rem; }
  .sheet-plan > .sheet-rev-note { grid-area: 4 / 2; }
}
@media (max-width: 40rem) {
  .sheet-part { padding: 1rem .75rem 1.25rem; }
  .sheet-fields > div { grid-template-columns: minmax(0, 1fr); }
  .sheet-fields dt { padding-top: 0; }
  .sheet-ok { padding-inline: .75rem; }
}

/* a link that leaves the page */
.go { display: inline-block; margin-top: .5rem; padding: .7rem 1.2rem; font-weight: 600; text-decoration: none; border: 2px solid var(--ink); transition: background-color var(--t-control) var(--ease); }
.go { transition: box-shadow var(--t-control) var(--ease); }
.go:hover { box-shadow: 3px 3px 0 var(--ink); }

/* laneboard, a light band: paper between two ink rules, like the floor's band at the top. The recordings are filmed
   in laneboard's light theme and stand in ordinary plates, so the screen reads as part of the page and not as a dark
   window in it (2026-11-20). No yellow in this band: nothing here is a gate; the recordings show laneboard's colours. */
.lane { background: var(--paper); border-block: 2px solid var(--ink); }
.lane > .wrap { padding-block: var(--section) calc(var(--section) * 1.25); }
.lane .plate-note { font-size: var(--text); }

/* the recording (Fig. 4): laneboard's demo, filmed twice. From 64rem up the plate shows the desk layout (.clip-wide,
   16:10), below it laneboard's own phone layout (.clip-phone, 2:3), so the words on screen can be read at either size.
   Only the one shown is ever loaded: preload is none, and the poster is a background (a hidden element loads none),
   set per figure below. The video fills the plate edge to edge at a fixed ratio, so nothing jumps when it loads; under
   it one row with the one button and what to expect, then what happens, in words.
   js/clips.js plays a recording only while it is in view and motion is on; with motion off the poster stands. */
.clip-lede { margin-top: 2.5rem; }
.clip > .plate-body { padding: 0; overflow: hidden; background: #FBFCFC; }   /* laneboard's light ground, while the poster loads */
.clip-v { display: block; width: 100%; height: auto; background: center / cover no-repeat; }
.clip-wide { aspect-ratio: 1440 / 900; }
.clip-phone { display: none; aspect-ratio: 640 / 960; }
#clip-gate .clip-wide { background-image: url(../media/laneboard-gate.jpg); }
/* below 64rem the desk recording would be shown at under 0.96 of its size and laneboard's mono text falls to 7 or 8 px:
   the phone recording stands there instead (review 6), on a tablet in a plate no wider than a phone's, centred */
@media (max-width: 63.99rem) {
  .clip-wide { display: none; }
  .clip-phone { display: block; }
  #clip-gate .clip-phone { background-image: url(../media/laneboard-gate-phone.jpg); }
}
@media (min-width: 40rem) and (max-width: 63.99rem) {
  .clip { max-width: 34rem; margin-inline: auto; }
}
/* framing, no new recording: from 64rem up the desk layout loses laneboard's grey status bar and the half row above it
   (60 of 900), so the frame ends between two rows. The left rail stays: cutting it would cut the top bar's words in half.
   Before the first play the poster stands at its own size, nothing cut, with a gate-yellow ring around Approve
   (.clip-ring, set by js/clips.js): a person's yes. In the last seconds of a play (.clip-push) the picture moves in
   1.3 times on Approve, which stays in place, the ring follows, and the frame's top, right and bottom edges fade
   out, so the lines it cuts read as a close-up and not a broken frame. */
.clip > .plate-body { position: relative; }
.clip-v { transition: transform calc(var(--t-scene) * 3) var(--ease), opacity var(--t-scene) linear; }
.clip-wide { transform-origin: 11.4% 72%; }
.clip-phone { transform-origin: 11.9% 58.1%; }
.clip-push .clip-v { transform: scale(1.3); }
.clip > .plate-body.clip-push {
  -webkit-mask-image: linear-gradient(to right, #000 92%, transparent), linear-gradient(to bottom, transparent, #000 5%, #000 94%, transparent);
  -webkit-mask-composite: source-in;
  mask-image: linear-gradient(to right, #000 92%, transparent), linear-gradient(to bottom, transparent, #000 5%, #000 94%, transparent);
  mask-composite: intersect;
}
.clip > .plate-body::after {
  content: ""; position: absolute; left: 4.2%; top: 55.7%; width: 14.6%; height: 4.9%; border: 3px solid var(--gate);
  box-shadow: 0 0 0 2px var(--ink); opacity: 0; transition: opacity calc(var(--t-scene) * 2) var(--ease); pointer-events: none;
}
.clip > .plate-body.clip-push::after { left: 1.9%; top: 55.1%; width: 20%; height: 6%; }
.clip > .plate-body:is(.clip-push, .clip-ring)::after { opacity: 1; transition-delay: calc(var(--t-scene) * .5); }   /* lands as the pointer reaches Approve */
/* the end (js/clips.js): after the held last frame the picture and the ring fade out, go back to the start unseen, and fade in */
.clip > .plate-body.clip-fade .clip-v { opacity: 0; }
.clip > .plate-body.clip-fade::after { opacity: 0; transition: opacity var(--t-scene) linear; }
.clip > .plate-body.clip-cut .clip-v, .clip > .plate-body.clip-cut::after { transition: none; }
@media (min-width: 64rem) {
  .clip > .plate-body { aspect-ratio: 1440 / 840; }
  /* Approve (122 to 206, 634 to 662 of 1440 x 900) with 6 px of air; moved in 1.3 times about its own middle when pushed */
  .clip > .plate-body::after { left: 8%; top: 74.8%; width: 6.7%; height: 4.8%; }
  .clip > .plate-body.clip-push::after { left: 6.8%; top: 73.6%; width: 9.2%; height: 6.6%; }
}
@media (min-width: 48rem) and (max-width: 63.99rem) {
  .clip { margin-inline: 0; }   /* the plate starts at the column's edge, in line with the heading and every other plate */
}
.clip-ctl { display: flex; flex-wrap: wrap; align-items: center; gap: .5rem 1rem; padding: .75rem .9rem; border-top: 2px solid var(--ink); }
.clip-ctl button {
  min-height: 3rem; min-width: 6.5rem; padding: 0 1.25rem; border: 2px solid var(--ink); border-radius: 0;
  background: transparent; color: var(--ink); font: 600 1rem/1.2 var(--body); cursor: pointer;
  transition: box-shadow var(--t-control) var(--ease);
}
.clip-ctl button:hover { box-shadow: 3px 3px 0 var(--ink); }
.clip-ctl button:active { box-shadow: none; }
.clip-meta { font-size: var(--small); }
.clip .plate-note p + p { margin-top: .5rem; }

/* the results */
.small { font-size: var(--small); color: var(--ink); }   /* small print a reader needs: ink, 15 px, the same as the yard plate's footer */
/* present for a screen reader, not drawn: the yard's numbers as a table */
.vh { position: absolute; width: 1px; height: 1px; margin: -1px; overflow: hidden; clip-path: inset(50%); white-space: nowrap; }

/* The yard (Fig. 4): the floor's drawing language, standing still. The view box is 1092 wide; a bay's place comes from
   its column --c and row --r. From 56rem up the eleven bays stand in one row on one slab. Below that they stand in rows
   of four on three slabs, each row 320 further along both ground axes, which on the page is straight down: the SVG is
   then drawn 1092 / 558 as wide as its stage, and the stage shows the left 558 units at the height the three rows need.
   Type sizes are in view box units and are chosen so that nothing is under 12 px at 390 px or at 56rem. */
.yard-body { position: relative; }
.yard-key { padding: .7rem .9rem 0; font-size: var(--small); }
.yard-key p { max-width: none; margin: 0; }
.yard-key .yard-now { margin-top: .75rem; padding: .6rem 0 .2rem; border-top: 2px solid var(--ink); font-size: 1.125rem; line-height: 1.45; }   /* the front end's size: in the figure at every width, under the legend */
.yard-stage { position: relative; }
.yard-svg { display: block; width: 100%; height: auto; }
.yard-svg .yb { transform: translate(calc(22px + (var(--c) + var(--r) * 4) * 88px), 22px); }
.yard-svg .yd-rows { display: none; }
.yard-svg .sh { fill: var(--ink); opacity: .17; }
.yard-svg .yd-slab rect { stroke: var(--ink); stroke-width: 2.2; stroke-linejoin: round; }
.yard-svg .yd-slab .t { fill: #E2E7EA; }  .yard-svg .yd-slab .l { fill: #C6CFD6; }  .yard-svg .yd-slab .r { fill: #AAB6BF; }
.yard-svg .yd-mark { fill: none; stroke: var(--steel); stroke-width: 2; }
.yard-svg .yd-none { fill: none; stroke: var(--ink); stroke-width: 1.8; stroke-dasharray: 6 5; }   /* dashes: not there */
.yard-svg .yd-chev { fill: none; stroke: var(--steel); stroke-width: 4; opacity: .85; }   /* it carries a fact (time between runs): 3.8:1 on the slab */
.yard-svg text { fill: var(--ink); text-anchor: middle; }
.yard-svg .yr { font: 600 17px var(--mono); fill: var(--ink); }   /* ink, and heavy enough to read as ink at 12 px */
.yard-svg .yn { font: 600 23px var(--body); }
.yard-svg .ync { font: 600 17px var(--body); }
@media (min-width: 56rem) {
  /* the key stands in the drawing's empty top right corner, under a short ink rule like the maker's */
  .yard-key { position: absolute; z-index: 1; top: 1rem; right: 1rem; width: 15.5rem; padding: .5rem 0 0; border-top: 2px solid var(--ink); }
  /* in one row, run 9's label would stand under the near corner of its dashed outline: 16 back along the lane it
     stands left of the corner, as far from the slab's edge as before, clear of every mark */
  .yard-svg .yl-9 { transform: translate(10px, 170px) matrix(.57735, -.57735, 1, 1, 0, 0); }
}
@media (max-width: 55.99rem) {
  .yard-stage { aspect-ratio: 558 / 1030; max-width: 30rem; margin-inline: auto; overflow: hidden; }   /* down to the last slab's shadow */
  .yard-svg { position: absolute; left: 0; top: 0; width: calc(100% * 1092 / 558); max-width: none; overflow: visible; }
  .yard-svg .yb { transform: translate(calc(22px + var(--c) * 88px + var(--r) * 320px), calc(22px + var(--r) * 320px)); }
  .yard-svg .yd-wide { display: none; }
  .yard-svg .yd-rows { display: inline; }
  .yard-svg .yr { font-size: 20px; }
  .yard-svg .yn { font-size: 26px; }
  /* both drawings say the same words: "not counted" stays under runs 9 and 11 (review 6). Run 9's pair stands as in the
     wide drawing; run 10's moves 12 down and right, so its own chevron, not run 9's, sits under it */
  .yard-svg .ync { font-size: 18px; }
  .yard-svg .yl-10 { transform: translate(30px, 182px) matrix(.57735, -.57735, 1, 1, 0, 0); }
}

/* the case study link at the end of the results */

/* the parts table */
table { width: 100%; border-collapse: collapse; margin-top: 1.5rem; background: var(--paper); }
caption { text-align: left; padding-bottom: .75rem; font-size: var(--small); }
th, td { text-align: left; vertical-align: top; padding: .7rem 1rem; border-bottom: 1px solid var(--line); }
thead th { font-weight: 600; font-size: .9rem; background: var(--floor); }
tbody th { font-weight: 600; width: 30%; }
@media (min-width: 48rem) { table:is(.parts, .rounds-tbl) tbody th { width: 13rem; } }   /* one- or two-word labels: the descriptions get the room */
table + p { margin-top: 1.5rem; }   /* the line after the parts table keeps its distance */

/* Fig. 10, one page of the toolbox cut to two things: the lesson and the ways a run ends. A document on paper, in ink
   only. No gate yellow, no check colours: nobody decides here and nothing ran here. The file's own headings are h4 in
   the heading face; its code words are mono on a floor-grey chip, as in Fig. 6. The lesson is what readers keep, so it
   is set a step larger than the table, and it stands first at every width. From 64rem up two columns in the file's
   order. The six-row table is the taller text, so it gets the wider column; with the lesson's larger type the two
   columns end close together and neither leaves a dead field. */
.tb-h { margin: 2.75rem 0 .6rem; }
.tb + p { margin-top: 1.5rem; }
.tb-body { display: grid; grid-template-columns: minmax(0, 1fr); padding: 1.25rem 1.25rem 1.5rem; overflow-wrap: anywhere; }
.tb-body p { margin: 0; }
.tb-body code { padding: 0 .25rem; background: var(--floor); font-size: var(--mono-size); overflow-wrap: anywhere; }
.tb-sec h4 { margin: 0 0 .5rem; font: 700 1.375rem/1.1 var(--display); text-wrap: balance; }
.tb-sec p + ul { margin-top: .6rem; }
.tb-col + .tb-col { margin-top: 1.5rem; padding-top: 1.25rem; border-top: 1px solid var(--line); }
/* one type size inside the sheet (review 5): every h4 22 px, the list and the table's cells at body size */
.tb-sec h4 { font-size: 1.375rem; }
.tb-lesson, .tb-table { font-size: var(--text); }
.tb-list { max-width: 44rem; margin: 0; padding: 0; list-style: none; }
.tb-list li { position: relative; padding-left: 1.75rem; }
.tb-list li + li { margin-top: .5rem; }
.tb-list li::before { content: ""; position: absolute; left: .25rem; top: .8em; width: .75rem; height: 2px; background: var(--ink); }   /* the site's one dash marker, as in .showed and .limits */
.tb-table { margin-top: .25rem; background: none; overflow-wrap: normal; }   /* "anywhere" would let the table's auto layout break a header mid-word */
.tb-table code { overflow-wrap: normal; }
.tb-table th, .tb-table td { padding: .55rem .75rem .55rem 0; }
.tb-table thead th { padding-left: 0; background: none; border-bottom: 2px solid var(--ink); font-size: var(--small); }
.tb-table tbody th { width: auto; font-weight: 400; white-space: nowrap; }
.tb-table thead th { white-space: nowrap; }
.tb-table td:last-child { padding-right: 0; }
.tb-body .tb-after { margin-top: 1rem; }
@media (min-width: 64rem) {
  /* the review/fix rule is a full-width block above the stop conditions, so neither leaves an empty panel */
  .tb-body { padding: 1.5rem 1.5rem 1.6rem; }
}
/* on the phone each table row is one stacked block: the code word, then its words */
@media (max-width: 40rem) {
  .tb-body { padding: 1rem .75rem 1.25rem; }
  .tb-table tr { padding: .6rem 0; }
  .tb-table tbody tr:first-child { border-top: 2px solid var(--ink); }
  .tb-table th, .tb-table td { width: auto; padding: 0; }
  .tb-table td { margin-top: .15rem; }
}

@media (max-width: 40rem) {
  .run { --rail: 1.1rem; --rail-pad: 2.25rem; }
  .plate { margin-inline: calc(var(--gutter) * -.5); }
  .plate-body { padding: .75rem; }
  table, tbody, tr, th, td { display: block; width: auto; }
  thead { display: none; }
  tr { padding: .8rem 1rem; border-bottom: 1px solid var(--line); }
  th, td, tbody th { padding: 0; border: 0; width: auto; }
}

/* closing, on bay: first person, plain. Text on bay is floor or line, never steel (too dim on the dark). */
.who, .foot { background: var(--bay); color: var(--floor); }
.who :focus-visible, .foot :focus-visible { outline-color: var(--paper); }
.who .wrap { padding-block: var(--section) calc(var(--section) * 1.5); }
/* stacked on a phone: the person first, then the reader's product. Two columns from 72rem up, parted by one steel line. */
.who-cols { display: grid; grid-template-columns: minmax(0, 1fr); gap: 2.75rem; }
/* "What a first run asks of you is at the end" lands on the second column: a little air above its heading when stacked,
   the top edge of the bay at the top of the screen when the columns stand side by side */
.who-run { scroll-margin-top: 1.5rem; }
@media (min-width: 72rem) {
  .who-cols { grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 0 3rem; align-items: start; }
  .who-run { padding-left: 3rem; border-left: 1px solid var(--steel-bay); scroll-margin-top: var(--section); }
}
.who h2 { color: var(--paper); }
.who h3 { margin: 2.25rem 0 1rem; font-size: var(--h3); color: var(--paper); text-wrap: balance; }
.who-run > h3 { margin-top: .35rem; }   /* its first line stands level with "Work with me" */
.who-lead { font-size: 1.25rem; line-height: 1.5; margin-bottom: .75rem; }
.who-lead + p { margin-bottom: 0; }
.who-lead a { font-weight: 600; text-decoration-color: var(--line); }
.who-lead a:hover { text-decoration-color: var(--floor); }

/* why write: three reasons, each a number in the heading face and a line of text, parted by thin steel rules.
   No box in front of them, so nothing looks tickable. */
.reasons { list-style: none; counter-reset: reason; padding: 0; margin: 0; max-width: var(--measure); border-bottom: 1px solid var(--steel-bay); }
.reasons li { counter-increment: reason; position: relative; padding: .6rem 0 .65rem 2.25rem; border-top: 1px solid var(--steel-bay); }
.reasons li::before { content: counter(reason); position: absolute; left: 0; top: .6rem; font: 700 1.35rem/1.7rem var(--display); color: var(--paper); }

/* the one line that covers all six moments: they are the design, and the status table holds how far each part has run */
.ask-after { margin: 1.25rem 0 0; color: var(--paper); }
.ask-lead { margin: -.25rem 0 1.5rem; color: var(--paper); }
.ask-lead a { text-decoration-color: var(--line); }
.ask-lead a:hover { text-decoration-color: var(--floor); }

/* a first run: six numbered moments on one rail. The two a person decides are yellow, as at the gates. */
.ask { --dot: 2.25rem; list-style: none; counter-reset: ask; padding: 0; margin: 0; max-width: var(--measure); }
.ask li { counter-increment: ask; position: relative; z-index: 0; min-height: var(--dot); padding: .3rem 0 1.25rem calc(var(--dot) + 1rem); }
.ask li:last-child { padding-bottom: 0; }
.ask li::before {
  content: counter(ask); position: absolute; left: 0; top: 0; width: var(--dot); height: var(--dot);
  border: 2px solid var(--line); border-radius: 50%; background: var(--bay); color: var(--paper);
  font: 800 1.2rem/calc(var(--dot) - 4px) var(--display); text-align: center;
}
.ask li:not(:last-child)::after {   /* the rail from one moment to the next */
  content: ""; position: absolute; z-index: -1; left: calc(var(--dot) / 2 - 1px); top: var(--dot); bottom: 0; border-left: 2px solid var(--steel-bay);
}
.ask li.you::before { background: var(--gate); border-color: var(--gate); color: var(--ink); }
.ask .tag { display: inline-block; margin-right: .4rem; padding: 0 .45rem; background: var(--gate); color: var(--ink); font: 600 .875rem/1.6 var(--body); vertical-align: .08em; }


/* The way to Marcel: yellow, because writing is a person's decision; the other link is the page's one outline style, in
   light on bay. The top bar's link goes to the same address. */
/* The two links share one height, one type size and one baseline at every width: side by side, stretched to the
   taller one, the words centred in each. On a phone they split the row in two and may wrap to two lines each. */
.act { display: flex; flex-wrap: wrap; align-items: stretch; gap: .75rem 1rem; margin-top: 2.25rem; }
.act a {
  display: inline-flex; align-items: center; justify-content: center; min-height: 3.5rem; padding: .5rem 1.6rem;
  border: 2px solid var(--floor); color: var(--floor); font-size: 1.125rem; font-weight: 600; line-height: 1.25;
  text-align: center; text-decoration: none; text-wrap: balance;
  transition: box-shadow var(--t-control) var(--ease);
}
.act a.main { border-color: var(--gate); background: var(--gate); color: var(--ink); }
.act a:hover { box-shadow: 4px 4px 0 var(--steel-bay); }
.act a:active { box-shadow: none; }
.act p { flex: none; width: 100%; margin: 0; color: var(--paper); font-size: var(--small); }   /* under the two links */
@media (max-width: 40rem) {
  .act { flex-direction: column; }
  .act a { width: 100%; padding-inline: .75rem; font-size: var(--text); }
}

/* footer: the mark, the date and the two ways out as plain text links, nothing promised */
.foot { border-top: 1px solid var(--steel-bay); }
.foot a:hover { text-decoration-color: var(--line); }   /* steel is too dim on bay */
.foot .wrap { display: flex; flex-wrap: wrap; align-items: baseline; gap: .5rem 1.5rem; padding-block: 1.5rem 2rem; }
.foot .wordmark { color: var(--paper); }
.foot .mark { outline: 1px solid var(--steel-bay); }  /* the ink square needs an edge on the dark ground */
.foot p { margin: 0; color: var(--paper); font-size: var(--small); }
.foot-links { display: flex; gap: 1.5rem; }
/* a thumb-sized target: 11 + 22 + 11 = 44 px high, at least 44 px wide, same type and colour */
.foot-links a { display: inline-block; min-width: 44px; padding: 11px 0; line-height: 22px; text-align: center; color: var(--floor); }
.foot-links a:focus-visible { outline: 3px solid var(--paper); outline-offset: 2px; }
@media (min-width: 40.0625rem) { .foot-links { margin-left: auto; } }

/* the timeline (Fig. 2): five dated stations on one rail, left to right from 48rem up, top to bottom below */
.grew { padding-block: 0 var(--section); }
.tl { list-style: none; margin: 0; padding: 1rem .9rem 1.1rem; display: grid; grid-template-columns: minmax(0, 1fr); gap: 0; }
.tl li { position: relative; padding: 0 0 1rem 1.75rem; border-left: 3px solid var(--ink); margin-left: .5rem; }
.tl li:last-child { padding-bottom: 0; border-left-color: transparent; }
.tl li::before { content: ""; position: absolute; left: -.6rem; top: .2rem; width: .9rem; height: .9rem; border: 3px solid var(--ink); border-radius: 50%; background: var(--paper); }
.tl li.tl-f::before { background: var(--ink); }
.tl-d { display: block; font: 500 var(--mono-size)/1.5 var(--mono); }
.tl-t { display: block; font-weight: 600; line-height: 1.3; }
.tl-s { display: block; font-size: var(--small); line-height: 1.45; }
@media (min-width: 48rem) {
  .tl { grid-template-columns: repeat(5, minmax(0, 1fr)); column-gap: 1.25rem; padding: 1.1rem 1.1rem 1.2rem; }
  .tl li { margin: 0; padding: 1.6rem 0 0; border-left: 0; border-top: 3px solid var(--ink); }
  .tl li:last-child { border-top-color: var(--ink); }
  .tl li::before { left: 0; top: -.6rem; }
}

/* depth on demand: a disclosure styled as a plate's footer row, an ink rule above, a plus that turns into a minus */
.more { max-width: none; margin: 1.5rem 0 0; border-top: 2px solid var(--ink); }
.more > summary { display: flex; align-items: center; gap: .6rem; min-height: 3rem; padding: .5rem 0; cursor: pointer; font-weight: 600; list-style: none; }
.more > summary::-webkit-details-marker { display: none; }
/* the plus and the minus are drawn: two bars 2 px thick and 10 px long, the upright one gone when open */
.more > summary::before {
  content: ""; flex: none; width: 1.5rem; height: 1.5rem; border: 2px solid var(--ink);
  background: linear-gradient(currentColor, currentColor) center / 10px 2px no-repeat, linear-gradient(currentColor, currentColor) center / 2px 10px no-repeat;
}
.more[open] > summary::before { background: linear-gradient(currentColor, currentColor) center / 10px 2px no-repeat; }
.more > summary:hover { text-decoration: underline; text-decoration-thickness: 2px; text-underline-offset: 3px; }
.more-in { padding: .25rem 0 .5rem; }
.more-in > :last-child { margin-bottom: 0; }
.who .more { border-top-color: var(--line); }
.who .more > summary::before { border-color: var(--line); }

/* the run report (Fig. 5): a document on paper, redacted. Label left, value right, mono for the record's own words */
.rr-body { padding: 1rem 1.1rem 1.2rem; display: grid; grid-template-columns: minmax(0, 1fr); gap: 1.25rem; }
.rr-body h3 { margin: 0 0 .5rem; font-size: 1.25rem; }
.rr { margin: 0; }
.rr > div { display: grid; grid-template-columns: 8.5rem minmax(0, 1fr); gap: .2rem 1rem; padding-block: .45rem; border-top: 1px solid var(--line); }
.rr > div:last-child { border-bottom: 1px solid var(--line); }
.rr dt { font: 400 var(--mono-size)/1.6 var(--mono); padding-top: .1rem; }
.rr dd { margin: 0; }
.rr code { padding: 0 .25rem; background: var(--floor); }
@media (min-width: 64rem) {
  .rr-body { grid-template-columns: minmax(0, 1fr) minmax(0, 1fr); column-gap: 2.5rem; padding: 1.25rem 1.5rem 1.4rem; align-items: start; }
}
@media (max-width: 40rem) { .rr > div { grid-template-columns: minmax(0, 1fr); } }
/* a run record's two lists, stacked below 64rem, read as one: no gap and no second rule between them (review 6) */
@media (max-width: 63.99rem) { .rec-sum { row-gap: 0; } .rec-sum > .rr + .rr > div:first-child { border-top: 0; } }


/* A comparison (Fig. 3, the checks pair): one table, a mono label column and two even value columns, so every row
   lines up across both. Below 40rem each row is a block: the label, then each value under its own name (data-run). */
.cmp-wrap { padding: 1rem 1.1rem 1.2rem; }
.cmp { margin: 0; background: none; table-layout: fixed; }
.cmp th, .cmp td { padding: .55rem 1.25rem .6rem 0; }
.cmp th { text-wrap: pretty; }
.cmp td:last-child { padding-right: 0; }
.cmp thead th { padding-bottom: .5rem; background: none; border-bottom: 2px solid var(--ink); font: 700 1.25rem/1.15 var(--display); text-wrap: balance; vertical-align: bottom; }
.cmp thead td { width: 9rem; border-bottom: 2px solid var(--ink); background: none; }
.cmp tbody th { width: auto; padding-top: .7rem; font: 400 var(--mono-size)/1.5 var(--mono); }
.cmp-sub { display: block; margin-top: .2rem; color: var(--steel); }
.cmp code { padding: 0 .25rem; background: var(--floor); }
@media (min-width: 64rem) {
  .cmp-wrap { padding: 1.25rem 1.5rem 1.4rem; }
  .cmp th, .cmp td { padding-right: 2rem; }
  .cmp thead td { width: 10rem; }
}
@media (max-width: 40rem) {
  .cmp-wrap { padding: .25rem .75rem .75rem; }
  .cmp tr { padding: .7rem 0; }
  .cmp tbody tr + tr { border-top: 1px solid var(--line); }
  .cmp tbody th { padding: 0 0 .2rem; }
  .cmp td { padding: .35rem 0 0; }
  .cmp td::before { content: attr(data-run); display: block; font: 600 var(--small)/1.4 var(--body); }
  .cmp-sub { display: inline; margin: 0 0 0 .4rem; }
}
/* the time bars: flat fills (stripes belong to the gates), on one minute scale across the runs: a track of 397 minutes
   (the longer run's working time) leaves 4.5rem for the total after the bar. The two parts are named in a key under it. */
.rr-time { display: flex; align-items: center; gap: .5rem; margin: .1rem 0 .3rem; }
.rr-bar { display: flex; flex: none; width: calc((100% - 4.5rem) * var(--m) / 397); height: 1.5rem; border: 2px solid var(--ink); }
.rr-bar span { display: block; height: 100%; }
.rr-bar .rr-chk { background: var(--steel); }
.rr-bar .rr-ag { background: var(--arc); border-left: 2px solid var(--ink); }   /* arc blue: an agent round, as in Fig. 1 and the run record */
.rr-sum { font: 600 var(--mono-size)/1.2 var(--mono); white-space: nowrap; }
.rr-key { display: flex; flex-wrap: wrap; gap: .1rem 1rem; margin-bottom: .35rem; font: 400 var(--mono-size)/1.5 var(--mono); }
.rr-k { display: inline-flex; align-items: center; gap: .35rem; white-space: nowrap; }
.rr-k::before { content: ""; width: .75rem; height: .75rem; border: 2px solid var(--ink); }
.rr-k-chk::before { background: var(--steel); }
.rr-k-ag::before { background: var(--arc); }

/* the failures that shaped foundry: three short stories side by side from 64rem up, in equal columns */
.stories { list-style: none; margin: 1.5rem 0 0; padding: 0; display: grid; gap: 1.5rem; }
.stories li { border-top: 3px solid var(--ink); padding-top: .75rem; }
.stories :is(h3, h4) { margin: 0 0 .5rem; font: 700 1.25rem/1.1 var(--display); text-wrap: balance; }   /* a card's head: 20 px, as the heads inside figures */
.stories p { margin: 0 0 .6rem; }
.stories p:last-child { margin-bottom: 0; }
@media (min-width: 64rem) { .stories { grid-template-columns: repeat(3, minmax(0, 1fr)); column-gap: 2rem; align-items: start; } }   /* three peers (review 8, round 2) */
.stories p { text-wrap: pretty; }   /* three stories, three columns: no hole */

/* a published run record (runs/*.html): the summary as in Fig. 5, then every event as a table. Below 56rem each event is a
   block of its own, so nothing is wider than the screen. */
.rec-page main { padding-top: 1rem; }
.rec-h { font-size: var(--h2); line-height: 1; margin: 0 0 1rem; overflow-wrap: anywhere; }
.rec-h2 { margin-top: 2.5rem; font-size: 2rem; }
.rec-page .plate-head .plate-no { overflow-wrap: anywhere; white-space: normal; }
.rec { margin-top: 1rem; font-size: var(--small); }
.rec th, .rec td { padding: .4rem .75rem .4rem 0; }
.rec td.ev-t, .rec td.ev-p, .rec td.ev-n { font: 400 var(--mono-size)/1.6 var(--mono); white-space: nowrap; }
.rec td:nth-child(3) { padding-left: .6rem; }   /* every row: the check rule sits in this padding, so all event words start on one line */
.rec tr.ev-red td:nth-child(3) { box-shadow: inset 4px 0 0 var(--red); }
.rec tr.ev-ok td:nth-child(3) { box-shadow: inset 4px 0 0 var(--green); }
.rec tr.ev-gate td:nth-child(3) { font-weight: 600; }
.rec-back { margin-top: 1.5rem; }
@media (max-width: 47.99rem) {
  .rec thead { display: none; }
  .rec, .rec tbody, .rec tr { display: block; }
  .rec tr { padding: .4rem 0; border-bottom: 1px solid var(--line); }
  .rec td { display: inline; padding: 0 .5rem 0 0; border: 0; }
  .rec td:nth-child(3) { display: block; }
  .rec td:empty { display: none; }
  .rec td.ev-p::after { content: " min"; }
}

/* review 4: the tally of every build run (a table of label and value, no head), what the runs showed, what the loop
   decides on its own (both lists of short paragraphs under an ink dash), and the design page's numbered conditions */
.runs-tally { max-width: none; margin-top: .25rem; font-variant-numeric: tabular-nums; }   /* to the figures' right edge, the second of the two (review 8) */
.runs-tally th { width: 14rem; }
.runs-tally { border-top: 2px solid var(--ink); }
:is(.showed, .limits) { list-style: none; max-width: var(--measure); margin: 0 0 1.5rem; padding: 0; }
:is(.showed, .limits) li { position: relative; padding-left: 1.75rem; }
:is(.showed, .limits) li + li { margin-top: .75rem; }
:is(.showed, .limits) li::before { content: ""; position: absolute; left: .25rem; top: .8em; width: .75rem; height: 2px; background: var(--ink); }
.limits strong { font-weight: 600; }
.limits a { font-weight: 600; white-space: nowrap; }
ol.plain { max-width: var(--measure); margin: 0 0 1em; padding-left: 1.75rem; }   /* text starts where the dash lists' text starts */
ol.plain li + li { margin-top: .35rem; }
ol.plain li::marker { font: 500 var(--mono-size) var(--mono); }
@media (max-width: 40rem) { .runs-tally th { margin-bottom: .15rem; } }

/* the design page (main.design): section heads a step below the main page's chapters, and a list of its thirteen
   sections, under the lede in columns at every width. Until review 6 it was a sticky rail right of the text from 75rem
   up; that held every figure to 736 px at 1400, smaller than at 1024, so the rail is gone and the plates span the grid. */
.design .part > h2 { font-size: clamp(2rem, 3.6vw, 3rem); margin-bottom: 1rem; }
.design .part { padding-block: clamp(2rem, 3.5vw, 2.5rem); }
.toc + .part::before { content: ""; position: absolute; top: 0; left: var(--gutter); right: var(--gutter); border-top: 1px solid var(--line); }
.toc { padding-bottom: 1.5rem; }
.toc-h { margin: 0 0 .4rem; font: 500 var(--mono-size)/1.45 var(--mono); }
/* three groups (review 8, round 2): the loop, what lies under it, and the evidence, each under a mono label */
.toc-cols { display: grid; grid-template-columns: minmax(0, 1fr); gap: .75rem 2rem; border-top: 2px solid var(--ink); padding-top: .5rem; }
@media (min-width: 48rem) { .toc-cols { grid-template-columns: repeat(3, minmax(0, 1fr)); } }
.toc-gh { margin: 0 0 .1rem; font: 600 var(--mono-size)/1.45 var(--mono); }
.toc ol { list-style: none; margin: 0; padding: 0; }
.toc li { break-inside: avoid; font-size: var(--small); line-height: 1.35; }
.toc a { display: block; padding: .3rem 0 .3rem .75rem; margin-left: -.75rem; border-left: 3px solid transparent; text-decoration: none; }
.toc a:hover { text-decoration: underline; }
.toc a[aria-current="true"] { border-left-color: var(--ink); font-weight: 600; }
@media (max-width: 40rem) { .toc a { padding-block: .55rem; } }
/* six links in the top bar: on a phone they come a little closer, so "Home" to "Stops" fit across 390 px */
@media (max-width: 47.99rem) { .top nav:has(> a:nth-child(6)) a { min-width: 40px; padding-inline: .3rem; } }
@media (max-width: 23.99rem) { .top nav:has(> a:nth-child(6)) a:nth-child(5) { display: none; } }   /* under 384 px "Parts" goes; the list under the lede has it */   /* thumb-sized rows on a phone */
