/* Bonnie Plants deck.
   Standalone. Nothing here links to another Parallel Path page or stylesheet.
   Every slide is drawn at 1920 by 1080, the size of the Figma Slides file,
   and scales to the screen. Write a size as calc(N * var(--u)), where N is
   the pixel value from Figma. */

/* ---------- FONTS ----------
   IBM Plex, bundled so the deck runs offline. Latin set only.
   Open Font License in assets/fonts/OFL.txt. */
@font-face { font-family: "IBM Plex Sans"; font-weight: 400; font-style: normal; font-display: swap;
  src: url("../fonts/ibm-plex-sans-latin-400-normal.woff2") format("woff2"); }
@font-face { font-family: "IBM Plex Sans"; font-weight: 500; font-style: normal; font-display: swap;
  src: url("../fonts/ibm-plex-sans-latin-500-normal.woff2") format("woff2"); }
@font-face { font-family: "IBM Plex Sans"; font-weight: 600; font-style: normal; font-display: swap;
  src: url("../fonts/ibm-plex-sans-latin-600-normal.woff2") format("woff2"); }
@font-face { font-family: "IBM Plex Serif"; font-weight: 300; font-style: normal; font-display: swap;
  src: url("../fonts/ibm-plex-serif-latin-300-normal.woff2") format("woff2"); }
@font-face { font-family: "IBM Plex Serif"; font-weight: 300; font-style: italic; font-display: swap;
  src: url("../fonts/ibm-plex-serif-latin-300-italic.woff2") format("woff2"); }

/* ---------- TOKENS ---------- */
:root {
  /* Parallel Path brand colors. Brand kit names in brackets. */
  --night:  #151515;
  --jet:    #333333;
  --dove:   #666666;
  --linen:  #F6EDE6;
  --slate:  #233D4D;  /* Cadet */
  --teal:   #3C6E71;  /* Current. Only on "From seed to sprout." */
  --lime:   #C6EB4C;  /* Spring. Dark grounds only, on whole elements. */
  --coral:  #E1885E;  /* Up next slides */
  --sand:   #D0A684;
  --oat:    #E6DACB;  /* Placeholder blocks and tiles */

  --serif: "IBM Plex Serif", Georgia, serif;
  --sans:  "IBM Plex Sans", system-ui, sans-serif;

  /* One Figma pixel. Resolves against the slide it sits in. */
  --u: calc(100cqw / 1920);

  /* Motion. Every move in the deck reads these, so tune it here.
     One curve, an ease-out that never overshoots. Two speeds. */
  --move-ease:    cubic-bezier(0.22, 0.61, 0.36, 1);
  --move-fast:    500ms;  /* fade, rise, dim, and the pause after a build */
  --move-slow:    800ms;  /* draw */
  --move-stagger: 90ms;   /* between the children of a build */
  --move-travel:  12;     /* how far rise travels, in Figma pixels */
  --move-dim:     40;     /* percent of the ink a dimmed element keeps */
  --move-cut:     300ms;  /* the dissolve between slides. 0ms is a hard cut */

  /* The frame. Content lives between --top and --bottom, inside --side. */
  --side:   calc(48 * var(--u));
  --top:    calc(100 * var(--u));
  --bottom: calc(80 * var(--u));
}

/* ---------- PAGE ---------- */
html { background: var(--night); }
body {
  margin: 0;
  background: var(--night);
  font-family: var(--sans);
  -webkit-font-smoothing: antialiased;
  text-rendering: optimizeLegibility;
}
* { box-sizing: border-box; }
img, video { display: block; max-width: 100%; }

/* ---------- SLIDE ---------- */
.slide {
  position: relative;
  container-type: inline-size;
  overflow: hidden;
  background: var(--bg);
  color: var(--ink);
  --bg: var(--linen);
  --ink: var(--slate);
  --mark: var(--slate);
}
.slide * { margin: 0; }

/* Grounds. Light grounds take Slate ink. Dark grounds take Linen ink,
   with Lime marking the current section. */
.ground-linen   { --bg: var(--linen); --ink: var(--slate); --mark: var(--slate); }
.ground-lime    { --bg: var(--lime);  --ink: var(--slate); --mark: var(--slate); }
.ground-coral   { --bg: var(--coral); --ink: var(--slate); --mark: var(--slate); }
.ground-night   { --bg: var(--night); --ink: var(--linen); --mark: var(--lime); }
.ground-slate   { --bg: var(--slate); --ink: var(--linen); --mark: var(--lime); }
.ground-teal    { --bg: var(--teal);  --ink: var(--linen); --mark: var(--lime); }

/* On a dark ground, mark the current section in Linen instead of Lime.
   Used over full-bleed photos and on the numbered divider. */
.mark-ink { --mark: var(--ink); }

/* Not presenting: a narrow screen, or the page before the script runs.
   The slides stack as a plain run. */
.deck { padding: 16px 0; }
.deck .slide {
  width: min(100% - 32px, 1600px);
  aspect-ratio: 16 / 9;
  margin: 0 auto 16px;
}

/* Presenting: one slide at a time, as large as the screen allows. */
.deck.is-live { padding: 0; }
.deck.is-live .slide {
  display: none;
  position: fixed;
  inset: 0;
  margin: auto;
  width: min(100vw, 100vh * 16 / 9);
  height: min(100vh, 100vw * 9 / 16);
  aspect-ratio: auto;
}
.deck.is-live .slide.is-on { display: block; }

/* The content area inside the frame. */
.slide-area {
  position: absolute;
  top: var(--top);
  right: var(--side);
  bottom: var(--bottom);
  left: var(--side);
}

/* Place anything by its Figma position and size:
   <div class="at" style="--x: 48; --y: 150; --w: 1180; --h: 664">.
   Leave out --w or --h to let it size itself. */
.at {
  position: absolute;
  left: calc(var(--x, 0) * var(--u));
  top: calc(var(--y, 0) * var(--u));
  width: calc(var(--w) * var(--u));
  height: calc(var(--h) * var(--u));
  /* A word too long for its box breaks, as it does in Figma. */
  overflow-wrap: break-word;
}
/* Measure from the right edge instead, for a line set flush right:
   <p class="at from-right" style="--r: 40; --y: 552">. */
.at.from-right {
  left: auto;
  right: calc(var(--r, 0) * var(--u));
  text-align: right;
}
/* Tight letter-spacing also pulls in after the last letter, which lets
   that letter hang past the edge. --trail, set by each type class, takes
   it back, so a line set flush right or centered lands where it does in
   Figma. */
.at.from-right { margin-right: var(--trail, 0em); }
.at.center { padding-right: var(--trail, 0em); }

/* ---------- FRAME ----------
   Written by deck.js on every slide from the data on .deck and each
   .chapter. Never write it by hand. */
.frame-top {
  position: absolute;
  top: calc(30 * var(--u));
  left: var(--side);
  right: var(--side);
  display: grid;
  grid-template-columns: repeat(5, 1fr);
}
.frame-strip {
  position: absolute;
  top: calc(1041 * var(--u));
  left: var(--side);
  right: var(--side);
  display: flex;
  align-items: center;
}
.frame-strip ol {
  display: flex;
  justify-content: space-between;
  width: calc(1764 * var(--u));
  padding: 0;
  list-style: none;
}
.frame-strip li {
  position: relative;
  white-space: pre;
  color: color-mix(in srgb, var(--ink) 45%, transparent);
}
.frame-strip li.on {
  color: var(--mark);
  transform: translateX(calc(16 * var(--u)));
}
.frame-strip li.on::before {
  content: "";
  position: absolute;
  left: calc(-16 * var(--u));
  top: 50%;
  width: calc(8 * var(--u));
  height: calc(8 * var(--u));
  border-radius: 50%;
  background: currentColor;
  transform: translateY(-50%);
}
.frame-page { margin-left: auto; }

/* A section name in the strip is a link to that section's first slide.
   At rest it looks like the plain text it replaced. The padding only
   widens where a click lands, and the margin takes it back so nothing
   shifts. With the pointer or the keyboard on it, a name goes to full
   ink. The current section's name does not change. */
.frame-strip a {
  padding: calc(12 * var(--u)) calc(8 * var(--u));
  margin: calc(-12 * var(--u)) calc(-8 * var(--u));
  color: inherit;
  text-decoration: none;
  outline: none;
}
@media screen {
  .frame-strip li:not(.on) a:hover,
  .frame-strip li:not(.on) a:focus-visible,
  .frame-strip li:not(.on) a.is-lit { color: var(--ink); }
}

/* A slide with data-over has a block of another color running under part
   of the frame, such as a half-width photo. deck.js writes a second copy
   of the frame for that part, in --over-ink, and clips the two copies
   where the block ends. */
.frame-top.is-over,
.frame-strip.is-over {
  --ink: var(--over-ink, var(--linen));
  --mark: var(--over-ink, var(--linen));
  color: var(--ink);
}

/* ---------- TYPE ----------
   Class names match the text styles in the Figma file. */
.display-1, .display-2, .display-3, .display-4, .display-5, .display-6, .quote {
  font-family: var(--serif);
  font-weight: 300;
  line-height: 0.98;
  letter-spacing: -0.03em;
  /* Browsers drop the fi and fl ligatures once type is letter-spaced.
     Figma keeps them, so ask for them by name. */
  font-feature-settings: "liga" 1;
  --trail: 0.03em;
}
.display-1 { font-size: calc(216 * var(--u)); }
.display-2 { font-size: calc(168 * var(--u)); }
.display-3 { font-size: calc(136 * var(--u)); }
.display-4 { font-size: calc(104 * var(--u)); }
.display-5 { font-size: calc(68 * var(--u)); }
.display-6 { font-size: calc(42 * var(--u)); }
.quote     { font-size: calc(136 * var(--u)); font-style: italic; }

.lead          { font: 500 calc(40 * var(--u)) / 1.2 var(--sans); letter-spacing: -0.01em; font-feature-settings: "liga" 1; --trail: 0.01em; }
.subhead       { font: 500 calc(30 * var(--u)) / 1.34 var(--sans); letter-spacing: -0.01em; font-feature-settings: "liga" 1; --trail: 0.01em; }
.small-heading { font: 500 calc(20 * var(--u)) / 1.34 var(--sans); }
.body-large    { font: 400 calc(36 * var(--u)) / 1.24 var(--sans); }
.body          { font: 400 calc(26 * var(--u)) / 1.34 var(--sans); }
.body-small    { font: 400 calc(24 * var(--u)) / 1.34 var(--sans); }
.label,
.frame-top, .frame-strip {
  font: 600 calc(12 * var(--u)) / 1.34 var(--sans);
  letter-spacing: 0.08em;
  text-transform: uppercase;
}

/* Secondary text, such as a name under a quote. The ink at 60 percent.
   For another strength, set --tone: <p class="muted" style="--tone: 35">. */
.muted { color: color-mix(in srgb, var(--ink) calc(var(--tone, 60) * 1%), transparent); }

/* Text helpers. */
.nowrap { white-space: nowrap; }
.center { text-align: center; }
.in-lime  { color: var(--lime); }
.in-linen { color: var(--linen); }
.in-night { color: var(--night); }
.in-slate { color: var(--slate); }

/* ---------- BLOCKS ----------
   Everything here is placed with .at. */

/* A hairline between rows, 2 thick unless --h says otherwise.
   .soft is the lighter one inside a group. .upright runs top to bottom. */
.rule { height: calc(var(--h, 2) * var(--u)); background: var(--ink); }
.rule.soft { opacity: 0.3; }
.rule.upright { width: calc(2 * var(--u)); height: calc(var(--h) * var(--u)); }

/* A row that links to another page: an <a class="row-link"> around the
   row's rule and its label. The rule and the label keep their own .at
   positions, so wrapping them moves nothing. At rest the row looks like
   any other, with a small angled arrow after the label. Under the
   pointer or keyboard focus the rule darkens. No underline. The label's
   padding joins it to the rule 20 above, so the whole row takes the
   click, and the margin takes the padding back. Print shows plain text. */
.row-link { color: inherit; text-decoration: none; outline: none; }
@media screen {
  .row-link > p {
    padding: calc(20 * var(--u)) 0;
    margin: calc(-20 * var(--u)) 0;
    cursor: pointer;
  }
  .row-link > p::after {
    content: "";
    display: inline-block;
    width: 0.56em;
    height: 0.56em;
    margin-left: 0.36em;
    background: currentColor;
    -webkit-mask: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 12 12' fill='none' stroke='%23000' stroke-width='1.5'%3E%3Cpath d='M1.5 10.5l9-9M3.5 1.5h7v7'/%3E%3C/svg%3E") center / contain no-repeat;
            mask: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 12 12' fill='none' stroke='%23000' stroke-width='1.5'%3E%3Cpath d='M1.5 10.5l9-9M3.5 1.5h7v7'/%3E%3C/svg%3E") center / contain no-repeat;
  }
  .row-link:hover .rule,
  .row-link:focus-visible .rule { background: color-mix(in srgb, var(--ink), #000 55%); }
}

/* A photo. It fills its box and crops to fit. A box wider than the
   slide is fine: the slide trims what runs past its edges. */
.photo { object-fit: cover; }
img.at { max-width: none; }

/* A photo shown through a tighter crop than its box. The img inside
   carries the crop as percentages of the box. */
.crop { overflow: hidden; }
.crop > img { position: absolute; max-width: none; }

/* A dark wash over a photo so type on top stays readable. */
.shade { background: color-mix(in srgb, var(--night) 28%, transparent); }

/* Where an image, chart or screenshot goes once it exists. The label
   inside says what belongs there. Replace the whole block with the
   image: <img class="photo at" src="assets/img/file.jpg" alt="" style="...">.
   .is-coral is the two-thirds block. It runs under the top line, so its
   label starts 100 down. .is-tint is for dark and Lime grounds. */
.placeholder {
  padding: calc(24 * var(--u));
  background: var(--fill, var(--oat));
  color: var(--slate);
}
.placeholder.is-coral { --fill: var(--coral); padding-top: calc(100 * var(--u)); }
.placeholder.is-tint  { --fill: color-mix(in srgb, var(--ink) calc(var(--tint, 12) * 1%), transparent); color: var(--ink); }

/* A flat panel behind a title and a line. */
.tile { background: var(--oat); }

/* A solid block in the ink color, for a boxed headline. */
.block { background: var(--ink); }

/* A circle. Plain, it is a dot in the ink color. */
.dot { border-radius: 50%; background: var(--ink); }
.dot.is-coral { background: var(--coral); }

/* A square outline, for a map or a chart area. */
.outline { border: calc(2 * var(--u)) solid var(--ink); }

/* A progress ring. The second circle is the arc. --arc on the ring sets
   how much of it shows: 1 is a quarter, 2 a half, 3 three quarters, 4 the
   whole. */
.ring { overflow: visible; fill: none; stroke-width: 7; }
.ring circle { stroke: color-mix(in srgb, var(--ink) 25%, transparent); }
.ring .ring-arc {
  stroke: var(--mark);
  stroke-dasharray: var(--arc, 4) 4;
  transform: rotate(-90deg);
  transform-origin: center;
}

/* ---------- MEDIA ----------
   A box for a video or a photo. Empty, it shows a play mark. Put a
   <video> or an <iframe> embed inside and it fills the box. */
.media {
  position: relative;
  overflow: hidden;
  background: color-mix(in srgb, var(--ink) 12%, transparent);
}
.media > video,
.media > iframe,
.media > img {
  position: absolute;
  inset: 0;
  width: 100%;
  height: 100%;
  border: 0;
  object-fit: cover;
}
.media > video, .media > iframe { background: #000; }
.media-empty {
  position: absolute;
  inset: 0;
  display: grid;
  place-items: center;
}
.media-empty::before {
  content: "";
  margin-left: calc(12 * var(--u));
  width: calc(40 * var(--u));
  height: calc(48 * var(--u));
  background: color-mix(in srgb, var(--ink) 70%, transparent);
  clip-path: polygon(0 0, 100% 50%, 0 100%);
}
/* A label on the empty box saying which clip goes there. It leaves with
   the media-empty span when the video goes in. */
.media-empty > span {
  position: absolute;
  top: calc(24 * var(--u));
  left: calc(24 * var(--u));
}
.media-subtitle {
  position: absolute;
  left: 0;
  right: 0;
  bottom: calc(48 * var(--u));
  padding: 0 calc(120 * var(--u));
  text-align: center;
  pointer-events: none;
}

/* ---------- MOTION ----------
   Five moves, set with data-move on an element or data-build on a group.
   deck.js gives each one its place in the slide's sequence and adds the
   classes below. Everything here sits inside "screen" and ".is-live", so
   print, the stacked scroll, and a page whose script did not run all show
   every slide finished.

   fade   opacity only
   rise   opacity and a short climb, for headlines and big numbers
   draw   a .rule draws along its length, a .ring draws its arc
   dim    text already on screen drops to --move-dim percent of the ink
   build  data-build on a group: its children arrive in order */
@media screen {
  .mv {
    transition-property: opacity, translate, clip-path;
    transition-duration: var(--move-fast);
    transition-timing-function: var(--move-ease);
    transition-delay: 0s;
  }
  /* Arriving waits its turn. Leaving, on a step back, does not. --n is the
     element's place in the sequence and --g the pauses ahead of it. */
  .mv.is-in,
  .ring.mv.is-in .ring-arc {
    transition-delay: calc(var(--n, 0) * var(--move-stagger) + var(--g, 0) * var(--move-fast));
  }

  .deck.is-live .mv-fade:not(.is-in),
  .deck.is-live .mv-rise:not(.is-in) { opacity: 0; }
  .deck.is-live .mv-rise:not(.is-in) { translate: 0 calc(var(--move-travel) * var(--u)); }

  .mv-draw { transition-duration: var(--move-slow); }
  /* The clip sits a little outside the rule, so a drawn rule renders
     exactly as an undrawn one, fine 1.5 rules included. */
  .rule.mv-draw { clip-path: inset(-2px); }
  .deck.is-live .rule.mv-draw:not(.is-in) { clip-path: inset(-2px 100% -2px -2px); }
  .deck.is-live .rule.upright.mv-draw:not(.is-in) { clip-path: inset(-2px -2px 100% -2px); }
  .ring.mv-draw .ring-arc {
    transition: stroke-dashoffset var(--move-slow) var(--move-ease);
  }
  .deck.is-live .ring.mv-draw:not(.is-in) .ring-arc { stroke-dashoffset: var(--arc, 4); }

  [data-move="dim"],
  [data-move="dim"] * { transition: color var(--move-fast) var(--move-ease); }
  .deck.is-live [data-move="dim"].is-dim,
  .deck.is-live [data-move="dim"].is-dim * {
    color: color-mix(in srgb, var(--ink) calc(var(--move-dim) * 1%), transparent);
  }

  /* While deck.js sets a slide to its starting state, nothing animates.
     The moves then play from there. */
  .deck.is-setting .mv,
  .deck.is-setting .ring.mv .ring-arc,
  .deck.is-setting [data-move="dim"],
  .deck.is-setting [data-move="dim"] * { transition: none; }

  /* Between slides the old one dissolves off the new one. Where the two
     share a ground, the frame does not appear to move. */
  .deck.is-live .slide.is-leaving {
    display: block;
    z-index: 1;
    opacity: 0;
    pointer-events: none;
    transition: opacity var(--move-cut) var(--move-ease);
  }
}
/* Asked for less motion: nothing travels or fades. A step build still
   steps, each step landing at once. */
@media (prefers-reduced-motion: reduce) {
  .mv, .ring.mv .ring-arc,
  [data-move="dim"], [data-move="dim"] *,
  .deck.is-live .slide.is-leaving { transition: none !important; }
}

/* ---------- PRINT ----------
   Print to PDF gives one slide per page, at 16 by 9 inches. */
@page { size: 16in 9in; margin: 0; }
@media print {
  html, body { background: none; }
  * { -webkit-print-color-adjust: exact; print-color-adjust: exact; }
  .deck, .deck.is-live { padding: 0; }
  .deck .slide, .deck.is-live .slide {
    display: block;
    position: relative;
    width: 16in;
    height: 9in;
    margin: 0;
    break-after: page;
  }
  .media-empty { display: none; }
}

/* ---------- CLIP WITH SYNCED LINES ----------
   A .media box with data-clip, a video and a .media-play button, plus a
   .clip-lines group with the same data-clip. Each .clip-line carries
   data-from, the second in the clip where it takes over. clip-sync.js
   fades the right line in as the video plays. Without the script, the
   first line (is-on in the markup) shows. */
.media-play {
  position: absolute;
  inset: 0;
  display: grid;
  place-items: center;
  padding: 0;
  border: 0;
  background: transparent;
  cursor: pointer;
}
.media-play::before,
.media-play::after { content: ""; grid-area: 1 / 1; }
.media-play::before {
  width: calc(160 * var(--u));
  height: calc(160 * var(--u));
  border-radius: 50%;
  background: color-mix(in srgb, var(--night) 55%, transparent);
}
.media-play::after {
  margin-left: calc(12 * var(--u));
  width: calc(40 * var(--u));
  height: calc(48 * var(--u));
  background: var(--linen);
  clip-path: polygon(0 0, 100% 50%, 0 100%);
}
.media.is-playing .media-play { display: none; }
.clip-line { opacity: 0; transition: opacity var(--move-fast) var(--move-ease); }
.clip-line.is-on { opacity: 1; }
/* Subtitles that change with the clip sit over bright video, so they get a soft dark halo. */
.clip-lines .media-subtitle {
  color: var(--linen);
  text-shadow: 0 0 calc(14 * var(--u)) color-mix(in srgb, var(--night) 90%, transparent),
               0 calc(2 * var(--u)) calc(6 * var(--u)) color-mix(in srgb, var(--night) 70%, transparent);
}

/* ---------- MICHAEL'S SLIDES ----------
   Added 2026-11-16 for bonnie-rfp-v2.html. Everything from here to the
   end of the file is new, and nothing above this line changed. These
   rules travel with the slides: a slide copied into index.html needs
   this block, assets/img/logos and assets/img/work. The logos in
   assets/img/logos are drawn in Linen, the ink of a dark ground, so
   they sit on Night, Slate or Teal. The six family logos also come as
   Slate copies, named -slate, for Lime, Coral and Linen. All of it is
   placed with .at, like the blocks above. Revised 2026-11-16: the
   slow drift became the roll, and .is-on and .mid were added. Revised
   2026-11-17: .rows replaced .bullets, .swatch.is-round went, and
   --move-hold, the carry move, .phase, .laptop-lid, .laptop-base,
   .screens and .waits were added. */

/* One more motion token, beside the ones at the top of this file. The
   hold between reveals on a diagram that builds from the center out. */
:root { --move-hold: 1200ms; }

/* A circle drawn as an outline, for the nested circle diagrams. */
.circle { border: calc(2 * var(--u)) solid var(--ink); border-radius: 50%; }

/* A line drawing, written as an inline <svg class="diagram at">. Its
   strokes take the ink color. The stroke width is in the drawing's own
   units, so set --stroke when a drawing uses another scale. */
.diagram { overflow: visible; fill: none; stroke: var(--ink); stroke-width: var(--stroke, 6); }

/* A flat block of one color, for a color chip on a mood board. --fill
   sets the color. */
.swatch { background: var(--fill, var(--oat)); }

/* A .tile on a dark ground. Oat would glare there, so the panel is a
   light tint of the ink. --tint sets how strong. */
.tile.is-tint { background: color-mix(in srgb, var(--ink) calc(var(--tint, 10) * 1%), transparent); }

/* A wall of images in columns, which run off the top and bottom of the
   box. Each .wall-col is one column. --from on a column is where it
   rests, in Figma pixels, measured up from the top of the box. A
   .placeholder in a column is an open spot for another image, and
   .wall-space is an empty one. Both take --h. .wall-cover is a block of
   the ground color, for a headline set over the top of a column. */
.wall {
  display: flex;
  align-items: flex-start;
  gap: calc(var(--gap, 16) * var(--u));
  overflow: hidden;
}
.wall-col {
  flex: 1 1 0;
  min-width: 0;
  display: flex;
  flex-direction: column;
  gap: calc(var(--gap, 16) * var(--u));
  translate: 0 calc(var(--from, 0) * var(--u));
}
.wall-col > img { width: 100%; height: auto; }
.wall-col > .placeholder,
.wall-space { flex: none; height: calc(var(--h) * var(--u)); }
.wall-cover { background: var(--bg); }

/* THE ROLL. This departs from the motion rules above, where nothing
   loops. On a .wall with .rolls, each column scrolls without end for as
   long as the slide is up, and every other column scrolls the other
   way. deck.js writes each column's images a second time under the
   first, so the loop has no seam. --secs on a column is how long one
   pass takes, and --from is where the column rests. Take .rolls off a
   wall and its columns sit still at --from. Print, the stacked scroll
   and reduced motion show it still. */
@media screen and (prefers-reduced-motion: no-preference) {
  .deck.is-live .wall.rolls .wall-col.is-doubled {
    animation: wall-roll calc(var(--secs, 60) * 1s) linear infinite;
  }
  .deck.is-live .wall.rolls .wall-col.is-doubled:nth-child(even) { animation-direction: reverse; }
}
@keyframes wall-roll {
  from { translate: 0 calc(var(--from, 0) * var(--u)); }
  to   { translate: 0 calc(var(--from, 0) * var(--u) - 50% - var(--gap, 16) / 2 * var(--u)); }
}

/* A filled part of a .diagram, in the color that marks the current
   section. For the small Landscape circles on Rivals, Substitutes and
   Benchmarks. */
.diagram .is-on { fill: var(--mark); fill-rule: evenodd; stroke: none; }

/* A short list with a fine rule above each line and one under the
   last. Set the type class on the <ul>. */
.rows { padding: 0; list-style: none; }
.rows li {
  padding: calc(9 * var(--u)) 0;
  border-top: calc(1.5 * var(--u)) solid var(--ink);
}
.rows li:last-child { border-bottom: calc(1.5 * var(--u)) solid var(--ink); }

/* Centers a text box on its --y, for a statement set beside a diagram. */
.at.mid { transform: translateY(-50%); }

/* A phase name in an outlined box. The same box sits on slides 2 and 3
   at the same width, so the carry move reads as one box rising. */
.phase {
  display: flex;
  align-items: center;
  padding: 0 calc(30 * var(--u)) calc(6 * var(--u));
  border: calc(2 * var(--u)) solid var(--ink);
  font: 300 calc(60 * var(--u)) / 1 var(--serif);
  letter-spacing: -0.03em;
  white-space: nowrap;
}

/* THE CARRY. A sixth move, data-move="carry", beside the five under
   MOTION. The element is on screen from the start, --carry Figma pixels
   lower than it rests, and travels up to its place once the dissolve
   from the last slide is done. --carry-h, when set, is the height it
   starts at, and it comes to its own --h on the way. Slide 3 uses it to
   pick up the three phase boxes from where slide 2 leaves them. Slide
   14 uses it inside a step build, with --move-cut at 0ms on the element,
   so its large line rises on a Next with no wait. deck.js lists it with
   the moves that enter. */
@media screen {
  .mv-carry { transition-property: translate, height; transition-duration: var(--move-slow); }
  .mv-carry.is-in { transition-delay: calc(var(--move-cut) + var(--n, 0) * var(--move-stagger)); }
  .deck.is-live .mv-carry:not(.is-in) {
    translate: 0 calc(var(--carry, 0) * var(--u));
    height: calc(var(--carry-h, var(--h)) * var(--u));
  }
}

/* THE LAND. A seventh move, data-move="land", added 2026-11-19 for
   bonnie-rfp-v3.html. The element is on screen before its step, in
   another box: --fx, --fy, --fw and --fh, in Figma pixels like --x, --y,
   --w and --h. On its step it travels to its own box and comes to its
   own size. The logo pages use it: one logo sits large in the middle
   of the page, then takes its place as the others fade in (.waits).
   With data-later="1" it plays one step after the group it is written
   in, so a row can fade in first and one logo can then leave it. The
   size is set with width and height, not scale, so a logo stays sharp
   at both ends. deck.js lists it with the moves that enter. */
@media screen {
  .mv-land { transition-property: translate, width, height; transition-duration: var(--move-slow); }
  .deck.is-live .mv-land:not(.is-in) {
    translate: calc((var(--fx, var(--x)) - var(--x)) * var(--u)) calc((var(--fy, var(--y)) - var(--y)) * var(--u));
    width: calc(var(--fw, var(--w)) * var(--u));
    height: calc(var(--fh, var(--h)) * var(--u));
  }
}

/* A laptop, drawn as an outline. .laptop-lid is the screen's surround
   and .laptop-base the deck under it, with the thumb notch. Both are
   placed with .at. The page goes in a .screens box set 20 inside the lid.
   --line on each is the weight of the outline, 2 unless set. */
.laptop-lid {
  border: calc(var(--line, 2) * var(--u)) solid var(--ink);
  border-radius: calc(26 * var(--u)) calc(26 * var(--u)) 0 0;
}
.laptop-base {
  border: calc(var(--line, 2) * var(--u)) solid var(--ink);
  border-radius: calc(4 * var(--u)) calc(4 * var(--u)) calc(18 * var(--u)) calc(18 * var(--u));
}
.laptop-base::before {
  content: "";
  position: absolute;
  top: calc(var(--line, 2) * -1 * var(--u));
  left: 50%;
  width: calc(220 * var(--u));
  height: calc(12 * var(--u));
  translate: -50% 0;
  border: calc(var(--line, 2) * var(--u)) solid var(--ink);
  border-top: 0;
  border-radius: 0 0 calc(10 * var(--u)) calc(10 * var(--u));
}

/* THE SCREENS. Like the roll, this departs from the motion rules above.
   A .screens box holds captures of one page, a screen each, stacked on
   one another. While the slide is up, deck.js shows them in order,
   --secs seconds each, with a quick fade from one to the next, and
   starts again after the last. Each new screen fades in over the one
   before it, so the box never dips to its background. Print, the
   stacked scroll and a page whose script did not run show the first
   screen. */
.screens {
  overflow: hidden;
  border-radius: calc(6 * var(--u));
  background: #17131f;
}
.screens > img {
  position: absolute;
  inset: 0;
  width: 100%;
  height: 100%;
  object-fit: cover;
  opacity: 0;
}
.screens:not(.is-run) > img:first-child,
.screens > img.is-under { opacity: 1; }
.screens > img.is-on {
  z-index: 1;
  opacity: 1;
  transition: opacity var(--move-cut) var(--move-ease);
}
@media (prefers-reduced-motion: reduce) {
  .screens > img.is-on { transition: none; }
}

/* A move that waits for a carry in its own step to finish before it
   plays. --wait is its turn after that, two staggers apart. Slide 14
   uses it: the large line rises, then the drawing arrives in order. */
@media screen {
  .mv.is-in.waits {
    transition-delay: calc(var(--move-slow) + var(--wait, 0) * 2 * var(--move-stagger));
  }
}

/* Added 2026-11-17, fifth round. */

/* Breaks a short statement into lines of even length. For the line
   beside the circle diagrams on Attributes, Customer and Landscape. */
.balance { text-wrap: balance; }

/* A line that is there on arrival and leaves on the next step. Write it
   with data-move="dim" in the first child of a step build, and add
   .leaves. Where the dim would drop it to 40 percent, it goes all the
   way. It is never in the finished state, so print, the stacked scroll
   and a page whose script did not run leave it out. Slide 14 uses it for
   the line under "Recognition and relevance". */
.leaves { display: none; }
@media screen {
  .deck.is-live .leaves { display: block; transition: opacity var(--move-fast) var(--move-ease); }
  .deck.is-live .leaves.is-dim { opacity: 0; }
  .deck.is-setting .leaves { transition: none; }
}

/* A block of another ground, full bleed, laid under everything on the
   slide but over the slide's own color. Fade it in to change the ground
   on a step. The frame keeps the first ground's ink, so pair grounds
   that share an ink, like Coral and Linen. Slide 14 uses it. */
.ground-swap {
  z-index: -1;
  background: var(--fill, var(--linen));
}

/* Added 2026-11-19, for the mockup slides in bonnie-rfp-v3.html. */

/* A picture floated over a photo. Rounded corners and a soft shadow
   lift it off the photo. Slide 36 uses it for the care page over the
   store picture. */
.float {
  border-radius: calc(20 * var(--u));
  box-shadow: 0 calc(24 * var(--u)) calc(72 * var(--u)) color-mix(in srgb, var(--night) 45%, transparent);
}

/* A phone, drawn as an outline, like the laptop. .phone is the body,
   placed with .at. The picture goes in a .phone-screen box set 12
   inside it, at 9 by 16. --line is the weight of the outline, 2 unless
   set. Slide 34 uses three of them. */
.phone {
  border: calc(var(--line, 2) * var(--u)) solid var(--ink);
  border-radius: calc(52 * var(--u));
}
.phone-screen { border-radius: calc(40 * var(--u)); }
