/* The Omand site, on Omand's design system (design/README.md). Its tokens
   are design/tokens.json's, by the same names, in tokens.css, which
   design/generate.py writes and every page links before this file: a change
   starts in tokens.json. The site's own values follow below (the two type
   sizes that flex with the screen, the wordmark's, and the sizes of the
   pictures, the stage and the forms); tracking, measures, the marker's
   placement, the field's geometry and a drawn device's proportions are
   written where they are drawn. A media query names its width as a number,
   since CSS reads no custom property there: 640 is width-tablet (a phone
   below it) and 1024 width-computer (a computer from it). */

@font-face {
  font-family: Syne;
  src: url("fonts/syne-var.ttf") format("truetype");
  font-weight: 400 800;
  font-display: swap;
}

:root {
  /* Type: the two headlines flex with the screen, from a phone's size up
     to their largest, both ends in tokens.css; the other sizes are there as
     they are. Each headline's line height keeps a phone's lead over its
     size as it grows, held to the 4px grid and to the largest line height
     (tokens.css: --line-display-min/max, --line-headline-min/max). */
  --size-display: clamp(var(--size-display-min), 7vw, var(--size-display-max));
  --size-headline: clamp(var(--size-headline-min), 3.4vw, var(--size-headline-max));

  /* The name in the bar: the logo's size, not a text size, on one scale
     with the bar's links at the body's size. */
  --size-wordmark: 24px;
  /* The bar's button: the design's button made small, so it stays in view
     beside the links without outweighing the first screen's own. */
  --bar-button: 40px;
  /* The bar's height, which the page keeps clear under it. */
  --bar-tall: calc(2 * var(--space-3) + var(--bar-button));

  /* The site's own sizes. */
  /* The first screen's headline on a computer, held so its two lines fit
     the words' column; and the deeper shadow of a card the pointer lifts. */
  --hero-display-max: 57px;
  --shadow-lift: 0 2px 4px color-mix(in srgb, var(--ink) 5%, transparent), 0 24px 48px color-mix(in srgb, var(--ink) 10%, transparent);
  --focus-width: 2px;
  --flow-line: 2px;
  --art-height: 120px;
  --art-figure: 88px;
  --edge-reach: 180px;
  --form-width: 640px;
  --plans-width: 800px;
  --table-min: 560px;
  --short-width: 800px;
  --hero-width: 1184px;
  --hero-tall: 1000px;
  --tour-words-tall: 240px;

  /* The explainers' parts, at the sizes design/components draws them: a
     scene's width, a tool's chip (near and far) and its mark, the AI's
     chip and its mark, the tools' cloud, Omand's card and its rows, a
     file's sheet (alone, and small inside a chat), the stack of sheets, a
     chat, Omand's contents and a bubble, a mark in a row or on a sheet,
     and a row of the contents, the path's conversation and its row of
     files; each the part's whole box. The smallest
     words of a picture (a row's source, who speaks, a file's kind, the
     limit's name) are part of the drawing, like the words on a drawn
     device's screen, not a text size of the page. */
  --explain-width: 880px;
  --explain-tool: 52px;
  --explain-tool-far: 40px;
  --explain-tool-mark: 24px;
  --explain-tool-mark-far: 18px;
  --explain-ai: 88px;
  --explain-ai-mark: 40px;
  --explain-sources: 260px;
  --explain-base: 320px;
  --explain-row: 52px;
  --explain-sheet-width: 80px;
  --explain-sheet-height: 96px;
  --explain-sheets-width: 120px;
  --explain-sheets-height: 288px;
  --explain-small-width: 48px;
  --explain-small-height: 56px;
  --explain-chat: 296px;
  --explain-contents: 304px;
  --explain-say: 292px;
  --explain-mark: 20px;
  --explain-mark-small: 16px;
  --explain-contents-row: 32px;
  --explain-words: 12px;
  --explain-talk: 232px;
  --explain-row-of-files-width: 208px;
  --explain-row-of-files-height: 112px;

  /* The glass: its edges (a white top edge, a white hairline inside, a
     faint ink one outside) and its grain, a fine noise of ink at 3.5%, so a
     frosted card reads as a material, not as a tint. */
  --glass-edges: inset 0 1px 0 color-mix(in srgb, var(--paper) 95%, transparent), inset 0 0 0 1px color-mix(in srgb, var(--paper) 55%, transparent), 0 0 0 1px color-mix(in srgb, var(--ink) 5%, transparent);
  --grain: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='160' height='160'%3E%3Cfilter id='g'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.85' numOctaves='2' stitchTiles='stitch'/%3E%3CfeColorMatrix values='0 0 0 0 0.11 0 0 0 0 0.106 0 0 0 0 0.098 0 0 0 0.035 0'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23g)'/%3E%3C/svg%3E");
}

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

body {
  background: var(--paper);
  color: var(--ink);
  font-family: var(--font-text);
  font-size: var(--size-body);
  /* 24 at the body's size; relative, so the words on a drawn device's
     screen keep the same proportion at its own points. */
  line-height: 1.5;
  -webkit-font-smoothing: antialiased;
}

:focus-visible {
  outline: var(--focus-width) solid var(--ink);
  outline-offset: var(--space-1);
}

a {
  color: inherit;
}

/* Two weights of the text face: regular and semibold. */
b,
strong {
  font-weight: 600;
}

ul,
ol {
  list-style: none;
}

.wrap {
  max-width: var(--content-width);
  margin: 0 auto;
  padding: 0 var(--space-12);
}

/* The pointer's light: one soft light of field-2 that follows a mouse or a
   trackpad over every page (site.js adds it, never where the system asks
   for less motion). It lies under everything but the grounds: on the first
   screen over the field and under the words and the devices; below it,
   every section stands above it as a whole, its dawn and its cards
   included, so the light shows on the white ground and glows through the
   frosted cards, never over them. The footer, the one ground of ink, stays
   above it. Its falloff is a lamp's, eased in seven stops so no stop shows
   as a ring, and a fine dither breaks its 8-bit steps. */
.light {
  position: fixed;
  left: calc(var(--pointer-light) / -2);
  top: calc(var(--pointer-light) / -2);
  z-index: 1;
  width: var(--pointer-light);
  height: var(--pointer-light);
  pointer-events: none;
  background: radial-gradient(closest-side,
    color-mix(in srgb, var(--field-2) 44%, transparent) 0%,
    color-mix(in srgb, var(--field-2) 40%, transparent) 12%,
    color-mix(in srgb, var(--field-2) 30%, transparent) 30%,
    color-mix(in srgb, var(--field-2) 18%, transparent) 48%,
    color-mix(in srgb, var(--field-2) 8%, transparent) 66%,
    color-mix(in srgb, var(--field-2) 3%, transparent) 82%,
    transparent 100%);
  mask: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='160' height='160'%3E%3Cfilter id='d'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.9' stitchTiles='stitch'/%3E%3CfeColorMatrix values='0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.28 0 0 0 0.72'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23d)'/%3E%3C/svg%3E") 0 0 / 160px;
  opacity: 0;
  transition: opacity 400ms ease;
}

.light.on {
  opacity: 1;
}

.intro > :not(.field, .work, .bar),
.work-tags,
.work-devices,
.page-head > :not(.bar),
.footer {
  position: relative;
  z-index: 2;
}

/* A card's edge catches the pointer's light where the pointer comes near:
   its own hairline brightening, as backlit glass does, thin and pale
   field-2 fading within a short reach, never a stroke of color. It lies on
   the card's rim only, in the card's own corner shape (site.js adds it to
   each card and tells it where the pointer is). */
.edge {
  position: absolute;
  inset: 0;
  padding: 1px;
  border-radius: inherit;
  pointer-events: none;
  corner-shape: inherit;
  background: radial-gradient(var(--edge-reach) circle at var(--x, -999px) var(--y, -999px),
    color-mix(in srgb, var(--field-2) 75%, transparent) 0%,
    color-mix(in srgb, var(--field-2) 25%, transparent) 45%,
    transparent 70%);
  mask: linear-gradient(#000 0 0) content-box exclude, linear-gradient(#000 0 0);
}

/* The field: behind the first screen, its colors at the screen's corners
   and fading into paper at its foot, so it stays an accent at the door.
   Each color is a wide radial falloff centered off the screen, so only its
   soft edge shows; multiply lets two colors mix where they meet. Each
   falloff is an ellipse sized by the first screen's width and height, so
   the composition keeps its proportions on every screen. */

.field {
  position: absolute;
  inset: 0;
  z-index: 0;
  overflow: hidden;
  mask: linear-gradient(#000 55%, transparent);
}

.field span {
  position: absolute;
  width: 92%;
  height: 147.2%;
  mix-blend-mode: multiply;
  /* Eased stops: a plain two-stop falloff peaks in a hot point; these hold
     the color, then let it go slowly. */
  background: radial-gradient(closest-side,
    var(--tone) 0%,
    color-mix(in oklab, var(--tone) 94%, transparent) 18%,
    color-mix(in oklab, var(--tone) 74%, transparent) 38%,
    color-mix(in oklab, var(--tone) 44%, transparent) 58%,
    color-mix(in oklab, var(--tone) 16%, transparent) 80%,
    transparent 100%);
}

.field span:nth-child(1) { --tone: var(--field-1); left: -38%; top: -70.4%; }
.field span:nth-child(2) { --tone: var(--field-2); right: -30%; top: -83.2%; }
.field span:nth-child(3) { --tone: var(--field-3); right: -36%; bottom: -80%; }
.field span:nth-child(4) { --tone: var(--field-4); left: -40%; bottom: -89.6%; }

/* On a tall screen the corners stand close together, and colors centered on
   them would mix to mud; there they stand down the sides instead, each
   meeting the next only in its soft edge. */
@media (max-aspect-ratio: 1/1) {
  .field span { width: 170%; height: 78.6%; }
  .field span:nth-child(1) { left: -95%; top: -44.3%; }
  .field span:nth-child(2) { right: -95%; top: -9.3%; }
  .field span:nth-child(3) { right: -90%; bottom: -39.3%; }
  .field span:nth-child(4) { left: -95%; bottom: auto; top: 35.7%; }
}

/* A faint grain, so the long falloffs never band on a large screen. */
.field::after {
  content: "";
  position: absolute;
  inset: 0;
  opacity: 0.05;
  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='160' height='160'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.9' numOctaves='2' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)'/%3E%3C/svg%3E");
}

/* The first screen: the hero and the work on the field, under the bar.
   Its sides clip what glows past the screen's edge. */

.intro {
  position: relative;
  overflow-x: clip;
  padding-top: var(--bar-tall);
  padding-bottom: var(--space-16);
}

/* The bar stays at the top of the screen on every page, its words on the
   hero's edges. Once the page leaves its top, frosted paper gathers under
   it, fading at its foot, so what scrolls beneath never meets the words;
   over the ink footer the words and the frost turn to the night. Without
   the script the frost stands from the start. */
html {
  scroll-padding-top: var(--bar-tall);
}

.page-head {
  padding-top: var(--bar-tall);
}

.bar {
  position: fixed;
  inset: 0 0 auto;
  z-index: 20;
  display: flex;
  align-items: center;
  padding: var(--space-3) max(var(--space-12), (100% - var(--hero-width)) / 2);
}

.bar::before {
  content: "";
  position: absolute;
  inset: 0 0 calc(-1 * var(--space-8));
  z-index: -1;
  background: color-mix(in srgb, var(--paper) 62%, transparent);
  backdrop-filter: blur(var(--space-6)) saturate(1.6);
  mask-image: linear-gradient(var(--ink) 55%, transparent);
  pointer-events: none;
  transition: opacity var(--motion-calm) var(--ease), background var(--motion-calm) var(--ease);
}

.at-top .bar::before {
  opacity: 0;
}

.bar.on-night::before {
  background: color-mix(in srgb, var(--ink) 62%, transparent);
}

.bar.on-night .wordmark,
.bar.on-night a {
  color: var(--on-ink);
}

/* Over the ink footer the bar's button turns to paper, so it still reads
   as the one strong action there. */
.bar.on-night .bar-join {
  background: var(--paper);
  color: var(--ink);
}

.bar.on-night .bar-join:hover {
  background: color-mix(in srgb, var(--paper) 88%, var(--ink));
}

.wordmark {
  font-family: var(--font-display);
  font-weight: 700;
  font-size: var(--size-wordmark);
  line-height: 1;
  letter-spacing: -0.01em;
  color: var(--ink);
  text-decoration: none;
}

/* The wordmark holds the left; the links and the button stand at the
   right, so the button keeps its place when the links give way on a phone,
   and on a page with no links. */
.bar .wordmark {
  margin-right: auto;
}

.bar-nav {
  display: flex;
  gap: var(--space-8);
  margin-right: var(--space-8);
  font-size: var(--size-body);
}

/* The links in regular, so the button is the bar's one strong word. */
.bar-nav a {
  text-decoration: none;
  text-underline-offset: 0.25em;
}

.bar-nav a:hover {
  text-decoration: underline;
}

/* The headline, then its line and the button under it; on a computer they
   stand beside the work (below). */
.hero {
  width: min(var(--hero-width), 100% - 2 * var(--space-12));
  margin: var(--space-4) auto 0;
}

.hero h1 {
  max-width: none;
  letter-spacing: -0.035em;
}

.hero-side {
  display: grid;
  gap: var(--space-6);
}

.hero .lede {
  margin-top: 0;
}

.hero .button {
  margin-top: 0;
  justify-self: start;
}

h1 {
  font-family: var(--font-display);
  font-weight: 700;
  font-size: var(--size-display);
  line-height: min(var(--line-display-max), round(var(--size-display) + var(--line-display-min) - var(--size-display-min), 4px));
  letter-spacing: -0.025em;
  max-width: 11ch;
  text-wrap: balance;
}

/* The marker: a highlighter stroke behind the lower part of one word, ink
   on it. Straight edges and both ends cut at the same angle, as a broad
   nib leaves them, so it reads as drawn with care rather than in a hurry. */
mark {
  position: relative;
  isolation: isolate;
  background: none;
  color: var(--ink);
}

mark::before {
  content: "";
  position: absolute;
  z-index: -1;
  inset: 0.5em -0.08em 0.1em;
  background: var(--accent);
  clip-path: polygon(0.18em 0, 100% 0, calc(100% - 0.18em) 100%, 0 100%);
}

.lede {
  margin-top: var(--space-6);
  max-width: 34em;
  font-size: var(--size-lede);
  line-height: var(--line-lede);
  color: var(--ink-soft);
  text-wrap: pretty;
}

/* The one strong action: ink, as contengy's is. The bar's button is the
   same, made small. */
.button,
.bar-join {
  margin-top: var(--space-12);
  display: inline-flex;
  align-items: center;
  height: var(--control-strong);
  padding: 0 var(--space-6);
  border-radius: var(--radius-control);
  corner-shape: squircle;
  background: var(--ink);
  color: var(--paper);
  font-size: var(--size-body);
  font-weight: 600;
  text-decoration: none;
}

.button:hover,
.bar-join:hover {
  background: color-mix(in srgb, var(--ink) 88%, var(--paper));
}

.button:active,
.bar-join:active {
  background: color-mix(in srgb, var(--ink) 78%, var(--paper));
}

/* Devices: a MacBook Pro 14 and an iPhone 17 Pro drawn in their dark
   finish around the app's own screens. A device sizes from its own width:
   its parts use container units, so one rule draws it at any size. Its
   screen is a container of its own, and what stands on the screen counts
   in the screen's points (--pt), so the words on it keep the six sizes,
   scaled with the device. A device is an iPhone; a Mac (`mac`) is a Mac
   only where the page is wider than a phone, and an iPhone showing the
   app's phone screens on a phone, so a phone loads no computer picture.

   iPhone 17 Pro: 71.9 by 150 mm, the screen 2.65 mm in at the sides and 2.6
   at the ends, 390 points wide as the app's phone screens are. */
.device {
  --body-ratio: 71.9 / 150;
  --body-radius: 16cqw;
  --rim: 0.5cqw;
  --glass-inset: 1.1cqw;
  --glass-radius: 15cqw;
  --screen-inset: 1.73% 3.69%;
  --screen-radius: 12.5cqw;
  container-type: inline-size;
}

/* MacBook Pro 14: the lid 312.6 by 207.9 mm over the base's front edge,
   the screen 5.1 mm in at the sides and 6 under the lid's top edge. */
@media (width >= 640px) {
  .mac {
    --body-ratio: 312.6 / 207.9;
    --body-radius: 2.9cqw 2.9cqw 0.4cqw 0.4cqw;
    --rim: 0.2cqw;
    --glass-inset: 0.55cqw;
    --glass-radius: 2.5cqw 2.5cqw 0.2cqw 0.2cqw;
    --screen-inset: 2.89% 1.63% 2.65%;
    --screen-radius: 0.9cqw 0.9cqw 0 0;
  }
}

.device-body {
  position: relative;
  aspect-ratio: var(--body-ratio);
  border-radius: var(--body-radius);
  background: var(--device-band);
  box-shadow: inset 0 0 0 var(--rim) color-mix(in srgb, var(--device-rim) 45%, transparent), var(--shadow-device);
}

.device-body::before {
  content: "";
  position: absolute;
  inset: var(--glass-inset);
  border-radius: var(--glass-radius);
  background: var(--device-glass);
}

.device-screen {
  --pt: calc(100cqw / 390);
  position: absolute;
  inset: var(--screen-inset);
  overflow: hidden;
  border-radius: var(--screen-radius);
  container-type: size;
  background: var(--paper);
}

.device-base {
  display: none;
}

/* The iPhone's status bar: the time, the Dynamic Island, signal, wifi and
   battery, at the height iOS gives it. */
.status-bar {
  position: relative;
  flex: none;
  display: flex;
  align-items: center;
  justify-content: space-between;
  height: calc(54 * var(--pt));
  padding: 0 calc(30 * var(--pt)) 0 calc(36 * var(--pt));
  font-size: calc(16 * var(--pt));
  line-height: 1;
  color: var(--ink);
}

.status-bar b {
  font-weight: 600;
}

.island {
  position: absolute;
  left: 50%;
  top: calc(12 * var(--pt));
  width: calc(124 * var(--pt));
  height: calc(36 * var(--pt));
  translate: -50% 0;
  border-radius: calc(18 * var(--pt));
  background: var(--device-glass);
}

.status-icons {
  width: calc(68 * var(--pt));
  height: calc(12 * var(--pt));
  fill: var(--ink);
}

.status-icons .battery {
  fill: none;
  stroke: var(--ink-faint);
}

/* The Mac: the app fills its screen, as it runs full screen, under the
   camera's notch, and the base below the lid. Nothing is drawn around the
   app: no desktop, no window. */
@media (width >= 640px) {
  .mac .device-screen {
    background: var(--paper);
  }

  .mac .device-screen::after {
    content: "";
    position: absolute;
    left: 50%;
    top: 0;
    width: 11%;
    height: 3.4%;
    translate: -50% 0;
    border-radius: 0 0 0.8cqw 0.8cqw;
    background: var(--device-glass);
  }

  .mac .status-bar {
    display: none;
  }

  .mac .device-base {
    display: block;
    position: relative;
    margin: 0 -1.2cqw;
    height: 3.6cqw;
    border-radius: 0 0 2.4cqw 2.4cqw;
    background: linear-gradient(var(--device-edge), var(--device-band) 30%, var(--device-foot));
    box-shadow: var(--shadow-device);
  }

  /* The notch in the base's front edge that lifts the lid. */
  .mac .device-base::before {
    content: "";
    position: absolute;
    left: 50%;
    top: 0;
    width: 14%;
    height: 38%;
    translate: -50% 0;
    border-radius: 0 0 1.4cqw 1.4cqw;
    background: var(--device-foot);
  }
}

/* The app's screen inside a device. On a phone it is the phone's screen
   under its status bar; on a computer it fills the Mac's screen from its
   top, at its own proportions, and the screen's edge cuts what runs past
   its foot. */
.window-view {
  position: relative;
  aspect-ratio: 390 / 640;
}

@media (width >= 640px) {
  .window {
    position: absolute;
    inset: 0;
    overflow: hidden;
    background: var(--paper);
  }

  .window-view {
    aspect-ratio: 1200 / 780;
  }
}

/* The first screen's work: the company's AI on an iPhone in front, Omand
   on a Mac behind it, each under its tag, the field's colors glowing
   behind them. The glow is the field's, a ground: it lies under the
   pointer's light, the tags and the devices over it. At rest the page shows
   the whole conversation and Omand's last screen; site.js plays it once, a
   beat at a time. */
.work {
  position: relative;
  container-type: inline-size;
  width: min(var(--hero-width), 100% - 2 * var(--space-12));
  margin: var(--space-8) auto 0;
}

.work::before {
  content: "";
  position: absolute;
  inset: 0 -8% -6%;
  z-index: 0;
  pointer-events: none;
  background:
    radial-gradient(30% 40% at 18% 62%, color-mix(in srgb, var(--field-4) 60%, transparent), transparent 70%),
    radial-gradient(38% 46% at 60% 42%, color-mix(in srgb, var(--field-2) 55%, transparent), transparent 70%),
    radial-gradient(30% 36% at 88% 78%, color-mix(in srgb, var(--field-3) 50%, transparent), transparent 70%),
    radial-gradient(24% 30% at 10% 18%, color-mix(in srgb, var(--field-1) 50%, transparent), transparent 70%);
  filter: blur(var(--space-12));
}

/* Each device's label: a paper pill with the card's shadow, so it reads on
   the field and on the page's white ground alike: the device's name in ink
   after a dot of its own (ink for the AI, the accent for Omand), then what
   happens there. The two stand in one row over the devices, the AI's at the
   iPhone's left edge, Omand's at the Mac's right edge; on a computer wide
   enough each is pinned to its own device. */
.work-tags {
  display: grid;
  margin-bottom: var(--space-4);
}

.work-place {
  grid-area: 1 / 1;
  justify-self: start;
  display: flex;
  flex-wrap: wrap;
  align-items: center;
  gap: 0 var(--space-2);
  max-width: 48cqw;
  padding: var(--space-1) var(--space-3);
  border-radius: var(--radius-control);
  background: var(--paper);
  box-shadow: var(--shadow-card);
  font-size: var(--size-label);
  line-height: var(--line-label);
  color: var(--ink-soft);
}

.work-place + .work-place {
  justify-self: end;
}

.work-place :is(.chip.strong, .chip.blue) {
  gap: var(--space-2);
  height: auto;
  padding: 0;
  background: none;
  color: var(--ink);
}

.work-place .chip::before {
  content: "";
  width: var(--space-2);
  height: var(--space-2);
  border-radius: 50%;
  background: var(--ink);
}

.work-place .chip.blue::before {
  background: var(--accent);
}

/* The devices stand in a box as wide as the work, placed in its own
   units, so the composition keeps its proportions at every width; the box
   is as tall as the iPhone's foot. */
.devices {
  position: relative;
  container-type: inline-size;
}

.devices .device {
  position: absolute;
}

.work-devices {
  aspect-ratio: 100 / 65.6;
}

.work-app {
  right: 0;
  top: 0;
  width: 78cqw;
}

.work-chat {
  left: 0;
  top: 3cqw;
  z-index: 1;
  width: 30cqw;
}

/* The conversation on the AI's screen: a person's words on the accent's
   tint, each thing the AI did as a line with its icon, its answers plain.
   The iPhone shows it in the screen's own points, a size up from a
   messenger's so it reads on a phone drawn smaller than life: the
   conversation at the lede's size and the AI's lines at the body's.
   As in a messenger, the newest line comes at the foot and the older rise;
   the layout keeps the newest in view and the oldest slip under the head. */
.chat {
  position: absolute;
  inset: 0 0 auto;
  height: 100%;
  display: flex;
  flex-direction: column;
}

.chat-head {
  flex: none;
  padding: calc(4 * var(--pt)) 0 calc(12 * var(--pt));
  border-bottom: 1px solid var(--line);
  font-size: calc(16 * var(--pt));
  color: var(--ink-soft);
  text-align: center;
}

.chat-head b {
  color: var(--ink);
}

.work-talk {
  flex: 1;
  min-height: 0;
  overflow: hidden;
  display: flex;
  flex-direction: column;
  justify-content: flex-end;
  gap: calc(12 * var(--pt));
  padding: calc(16 * var(--pt)) calc(20 * var(--pt));
  font-size: calc(20 * var(--pt));
  line-height: calc(28 * var(--pt));
}

.work-talk > * {
  flex: none;
}

/* A line the work has not reached yet; the lines' own display would show it. */
.work-talk > p[hidden] {
  display: none;
}

.work-talk .you {
  align-self: flex-end;
  max-width: 88%;
  padding: calc(8 * var(--pt)) calc(14 * var(--pt));
  border-radius: calc(20 * var(--pt));
  background: var(--accent-soft);
}

.work-talk .did {
  display: flex;
  flex-wrap: wrap;
  align-items: center;
  gap: 0 calc(8 * var(--pt));
  font-size: calc(16 * var(--pt));
  line-height: calc(24 * var(--pt));
  color: var(--ink-soft);
}

.work-talk .did b {
  color: var(--ink);
  white-space: nowrap;
}

.work-talk .ico {
  width: calc(24 * var(--pt));
  height: calc(24 * var(--pt));
}

.work-talk .new {
  animation: settle 400ms ease both;
}

@keyframes settle {
  from {
    opacity: 0;
    translate: 0 var(--space-2);
  }
}

.work-talk .typing {
  display: flex;
  gap: calc(6 * var(--pt));
  padding: calc(8 * var(--pt)) 0;
}

.work-talk .typing i {
  width: calc(8 * var(--pt));
  height: calc(8 * var(--pt));
  border-radius: 50%;
  background: var(--mark-quiet);
  animation: typing 900ms infinite ease-in-out;
}

.work-talk .typing i:nth-child(2) {
  animation-delay: 150ms;
}

.work-talk .typing i:nth-child(3) {
  animation-delay: 300ms;
}

@keyframes typing {
  50% {
    background: var(--ink);
  }
}

.chat-reply {
  flex: none;
  margin: 0 calc(16 * var(--pt)) calc(30 * var(--pt));
  padding: calc(12 * var(--pt)) calc(18 * var(--pt));
  border-radius: calc(24 * var(--pt));
  background: var(--mist);
  font-size: calc(16 * var(--pt));
  line-height: calc(24 * var(--pt));
  color: var(--ink-faint);
}

/* Omand's screens, one per beat, laid over each other; the one of the
   beat shows. */
.work-screen {
  position: absolute;
  inset: 0;
  opacity: 0;
  transition: opacity 450ms ease;
}

.work-screen.now {
  opacity: 1;
}

.work-screen img {
  display: block;
  width: 100%;
  height: auto;
}

/* What the AI just saved, marked on Omand's screen with the accent's tint,
   the way the app marks what waits for a person. */
.work-saved {
  position: absolute;
  left: 46.7%;
  top: 56.8%;
  width: 50.2%;
  height: 10.5%;
  border-radius: var(--radius-control);
  background: var(--accent-soft);
  mix-blend-mode: multiply;
}

.work-steps {
  display: flex;
  justify-content: center;
  gap: var(--space-2);
  margin-top: var(--space-8);
}

.work-steps button {
  position: relative;
  width: var(--space-16);
  height: var(--space-6);
  padding: 0;
  border: 0;
  background: none;
  cursor: pointer;
}

.work-steps button::before,
.work-steps button::after {
  content: "";
  position: absolute;
  inset: 50% 0 auto;
  height: var(--flow-line);
  border-radius: var(--flow-line);
  background: var(--line);
}

.work-steps button::after {
  background: var(--ink);
  transform-origin: left;
  transform: scaleX(0);
}

.work-steps .done::after {
  transform: scaleX(1);
}

.work-steps .now::after {
  transform: scaleX(1);
  transition: transform var(--beat) linear;
}

.work-steps .start::after {
  transform: scaleX(0);
  transition: none;
}

/* On a computer wide enough, the first screen stands on one grid: the
   words at the left, the work at the right, on the bar's edges. The work and its steps stand together as one
   block, and that block and the words are centered in the height left
   under the bar (two equal spacer rows around them), so on a tall screen
   nothing drifts apart. The row is split 387 to 613 between the words and
   the work, 440 and 696 at the hero's full width. The headline there is
   the display size held to 57, so its two lines fit the words' column; the
   Mac takes nearly the work's whole width. From width-computer (1024). */
@media (width >= 1024px) {
  .intro {
    --row: calc(min(var(--hero-width), 100% - 2 * var(--space-12)) - var(--space-12));
    display: grid;
    grid-template-columns: 1fr calc(var(--row) * 0.387) var(--space-12) calc(var(--row) * 0.613) 1fr;
    grid-template-rows: 1fr auto auto 1fr;
    min-height: min(100svh, var(--hero-tall));
    padding-bottom: var(--space-8);
  }

  .hero {
    grid-column: 2;
    grid-row: 2 / 4;
    align-self: center;
    display: flex;
    flex-direction: column;
    align-items: flex-start;
    gap: var(--space-6);
    width: auto;
    margin: 0;
  }

  .hero h1 {
    --size-display: clamp(var(--size-display-min), 4.3vw, var(--hero-display-max));
  }

  .hero-side {
    gap: var(--space-8);
  }

  .work {
    grid-column: 4;
    grid-row: 2;
    width: auto;
    margin: var(--space-12) 0 0;
  }

  /* The steps on the line of the AI's label, at the work's right edge. */
  .work-steps {
    grid-column: 4;
    grid-row: 3;
    justify-content: flex-end;
    margin-top: calc(var(--space-4) + var(--space-1));
  }

  .work-devices {
    aspect-ratio: 100 / 80.93;
  }

  .work-app {
    width: 96cqw;
  }

  .work-chat {
    top: 10cqw;
    width: 34cqw;
  }

  /* Each label stands by its own device on the page's ground, never over a
     screen: the AI's a step under the iPhone's foot at its left edge (the
     box's foot), Omand's a step above the Mac's top at its right edge. The
     work holds a margin above it for Omand's label, so the label never
     reaches the bar; the steps sit at the work's right. */
  .work-tags {
    position: absolute;
    inset: 0;
    z-index: 3;
    margin: 0;
    pointer-events: none;
  }

  .work-place {
    position: absolute;
    top: calc(100% + var(--space-4));
    left: 0;
    max-width: none;
    white-space: nowrap;
  }

  .work-place + .work-place {
    top: auto;
    bottom: calc(100% + var(--space-3));
    right: 0;
    left: auto;
  }
}

/* Sections: full width, every one on the page's white ground, parted by
   space alone. The first screen is the brightest part of the page; below
   it the information comes first, and the same light touches it in a small
   dose: in each section a soft dawn of one field color at one side, the
   sides alternating section by section and the colors in turn (field-4,
   field-2, field-3, field-2, so the pointer's blue comes every other
   section), on a page of any length. The first section's dawn starts lower,
   clear of the first screen or the page's head. A section stands above the
   pointer's light as a whole, its dawn inside it, and its sides clip the
   dawn. */
.section {
  position: relative;
  z-index: 2;
  overflow-x: clip;
  padding: var(--space-16) 0;
}

.section::before {
  --tone: var(--field-4);
  content: "";
  position: absolute;
  top: -10%;
  z-index: -1;
  width: min(70vw, 960px);
  aspect-ratio: 1;
  pointer-events: none;
  opacity: 0.32;
  background: radial-gradient(closest-side, var(--tone), transparent);
}

.section:nth-child(odd)::before {
  left: -30%;
}

.section:nth-child(even)::before {
  --tone: var(--field-2);
  right: -30%;
}

.section:nth-child(4n + 3)::before {
  --tone: var(--field-3);
}

.section:first-child::before {
  top: 10%;
}

/* A dawn spills over its section's edges, so neighbors blend; the page
   still ends at the footer, so the sections' parent clips what spills past
   its foot. */
main {
  overflow-y: clip;
}

h2 {
  font-family: var(--font-display);
  font-weight: 700;
  font-size: var(--size-headline);
  line-height: min(var(--line-headline-max), round(var(--size-headline) + var(--line-headline-min) - var(--size-headline-min), 4px));
  letter-spacing: -0.02em;
  max-width: 22ch;
  text-wrap: balance;
}

/* Every name of a block, a page, a step or a promise is a title: the text
   face in semibold; Syne is kept for the two headlines and the wordmark. */
h3 {
  font-family: var(--font-text);
  font-size: var(--size-title);
  font-weight: 600;
  letter-spacing: -0.01em;
  line-height: var(--line-title);
}

.section-lede {
  margin-top: var(--space-6);
  max-width: 36em;
  font-size: var(--size-lede);
  line-height: var(--line-lede);
  color: var(--ink-soft);
  text-wrap: pretty;
}

/* A step: a mark (a number or an icon on its tile), a title and one plain
   line; the mark leads the eye, so no rule is drawn. */
.steps b {
  font-family: var(--font-text);
  font-weight: 600;
  font-size: var(--size-title);
  letter-spacing: -0.01em;
  line-height: var(--line-title);
}

/* A step's tile: mist, one step off the white ground, ink on it, no color
   of its own. */
.step-n {
  width: var(--tile);
  height: var(--tile);
  display: grid;
  place-items: center;
  border-radius: var(--radius-control);
  corner-shape: squircle;
  background: var(--mist);
}

.steps li > span:last-child {
  font-size: var(--size-body);
  color: var(--ink-soft);
  text-wrap: pretty;
}

/* Icons: Omand's own, solid ink shapes with one part in the accent
   (design/assets/Icons). */
.ico {
  width: var(--icon);
  height: var(--icon);
  flex: none;
  fill: currentColor;
}

.ico .accent {
  fill: var(--accent);
}

/* A tag: a role, a kind or a verdict in a word or two, beside a name, in a
   tile's picture or in a comparison's cell. */
.chip {
  display: inline-flex;
  align-items: center;
  height: var(--space-6);
  padding: 0 var(--space-2);
  border-radius: var(--radius-tag);
  font-size: var(--size-label);
  font-weight: 600;
  line-height: var(--line-label);
  white-space: nowrap;
}

.chip.blue {
  background: var(--accent);
}

.chip.strong {
  background: var(--ink);
  color: var(--on-ink);
}

/* Material: what arrived as it is, one step off its paper or glass
   ground, never an outline. */
.chip.material {
  background: var(--mist);
  color: var(--ink-soft);
}

/* The second brain, one slide at a time, right after the first screen: on a
   stage, a Mac with the app at its computer size and an iPhone beside it
   with the same part on a phone, and under the stage the slide's words with
   a numbered step for each slide. The stage is no panel: the devices stand
   on the section's ground in their own shadow, the section's dawn behind
   them. The first three slides are stills of the app, full screen on the
   Mac and under the iPhone's drawn status bar; the last four are scenes
   recorded with their own title bar and the iPhone's outline (`recorded`),
   the Mac's playing and the iPhone's standing at their first frame. On a
   phone the Mac is an iPhone showing the phone's pictures, and plays the
   phone's scenes. */
.tour-head {
  text-align: center;
}

.tour-head h2,
.tour-head .section-lede {
  margin-inline: auto;
}

.tour {
  margin-top: var(--space-16);
}

/* The stage is held to the screen's height less the steps and the slide's
   words under it, so the devices and the words are in view together. */
.tour-stage {
  width: min(var(--hero-width), 100% - 2 * var(--space-12), (100svh - var(--tour-words-tall)) * 100 / 62);
  margin: 0 auto;
  aspect-ratio: 100 / 62;
}

.tour-mac {
  left: 5cqw;
  top: 6cqw;
  width: 76cqw;
}

.tour-phone {
  right: 4cqw;
  top: 12.4cqw;
  z-index: 1;
  width: 19cqw;
}

.tour-mac img,
.tour-phone img {
  display: block;
  width: 100%;
  height: auto;
}

/* A recorded phone scene carries a flat outline of its own; scaled so its
   screen fills the drawn one, the outline falls outside the screen's edge,
   and both devices share one finish. Its status bar is the recording's. */
.recorded :is(.tour-mac, .tour-phone) .status-bar {
  display: none;
}

.recorded :is(.tour-mac, .tour-phone) img {
  position: absolute;
  left: 50%;
  top: -1.422%;
  height: 102.844%;
  width: auto;
  translate: -50% 0;
}

/* On a computer the app fills the Mac's screen from its top left: a still
   at 1280 by 800 points, a recorded scene at 1282 by 846 with its own title
   bar, 45 points, held above the screen's top edge, so only the app shows.
   The screen is a little narrower than the app, so its right edge runs past
   the screen's. */
@media (width >= 640px) {
  .tour-mac .window-view {
    height: 100%;
    aspect-ratio: auto;
  }

  .tour-mac .window-view img {
    width: 100%;
    height: 100%;
    object-fit: cover;
    object-position: left top;
  }

  .recorded .tour-mac .window-view img {
    position: absolute;
    left: 0;
    top: calc(-45 / 801 * 100%);
    width: auto;
    height: calc(846 / 801 * 100%);
    object-fit: fill;
    translate: none;
  }
}

.tour figcaption {
  margin-top: var(--space-8);
  display: flex;
  flex-direction: column;
  align-items: center;
  text-align: center;
}

/* Without the script every slide's words stand as a list: each title in
   semibold, its line under it. */
.tour-lines {
  display: flex;
  flex-direction: column;
  gap: var(--space-4);
  text-wrap: pretty;
}

.tour-lines li {
  display: flex;
  flex-direction: column;
  gap: var(--space-1);
}

.tour-lines b {
  font-weight: 600;
  color: var(--ink);
}

.tour-lines span {
  color: var(--ink-soft);
}

/* With the script, one slide's words show at a time, under the numbered
   steps: its title as a name and its line beside it, with a progress line
   under them that fills while the slide plays. Two lines are held for the
   words, so a longer slide moves nothing. The step showing stands on the
   accent, the others fade back. */
.tour.stepped .tour-lines {
  min-height: calc(2 * var(--line-lede) + var(--space-4) + var(--flow-line));
}

.tour.stepped .tour-lines li:not(.now) {
  display: none;
}

.tour.stepped .tour-lines li {
  display: block;
  max-width: 40em;
}

.tour.stepped .tour-lines b {
  margin-right: var(--space-2);
  font-family: var(--font-text);
  font-size: var(--size-title);
  font-weight: 600;
  line-height: var(--line-title);
  letter-spacing: -0.01em;
}

.tour.stepped .tour-lines span {
  font-size: var(--size-lede);
  line-height: var(--line-lede);
}

.tour.stepped .tour-lines li::after {
  content: "";
  display: block;
  height: var(--flow-line);
  margin-top: var(--space-4);
  border-radius: var(--flow-line);
  background: linear-gradient(var(--ink), var(--ink)) no-repeat 0 0 / 100% 100%, var(--line);
  visibility: hidden;
}

.tour.playing .tour-lines .now::after {
  visibility: visible;
}

.tour-steps {
  display: flex;
  flex-wrap: wrap;
  justify-content: center;
  gap: var(--space-1);
  margin-bottom: var(--space-6);
}

.tour-steps button {
  width: var(--icon-tile);
  height: var(--icon-tile);
  padding: 0;
  border: 0;
  border-radius: var(--radius-tag);
  background: none;
  color: var(--ink-soft);
  font: 600 var(--size-label) / var(--line-label) var(--font-text);
  cursor: pointer;
}

.tour-steps button[aria-current] {
  background: var(--accent);
  color: var(--ink);
}

/* Tiles: cards in one grid, each a small picture of itself, a title and
   one line, the promises four in a row. Under the row lies a soft pool of
   field-2, blurred, for the glass to show. */
.tiles {
  position: relative;
  margin-top: var(--space-12);
  display: grid;
  grid-template-columns: repeat(4, 1fr);
  gap: var(--space-4);
}

.tiles::before {
  content: "";
  position: absolute;
  inset: -12% -6%;
  z-index: -1;
  pointer-events: none;
  background: radial-gradient(55% 70% at 50% 50%, color-mix(in srgb, var(--field-2) 42%, transparent), transparent 72%);
  filter: blur(var(--space-6));
}

/* Every card: paper under the card's shadow, unless it is glass. */
.tiles li,
.plan,
.table-card,
.short,
.waitlist {
  position: relative;
  background: var(--paper);
  box-shadow: var(--shadow-card);
}

/* A card is frosted glass: clear white over what lies behind it, blurred
   and a little saturated, lit white along its top edge with a white
   hairline inside and a faint ink one outside, a fine grain on it, the
   card's shadow under it. Glass reads only with something behind it, so a
   card is glass where light lies under it: tiles, the form and the parts
   of an explainer always (a pool of light under each row of tiles and
   each explainer, the section's dawn behind the form), every other card
   where the pointer's light runs; elsewhere it is plain paper under the
   card's shadow. */
:is(.tiles li, .plan, .waitlist),
.explain :is(.tool, .ai, .base, .sheet, .conversation, .contents),
.glass :is(.table-card, .short) {
  background:
    var(--grain) 0 0 / 160px,
    linear-gradient(160deg, color-mix(in srgb, var(--paper) 72%, transparent), color-mix(in srgb, var(--paper) 46%, transparent));
  backdrop-filter: blur(var(--space-6)) saturate(1.7);
  box-shadow: var(--glass-edges), var(--shadow-card);
}

.tiles li {
  display: flex;
  flex-direction: column;
  gap: var(--space-2);
  padding: var(--space-6);
  border-radius: var(--radius-card);
  corner-shape: squircle;
}

/* The tile under the pointer lifts a step, its shadow deepening. It moves
   as it rose into view (Motion, below), so its transition carries the
   rise's too. */
.glass .tiles li {
  transition: opacity 500ms ease, translate 500ms ease, box-shadow 500ms ease;
}

.glass .tiles li:hover {
  translate: 0 calc(-1 * var(--space-1));
  box-shadow: var(--glass-edges), var(--shadow-lift);
}

.tiles p {
  color: var(--ink-soft);
  text-wrap: pretty;
}

.tile-art {
  height: var(--art-height);
  margin-bottom: var(--space-4);
  display: flex;
  flex-wrap: wrap;
  align-content: center;
  align-items: center;
  gap: var(--space-2);
}

/* In a picture the tags grow to read as the things themselves: AI by name,
   formats, sections. */
.tile-art .chip {
  gap: var(--space-1);
  height: var(--space-8);
  padding: 0 var(--space-3);
  border-radius: var(--radius-control);
  corner-shape: squircle;
}

.tile-art .chip .ico {
  width: var(--space-4);
  height: var(--space-4);
}

.tile-art > .ico {
  width: var(--space-6);
  height: var(--space-6);
}

/* Explainers: pictures that show how something reaches Omand, read in
   seconds, drawn from design/components' parts. One grammar for all of
   them: where it comes from, the light that carries it, Omand where it
   lands. Each is one `.explain`, a picture with its alt text, its parts
   laid out by grid and its flows drawn between them by site.js. These
   rules are the picture at rest, complete without the script and where
   the system asks for less motion: each scene on the beat the design
   names. Its motion is under Motion, below. A sheet's sketch, a wave's
   bars and a flow's strokes are the drawing's own proportions, written
   where they are drawn. */
.explain {
  position: relative;
  isolation: isolate;
  display: grid;
  grid-auto-flow: column;
  justify-content: space-between;
  align-items: center;
  max-width: var(--explain-width);
  margin: var(--space-12) auto 0;
}

/* Under each explainer a soft pool of field-2, blurred, so its glass has
   light to show. */
.explain::before {
  content: "";
  position: absolute;
  inset: -8% -4%;
  z-index: -1;
  pointer-events: none;
  background: radial-gradient(55% 65% at 50% 50%, color-mix(in srgb, var(--field-2) 40%, transparent), transparent 72%);
  filter: blur(var(--space-6));
}

.explain .part {
  position: relative;
  z-index: 1;
  display: grid;
  justify-items: center;
  gap: var(--space-3);
}

/* Flow: a dotted rail in faint ink from where something comes from to
   where it lands. On it a comet of light runs while the picture moves:
   its head light-core, its tail fading into a field-2 glow; paths carry
   pathLength="100", so a comet's length is a share of its path. At rest
   the rail stands alone. */
.explain .flow {
  position: absolute;
  inset: 0;
  z-index: 0;
  width: 100%;
  height: 100%;
  overflow: visible;
  pointer-events: none;
  fill: none;
  stroke-linecap: round;
}

.explain .rail {
  stroke: color-mix(in srgb, var(--ink) 26%, transparent);
  stroke-width: 2;
  stroke-dasharray: 0 7;
}

.explain .run {
  --l: 4;
  visibility: hidden;
  stroke-dasharray: var(--l) 300;
  stroke-dashoffset: var(--l);
}

.explain .glow {
  --l: 26;
  stroke: var(--field-2);
  stroke-width: 12;
  opacity: 0.85;
  filter: blur(5px);
}

.explain .tail {
  --l: 22;
  stroke: var(--field-2);
  stroke-width: 4;
}

.explain .head {
  --l: 6;
  stroke: var(--light-core);
  stroke-width: 5;
}

/* Where light lands, a ring of field-2 opens once and fades; at rest it
   is closed. */
.explain .land {
  position: absolute;
  inset: calc(-1 * var(--space-2));
  border-radius: inherit;
  pointer-events: none;
  box-shadow: 0 0 0 2px var(--field-2), 0 0 var(--space-6) var(--field-2);
  opacity: 0;
}

/* A tool's own mark, in ink. Only the marks the pictures show are here. */
.explain .logo {
  display: block;
  width: var(--explain-mark);
  height: var(--explain-mark);
  background: var(--ink);
  -webkit-mask: var(--logo) center / contain no-repeat;
  mask: var(--logo) center / contain no-repeat;
}

.logo.airtable { --logo: url("/logos/airtable.svg"); }
.logo.asana { --logo: url("/logos/asana.svg"); }
.logo.claude { --logo: url("/logos/claude.svg"); }
.logo.dropbox { --logo: url("/logos/dropbox.svg"); }
.logo.gmail { --logo: url("/logos/gmail.svg"); }
.logo.googlecalendar { --logo: url("/logos/googlecalendar.svg"); }
.logo.googlesheets { --logo: url("/logos/googlesheets.svg"); }
.logo.hubspot { --logo: url("/logos/hubspot.svg"); }
.logo.notion { --logo: url("/logos/notion.svg"); }
.logo.openai { --logo: url("/logos/openai.svg"); }
.logo.paypal { --logo: url("/logos/paypal.svg"); }
.logo.perplexity { --logo: url("/logos/perplexity.svg"); }
.logo.quickbooks { --logo: url("/logos/quickbooks.svg"); }
.logo.shopify { --logo: url("/logos/shopify.svg"); }
.logo.stripe { --logo: url("/logos/stripe.svg"); }
.logo.telegram { --logo: url("/logos/telegram.svg"); }
.logo.whatsapp { --logo: url("/logos/whatsapp.svg"); }
.logo.xero { --logo: url("/logos/xero.svg"); }

/* Sources: the tools a company's AI reaches, as a cloud of their marks on
   glass chips; far ones smaller and softer, so the cloud has depth. */
.explain .sources {
  position: relative;
  width: var(--explain-sources);
  max-width: 100%;
  aspect-ratio: 1;
}

.explain .tool {
  position: absolute;
  left: var(--x);
  top: var(--y);
  translate: -50% -50%;
  display: grid;
  place-items: center;
  width: var(--explain-tool);
  height: var(--explain-tool);
  border-radius: var(--radius-control);
  corner-shape: squircle;
}

.explain .tool .logo {
  width: var(--explain-tool-mark);
  height: var(--explain-tool-mark);
}

.explain .tool.far {
  width: var(--explain-tool-far);
  height: var(--explain-tool-far);
  opacity: 0.55;
  filter: blur(0.5px);
}

.explain .tool.far .logo {
  width: var(--explain-tool-mark-far);
  height: var(--explain-tool-mark-far);
}

/* A tool, or a file, lights where its light leaves; at rest none is lit. */
.explain :is(.tool.lit, .files .sheet)::after {
  content: "";
  position: absolute;
  inset: -3px;
  border-radius: inherit;
  pointer-events: none;
  box-shadow: 0 0 0 2px var(--field-2), 0 0 var(--space-6) var(--field-2);
  opacity: 0;
}

/* A part's name in one to three words: a paper pill with the card's
   shadow and a dot, accent for Omand. */
.explain .caption {
  display: inline-flex;
  align-items: center;
  gap: var(--space-2);
  height: var(--space-8);
  padding: 0 var(--space-3);
  border-radius: 999px;
  background: var(--paper);
  box-shadow: var(--shadow-card);
  font-size: var(--size-label);
  font-weight: 600;
  line-height: var(--line-label);
  white-space: nowrap;
}

.explain .caption::before {
  content: "";
  width: var(--space-2);
  height: var(--space-2);
  border-radius: 50%;
  background: var(--dot, var(--ink));
}

.explain .caption.omand {
  --dot: var(--accent);
}

/* The AI: the company's own, one glass chip larger than a tool's, where
   the flows from the tools meet. It turns through the AI an owner can
   connect, by mark or, where the system has no mark, by name; at rest it
   shows the first. */
.explain .ai {
  position: relative;
  display: grid;
  place-items: center;
  width: var(--explain-ai);
  height: var(--explain-ai);
  border-radius: var(--radius-card);
  corner-shape: squircle;
}

.explain .ai > * {
  grid-area: 1 / 1;
  opacity: 0;
}

.explain .ai > :first-child {
  opacity: 1;
}

.explain .ai .logo {
  width: var(--explain-ai-mark);
  height: var(--explain-ai-mark);
}

.explain .ai-word {
  font-style: normal;
  font-weight: 600;
}

/* Base: Omand in a picture, a glass card headed Second brain and its
   sections, each a mist row with its mark and how much it holds. What
   arrives lands in the top row, its source under it; at rest the first
   arrival stands there. */
.explain .base {
  position: relative;
  display: grid;
  gap: var(--space-2);
  width: 100%;
  max-width: var(--explain-base);
  padding: var(--space-3);
  border-radius: var(--radius-card);
  corner-shape: squircle;
}

.explain .base-head {
  display: flex;
  align-items: center;
  gap: var(--space-2);
  padding: var(--space-1) var(--space-2) var(--space-2);
  font-weight: 600;
}

.explain .base-head img {
  width: var(--space-6);
  height: var(--space-6);
}

.explain .row {
  position: relative;
  display: grid;
  grid-template-columns: var(--space-8) 1fr auto;
  align-items: center;
  gap: var(--space-3);
  min-height: var(--explain-row);
  padding: var(--space-1) var(--space-3) var(--space-1) var(--space-1);
  border-radius: var(--radius-control);
  corner-shape: squircle;
  background: var(--mist);
}

.explain .row > i {
  display: grid;
  place-items: center;
  width: var(--space-8);
  height: var(--space-8);
  border-radius: var(--radius-tag);
  background: var(--paper);
}

.explain .row > i :is(.ico, .logo) {
  width: var(--explain-mark);
  height: var(--explain-mark);
}

.explain .row b {
  font-size: var(--size-label);
  line-height: var(--line-label);
}

.explain :is(.row, .say) small {
  display: block;
  font-size: var(--explain-words);
  line-height: 16px;
  color: var(--ink-soft);
}

.explain .row em {
  font-style: normal;
  font-size: var(--size-label);
  line-height: var(--line-label);
  color: var(--ink-soft);
  font-variant-numeric: tabular-nums;
}

.explain .slot {
  display: grid;
}

.explain .slot > .row {
  grid-area: 1 / 1;
  opacity: 0;
}

.explain .slot > .row:first-child {
  opacity: 1;
}

/* Material: what a company already has, as it is: a small glass sheet
   turned a little, its kind (a tag, or a chat's mark) and a sketch of what
   it holds: lines, cells, a photo's ground, a chat's bubbles, a voice's
   wave. */
.explain .sheet {
  position: relative;
  display: grid;
  align-content: space-between;
  gap: var(--space-3);
  width: var(--explain-sheet-width);
  height: var(--explain-sheet-height);
  padding: var(--space-2);
  border-radius: var(--radius-control);
  corner-shape: squircle;
  rotate: var(--r, 0deg);
}

.explain .kind {
  display: flex;
  align-items: center;
  gap: var(--space-2);
}

.explain .kind .chip {
  height: var(--explain-mark);
  padding: 0 6px;
  font-size: var(--explain-words);
}

.explain .sketch {
  display: grid;
  gap: 5px;
}

.explain .sketch i {
  display: block;
  height: 6px;
  border-radius: 3px;
  background: var(--heat-1);
}

.explain .sketch i:nth-child(2) { width: 82%; }
.explain .sketch i:nth-child(3) { width: 64%; }
.explain .sketch.cells { grid-template-columns: repeat(3, 1fr); gap: 3px; }
.explain .sketch.cells i { width: auto; height: 10px; border-radius: 2px; }
.explain .sketch.cells i:nth-child(-n + 3) { background: var(--heat-2); }
.explain .sketch.photo i { height: 36px; width: 100%; border-radius: var(--radius-tag); background: linear-gradient(160deg, var(--heat-1), var(--heat-2)); }
.explain .sketch.bubbles i { height: 12px; border-radius: 6px; width: 70%; }
.explain .sketch.bubbles i:nth-child(2) { justify-self: end; width: 55%; background: var(--accent-soft); }
.explain .sketch.bubbles i:nth-child(3) { width: 45%; }
.explain .sketch.wave { display: flex; align-items: center; gap: 3px; height: 28px; }
.explain .sketch.wave i { width: 4px; height: var(--h); border-radius: 2px; background: var(--ink); }

/* The files, as a loose stack. */
.explain .sheets {
  position: relative;
  width: var(--explain-sheets-width);
  height: var(--explain-sheets-height);
}

.explain .sheets .sheet {
  position: absolute;
  left: var(--sx);
  top: var(--sy);
}

/* A small sheet, as a file attached in a chat. A page from Omand takes
   Omand's mark for its kind. */
.explain .sheet.small {
  width: var(--explain-small-width);
  height: var(--explain-small-height);
  padding: 6px;
  gap: var(--space-1);
}

.explain .small .kind .chip {
  height: var(--explain-mark-small);
  padding: 0 4px;
}

.explain .small .kind :is(.logo, img) {
  width: var(--explain-mark-small);
  height: var(--explain-mark-small);
}

.explain .small .kind img {
  border-radius: 4px;
}

.explain .small .sketch { gap: 3px; }
.explain .small .sketch i { height: 4px; }
.explain .small .sketch.cells i { height: 6px; }
.explain .small .sketch.bubbles i { height: 7px; }
.explain .small .sketch.wave { height: 14px; gap: 2px; }
.explain .small .sketch.wave i { width: 3px; height: var(--h); }
.explain .small .sketch.photo i { height: 18px; }

/* Chat: a conversation on glass, the person's question on accent-soft, the
   files attached under it, the AI's answer on mist, and at its foot how
   much of the person's AI limit it used, a bar with no figure. The files
   inside it are parts inside a card: mist, not glass. */
.explain .conversation {
  position: relative;
  display: grid;
  gap: var(--space-3);
  width: 100%;
  max-width: var(--explain-chat);
  padding: var(--space-3);
  border-radius: var(--radius-card);
  corner-shape: squircle;
}

.explain .conversation .sheet {
  background: var(--mist);
  backdrop-filter: none;
  box-shadow: none;
}

.explain .say {
  max-width: var(--explain-say);
  padding: var(--space-3) var(--space-4);
  border-radius: 20px;
  corner-shape: squircle;
  font-size: var(--size-label);
  line-height: var(--line-label);
}

.explain .say small {
  margin-bottom: var(--space-1);
}

.explain .say.person {
  justify-self: end;
  background: var(--accent-soft);
}

.explain .say.answer {
  justify-self: start;
  background: var(--mist);
}

.explain :is(.attached, .load) {
  display: grid;
  grid-template-columns: repeat(4, var(--explain-small-width));
  justify-content: end;
  gap: var(--space-2);
}

.explain .attached.one {
  grid-template-columns: var(--explain-small-width);
}

/* The answer and the dots that think before it share one place; at rest
   the answer stands. */
.explain .turn {
  display: grid;
  justify-items: start;
  align-items: start;
}

.explain .turn > * {
  grid-area: 1 / 1;
}

.explain .think {
  display: flex;
  gap: 4px;
  padding: var(--space-3) var(--space-4);
  border-radius: 20px;
  corner-shape: squircle;
  background: var(--mist);
  opacity: 0;
}

.explain .think i {
  width: 6px;
  height: 6px;
  border-radius: 50%;
  background: var(--ink-soft);
  opacity: 0.4;
}

.explain .use {
  display: grid;
  grid-template-columns: auto 1fr;
  align-items: center;
  gap: var(--space-2);
  padding: 0 var(--space-1);
  font-size: var(--explain-words);
  line-height: 16px;
  color: var(--ink-soft);
}

.explain .use b {
  display: block;
  height: 6px;
  border-radius: 3px;
  background: var(--mist);
  overflow: hidden;
}

.explain .use b i {
  display: block;
  height: 100%;
  width: var(--use);
  border-radius: inherit;
  background: var(--ink);
}

/* Load: what a chat carries. Files fill it up to its line, named Chat
   limit; those past it stand as faint traces, dropped out, unread. */
.explain .load-line {
  grid-column: 1 / -1;
  display: flex;
  align-items: center;
  gap: var(--space-2);
  font-size: var(--explain-words);
  line-height: 16px;
  color: var(--ink-soft);
  white-space: nowrap;
}

.explain .load-line::before {
  content: "";
  flex: 1;
  height: 2px;
  background: radial-gradient(circle, color-mix(in srgb, var(--ink) 26%, transparent) 1px, transparent 1.5px) 0 50% / 7px 2px repeat-x;
}

.explain .load .past {
  opacity: 0.12;
  translate: 0 var(--space-2);
}

/* Contents: Omand as a book's contents, every section with how much it
   holds and a dotted leader between. The light stands on the one row the
   question needs (--pick, counted from 0), and only that row flows on. */
.explain .contents {
  position: relative;
  display: grid;
  width: 100%;
  max-width: var(--explain-contents);
  padding: var(--space-3) var(--space-4) var(--space-4);
  border-radius: var(--radius-card);
  corner-shape: squircle;
}

.explain .contents .base-head {
  padding-left: 0;
  padding-right: 0;
}

.explain .rows {
  position: relative;
}

.explain .rows ol {
  display: grid;
}

.explain .rows li {
  position: relative;
  display: flex;
  align-items: baseline;
  gap: var(--space-2);
  height: var(--explain-contents-row);
  padding: 6px 0;
  font-size: var(--size-label);
  line-height: var(--line-label);
}

.explain .rows li::after {
  content: "";
  order: 1;
  flex: 1;
  height: 2px;
  background: radial-gradient(circle, color-mix(in srgb, var(--ink) 26%, transparent) 1px, transparent 1.5px) 0 50% / 6px 2px repeat-x;
}

.explain .rows li em {
  order: 2;
  font-style: normal;
  color: var(--ink-soft);
  font-variant-numeric: tabular-nums;
}

.explain .reader {
  position: absolute;
  left: calc(-1 * var(--space-2));
  right: calc(-1 * var(--space-2));
  top: calc(var(--pick) * var(--explain-contents-row));
  height: var(--explain-contents-row);
  border-radius: var(--radius-tag);
  background: color-mix(in srgb, var(--field-2) 45%, transparent);
  box-shadow: 0 0 var(--space-6) var(--field-2);
}

/* Versus: the way without Omand and Omand's, side by side under their
   captions. The way without stands in faint ink on plain paper, with no
   glass and no light: the light is Omand's alone. */
.explain.book {
  display: block;
}

.explain .versus {
  position: relative;
  z-index: 1;
  display: flex;
  justify-content: space-between;
  align-items: flex-start;
  gap: var(--space-16);
}

.explain .versus > * {
  display: grid;
  justify-items: center;
  gap: var(--space-4);
}

.explain .parts {
  display: flex;
  align-items: flex-start;
  gap: var(--space-6);
}

.explain .without {
  --field-2: transparent;
  --light-core: transparent;
}

.explain .without :is(.conversation, .sheet) {
  background: var(--paper);
  backdrop-filter: none;
  box-shadow: 0 0 0 1px color-mix(in srgb, var(--ink) 8%, transparent);
}

.explain .without .parts {
  opacity: 0.55;
  filter: grayscale(1);
}

/* Below a computer the parts stand in a column, one under the next, and a
   flow runs down between them: in a row they need the whole of a
   computer's width. */
@media (width < 1024px) {
  .explain {
    grid-auto-flow: row;
    justify-content: center;
    gap: var(--space-16);
  }

  .explain .versus,
  .explain .parts {
    flex-direction: column;
    align-items: center;
  }
}

/* Path: how working with Omand goes, as four stations in a row joined by
   flows, each a part over its title and one line: the first conversation,
   the files, the tools, and Omand, where a gap is found, asked of the one
   who knows, filled with its source, and the AI's conclusion lands under
   it. Under the first three their phase, under the fourth its own with the
   mark of a step that repeats, each on a flow's dotted rail. At rest it
   stands on the gap filled, the conclusion under it. Its titles and lines
   are the page's words; each part is a picture with its alt text. */
.explain.path {
  max-width: none;
  grid-auto-flow: row;
  grid-template-columns: repeat(3, minmax(0, 1fr)) var(--explain-base);
  grid-template-rows: auto auto auto auto;
  justify-content: stretch;
  align-items: stretch;
  column-gap: var(--space-6);
}

.path .station {
  position: relative;
  z-index: 1;
  grid-row: 1 / span 3;
  display: grid;
  grid-template-rows: subgrid;
  justify-items: center;
}

.path .station.daily {
  grid-column: 4;
}

.path .station > :first-child {
  align-self: center;
  margin-bottom: var(--space-6);
}

/* A title that takes two lines starts higher, so every station's line
   starts on one line. */
.path .station h3 {
  align-self: end;
  text-align: center;
}

.path .station p {
  max-width: 16em;
  margin-top: var(--space-2);
  color: var(--ink-soft);
  text-align: center;
  text-wrap: balance;
}

.path .phase {
  grid-row: 4;
  position: relative;
  display: grid;
  align-content: start;
  gap: var(--space-1);
  margin-top: var(--space-12);
  padding-top: var(--space-4);
}

.path .phase.start {
  grid-column: 1 / 4;
}

.path .phase.daily {
  grid-column: 4;
}

.path .phase::before {
  content: "";
  position: absolute;
  top: 0;
  left: 0;
  right: 0;
  height: 2px;
  background: radial-gradient(circle, color-mix(in srgb, var(--ink) 26%, transparent) 1px, transparent 1.5px) 0 50% / 7px 2px repeat-x;
}

.path .phase h3 {
  display: flex;
  align-items: center;
  gap: var(--space-2);
}

.path .phase p {
  color: var(--ink-soft);
}

/* The first conversation: the AI's question on glass, the owner's answer
   on accent-soft with the wave of her voice. */
.path .talk {
  display: grid;
  gap: var(--space-2);
  width: min(var(--explain-talk), 100%);
}

.path .talk .say:first-child {
  background:
    var(--grain) 0 0 / 160px,
    linear-gradient(160deg, color-mix(in srgb, var(--paper) 72%, transparent), color-mix(in srgb, var(--paper) 46%, transparent));
  backdrop-filter: blur(var(--space-6)) saturate(1.7);
  box-shadow: var(--glass-edges), var(--shadow-card);
}

.path .voice {
  display: flex;
  align-items: center;
  gap: 3px;
  height: 20px;
  margin-top: var(--space-2);
}

.path .voice i {
  width: 3px;
  height: var(--h);
  border-radius: 2px;
  background: var(--ink);
}

/* The files side by side, and the tools' marks two by two. */
.path .sheets {
  width: var(--explain-row-of-files-width);
  height: var(--explain-row-of-files-height);
}

.path .tools {
  display: grid;
  grid-template-columns: repeat(2, var(--explain-tool));
  gap: var(--space-3);
}

.path .tools .tool {
  position: relative;
  left: auto;
  top: auto;
  translate: none;
}

/* Gap: a row with a dashed outline and its question in ink-faint, the one
   outlined part, because it is empty; answered, it fills like any row,
   its source under it. At rest it stands filled, so its empty state and
   who the AI asks stand hidden. */
.path .gap {
  display: grid;
}

.path .gap > * {
  grid-area: 1 / 1;
}

.path .gap .empty {
  background: transparent;
  box-shadow: inset 0 0 0 1.5px color-mix(in srgb, var(--ink) 28%, transparent);
  color: var(--ink-faint);
  opacity: 0;
}

.path .gap .empty > i {
  background: transparent;
}

.path .gap .empty small {
  opacity: 0;
}

/* Check: the company's AI reading the base, a band of field-2 passing
   down it; at rest it is gone. */
.path .check {
  position: absolute;
  inset: 0;
  border-radius: inherit;
  overflow: hidden;
  pointer-events: none;
}

.path .check::before {
  content: "";
  position: absolute;
  left: 0;
  right: 0;
  top: -30%;
  height: 30%;
  background: linear-gradient(to bottom, transparent, color-mix(in srgb, var(--field-2) 45%, transparent) 70%, var(--field-2) 96%, transparent);
  mix-blend-mode: multiply;
}

/* Below a computer the stations stand in a column, each phase after its
   own, and the light runs down the column's edge, clear of the words. */
@media (width < 1024px) {
  .explain.path {
    grid-template-columns: minmax(0, 1fr);
    grid-template-rows: none;
    gap: 0;
  }

  .path :is(.station, .station.daily, .phase.start, .phase.daily) {
    grid-row: auto;
    grid-column: 1;
  }

  .path .station {
    grid-template-rows: none;
  }

  .path .station > :last-child {
    margin-bottom: var(--space-8);
  }

  .path .phase {
    margin: 0 0 var(--space-16);
  }

  .path .phase:last-child {
    margin-bottom: 0;
  }
}

/* The EU's ring of twelve stars, in ink, around its name. */
.eu {
  width: var(--art-figure);
  height: var(--art-figure);
  fill: var(--ink);
}

/* The ring's letters: the text face, semibold, at the label size, counted
   in the ring's own 64-unit box. */
.eu text {
  font-family: var(--font-text);
  font-size: var(--size-label);
  font-weight: 600;
}

.tiles-next {
  margin-top: var(--space-8);
  display: flex;
  flex-wrap: wrap;
  gap: var(--space-2) var(--space-8);
  font-size: var(--size-label);
  line-height: var(--line-label);
  font-weight: 600;
}

/* The price, as pricing pages are read: the headline centered, the plan's
   two ways to pay as two cards side by side, each with its price as a key
   figure and its unit at the lede's size, its button and what it includes
   as a list of ticks. The
   cards are glass over a pool of field-2, as tiles are; the yearly card's
   button is the strong one, the monthly card's a quiet one in mist. */
.page-head.centered {
  padding-bottom: 0;
}

.page-head.centered .wrap {
  text-align: center;
}

.page-head.centered :is(h1, .lede) {
  margin-inline: auto;
}

.plans {
  position: relative;
  max-width: var(--plans-width);
  margin-inline: auto;
  display: grid;
  grid-template-columns: repeat(2, minmax(0, 1fr));
  gap: var(--space-6);
}

.plans::before {
  content: "";
  position: absolute;
  inset: -12% -6%;
  z-index: -1;
  pointer-events: none;
  background: radial-gradient(55% 70% at 50% 50%, color-mix(in srgb, var(--field-2) 42%, transparent), transparent 72%);
  filter: blur(var(--space-6));
}

.plan {
  display: flex;
  flex-direction: column;
  gap: var(--space-4);
  padding: var(--space-8);
  border-radius: var(--radius-card);
  corner-shape: squircle;
}

.plan h2 {
  display: flex;
  align-items: center;
  gap: var(--space-3);
  font-family: var(--font-text);
  font-size: var(--size-title);
  font-weight: 600;
  letter-spacing: -0.01em;
  line-height: var(--line-title);
}

.plan-price {
  font-size: var(--size-lede);
  line-height: var(--line-lede);
  color: var(--ink-soft);
}

.plan-price b {
  margin-right: var(--space-1);
  font-size: var(--size-figure);
  font-weight: 600;
  letter-spacing: -0.01em;
  line-height: var(--line-figure);
  color: var(--ink);
  font-variant-numeric: tabular-nums;
}

.plan .button {
  margin-top: var(--space-2);
  justify-content: center;
}

.button.quiet {
  background: var(--mist);
  color: var(--ink);
}

.button.quiet:hover {
  background: color-mix(in srgb, var(--mist) 88%, var(--ink));
}

.included {
  margin-top: var(--space-2);
  padding-top: var(--space-6);
  border-top: 1px solid var(--line);
  display: grid;
  gap: var(--space-3);
}

.included li {
  display: flex;
  align-items: start;
  gap: var(--space-3);
}

.plan-note,
.plan-join,
.table-note {
  color: var(--ink-soft);
  text-wrap: pretty;
}

.plan-join {
  margin-top: var(--space-8);
  text-align: center;
}

.table-note {
  margin-top: var(--space-4);
  max-width: 44em;
}

.table-note.checked {
  font-size: var(--size-label);
  line-height: var(--line-label);
}

/* Joining: the headline and its line across the section, then the steps
   of how the second brain grows beside the form on a computer, above it on
   a phone. */
.join {
  margin-top: var(--space-12);
  display: grid;
  grid-template-columns: minmax(0, 1fr) minmax(0, 1.2fr);
  gap: var(--space-16);
  align-items: start;
}

.steps {
  display: grid;
  gap: var(--space-6);
}

.steps li {
  display: grid;
  grid-template-columns: var(--tile) minmax(0, 1fr);
  column-gap: var(--space-4);
  align-content: center;
}

.step-n {
  grid-row: span 2;
  font-family: var(--font-text);
  font-weight: 600;
  font-size: var(--size-title);
  line-height: var(--line-title);
  color: var(--ink);
}

.step-n .ico {
  width: var(--icon-tile);
  height: var(--icon-tile);
}

.steps b {
  align-self: end;
}

/* The close of a page beyond the first: the strong action again, for a
   reader who came to the end. */

.closing .wrap {
  display: flex;
  flex-direction: column;
  align-items: center;
  text-align: center;
}

/* The waitlist: a form of plain fields on a card, the button its one strong
   action. Every word in it, a field's name, what a person types or picks,
   stands at the body's size, so the fields read as one even column. Every
   field works without the script; the trap field stays out of sight and out
   of the tab order, for bots only. */
.waitlist {
  width: 100%;
  max-width: var(--form-width);
  display: flex;
  flex-direction: column;
  gap: var(--space-6);
  padding: var(--space-8);
  border-radius: var(--radius-card);
  corner-shape: squircle;
  text-align: left;
}

.field-row {
  display: flex;
  flex-direction: column;
  gap: var(--space-2);
  min-width: 0;
  border: 0;
}

/* Two fields side by side share one grid of two rows, the names above and
   the fields under them, so a name that wraps never pushes its field below
   its neighbour's: each name sits on its field, the fields on one line. */
.field-pair {
  display: grid;
  grid-template-columns: repeat(2, minmax(0, 1fr));
  grid-template-rows: auto auto;
  column-gap: var(--space-6);
}

.field-pair > .field-row {
  display: grid;
  grid-row: span 2;
  grid-template-rows: subgrid;
  row-gap: var(--space-2);
}

.field-pair label {
  align-self: end;
}

.field-row label,
.field-row legend {
  font-size: var(--size-body);
  font-weight: 600;
}

.field-row small {
  font-size: var(--size-body);
  font-weight: 400;
  color: var(--ink-faint);
}

.field-row input:not([type="checkbox"]),
.field-row select {
  height: var(--control);
  padding: 0 var(--space-4);
  border: 1px solid var(--line);
  border-radius: var(--radius-control);
  corner-shape: squircle;
  background: var(--mist);
  color: var(--ink);
  font: inherit;
}

/* A choice drawn as the fields are, its words set in as theirs are; the
   system's own menu stays, so it works the same on every device. The
   chevron is a small triangle of ink at its right, drawn by two gradients. */
.field-row select {
  appearance: none;
  min-width: 0;
  padding-right: var(--space-12);
  background-image: linear-gradient(45deg, transparent 50%, var(--ink) 50%), linear-gradient(135deg, var(--ink) 50%, transparent 50%);
  background-size: var(--space-1) var(--space-1);
  background-position: calc(100% - var(--space-6)) 50%, calc(100% - var(--space-6) + var(--space-1)) 50%;
  background-repeat: no-repeat;
}

/* The AIs in an even grid: three to a row, two on a phone; each choice as
   tall as a finger needs. */
.choices {
  display: grid;
  grid-template-columns: repeat(3, minmax(0, 1fr));
  column-gap: var(--space-4);
}

.choices label {
  display: flex;
  align-items: center;
  gap: var(--space-2);
  min-height: var(--space-12);
  font-weight: 400;
}

.choices input {
  flex: none;
  width: var(--space-4);
  height: var(--space-4);
  margin: 0;
}

.waitlist .button {
  margin-top: 0;
  align-self: flex-start;
  border: 0;
  font: inherit;
  font-weight: 600;
  cursor: pointer;
}

.form-note {
  font-size: var(--size-label);
  line-height: var(--line-label);
  color: var(--ink-soft);
}

.trap {
  position: absolute;
  left: -100vw;
  width: 1px;
  height: 1px;
  overflow: hidden;
}

/* A page beyond the first: the bar and the page's headline on paper. The
   field stays at the landing's door. */
.page-head {
  background: var(--paper);
  padding-bottom: var(--space-16);
}

.page-head h1 {
  margin-top: var(--space-16);
  font-size: var(--size-headline);
  line-height: min(var(--line-headline-max), round(var(--size-headline) + var(--line-headline-min) - var(--size-headline-min), 4px));
  letter-spacing: -0.02em;
  max-width: 22ch;
}

.page-head .lede {
  max-width: 36em;
}

/* The bar's button: its words on one line, in a grid of one column, so
   the column can fold to nothing as the button steps aside. Each language's
   words fit a 390 phone beside the wordmark and the picker; a narrower
   screen cuts them with an ellipsis rather than push the bar past its edge. */
.bar-join {
  display: inline-grid;
  grid-template-columns: 1fr;
  margin: 0 var(--space-2) 0 0;
  height: var(--bar-button);
  padding: 0 var(--space-4);
}

.bar-join span {
  min-width: 0;
  overflow: hidden;
  white-space: nowrap;
  text-overflow: ellipsis;
}

/* The bar's button steps aside while a page's own waitlist button or form
   is on screen, so two never stand together, and on the page a person
   lands on once they joined (`joined`, without the script too). It folds
   away with its place, so the language picker holds the bar's right edge
   and no gap stands beside it. */
.at-top .intro .bar-join,
.join-in-view .bar-join,
.joined .bar-join {
  grid-template-columns: 0fr;
  margin-right: 0;
  padding: 0;
  opacity: 0;
  visibility: hidden;
}

/* The bar's language picker, at its right edge: the page's language as its
   code in regular body text like the bar's links, so the button stays the
   bar's one strong word; pressed, a paper card under it lists every
   language by its own name, each a link to this page in it, the current
   one semibold on mist. A <details>, so it opens without the script; the
   script closes it on a press outside or Escape. */
.bar-lang {
  position: relative;
}

.bar-lang summary {
  display: flex;
  align-items: center;
  gap: var(--space-2);
  height: var(--bar-button);
  padding: 0 var(--space-3);
  border-radius: var(--radius-control);
  corner-shape: squircle;
  list-style: none;
  cursor: pointer;
}

.bar-lang summary::-webkit-details-marker {
  display: none;
}

/* The chevron: a small triangle in the words' color, pointing up while open. */
.bar-lang summary::after {
  content: "";
  width: var(--space-2);
  height: var(--space-1);
  background: currentColor;
  clip-path: polygon(0 0, 100% 0, 50% 100%);
}

.bar-lang[open] summary::after {
  rotate: 180deg;
}

.bar-lang summary:hover,
.bar-lang[open] summary {
  background: color-mix(in srgb, var(--ink) 6%, transparent);
}

.bar-lang ul {
  position: absolute;
  top: calc(100% + var(--space-2));
  right: 0;
  max-height: calc(100svh - var(--bar-tall) - var(--space-4));
  overflow-y: auto;
  padding: var(--space-2);
  list-style: none;
  background: var(--paper);
  border-radius: var(--radius-control);
  corner-shape: squircle;
  box-shadow: var(--shadow-card);
}

/* The card stays paper over the footer, so its names keep the ink. */
.bar-lang a {
  display: block;
  padding: var(--space-2) var(--space-3);
  border-radius: var(--radius-tag);
  color: var(--ink);
  text-decoration: none;
  white-space: nowrap;
}

.bar.on-night .bar-lang a {
  color: var(--ink);
}

.bar-lang a:hover,
.bar-lang [aria-current] {
  background: var(--mist);
}

.bar-lang [aria-current] {
  font-weight: 600;
}

/* Over the ink footer the code and its ground turn to the night, and so
   does the focus ring of the bar's own controls. */
.bar.on-night .bar-lang summary {
  color: var(--on-ink);
}

.bar.on-night .bar-lang summary:hover,
.bar.on-night .bar-lang[open] summary {
  background: color-mix(in srgb, var(--on-ink) 14%, transparent);
}

.bar.on-night > :focus-visible,
.bar.on-night summary:focus-visible {
  outline-color: var(--on-ink);
}

/* Running text: answers, comparisons, the notices. One measure, headings
   as titles, lists as plain lists. */
.prose {
  max-width: 44em;
}

.prose > * + * {
  margin-top: var(--space-4);
}

.prose h2 {
  margin-top: var(--space-16);
  font-family: var(--font-text);
  font-size: var(--size-title);
  font-weight: 600;
  line-height: var(--line-title);
  letter-spacing: -0.01em;
  max-width: none;
}

.prose h3 {
  margin-top: var(--space-8);
  font-size: var(--size-body);
  font-family: var(--font-text);
  font-weight: 600;
  line-height: var(--line-body);
  letter-spacing: 0;
}

.prose > h2:first-child,
.prose > h3:first-child {
  margin-top: 0;
}

.prose ul,
.prose ol {
  padding-left: var(--space-6);
}

.prose ul {
  list-style: disc;
}

.prose ol {
  list-style: decimal;
}

.prose li + li {
  margin-top: var(--space-2);
}

/* ink-soft, not ink-faint: a checked line stands on mist as often as paper. */
.prose .checked {
  font-size: var(--size-label);
  line-height: var(--line-label);
  color: var(--ink-soft);
}

/* A comparison laid out as a table on a card: one row per question, Omand's
   column first after the question. Hairlines between rows, as a chart's grid. */
.table-card {
  margin-top: var(--space-8);
  padding: var(--space-6);
  border-radius: var(--radius-card);
  corner-shape: squircle;
  overflow-x: auto;
}

.table-card table {
  width: 100%;
  min-width: var(--table-min);
  border-collapse: collapse;
  font-size: var(--size-label);
  line-height: var(--line-label);
}

.table-card th,
.table-card td {
  padding: var(--space-3) var(--space-4);
  text-align: left;
  vertical-align: top;
}

.table-card thead th {
  font-weight: 600;
}

.table-card tbody tr {
  border-top: 1px solid var(--line);
}

.table-card tbody th {
  font-weight: 600;
  width: 20%;
}

/* A guide in short: a few lines on a card, each led by its name, read in
   ten seconds before the details. */
.short {
  margin-top: var(--space-12);
  max-width: var(--short-width);
  display: grid;
  grid-template-columns: max-content 1fr;
  gap: var(--space-4) var(--space-8);
  padding: var(--space-8);
  border-radius: var(--radius-card);
  corner-shape: squircle;
}

.short dt {
  font-weight: 600;
}

.short dd {
  color: var(--ink-soft);
  text-wrap: pretty;
}

/* The footer: the site's one ground of ink, where every page written for
   search engines and assistants is one step away. The wordmark large with
   the waitlist beside it, then the pages in five columns under their
   names (two on a phone), and who makes Omand. */
.footer {
  --ink-quiet: color-mix(in srgb, var(--on-ink) 62%, var(--ink));
  padding: var(--space-16) 0;
  background: var(--ink);
  color: var(--on-ink);
  font-size: var(--size-label);
  line-height: var(--line-label);
}

.footer a {
  color: var(--on-ink);
  text-decoration: none;
}

.footer a:hover {
  text-decoration: underline;
}

.footer :focus-visible {
  outline-color: var(--on-ink);
}

.footer-top {
  display: flex;
  flex-wrap: wrap;
  align-items: baseline;
  justify-content: space-between;
  gap: var(--space-4) var(--space-8);
}

.footer .wordmark {
  font-size: var(--size-headline);
  color: var(--on-ink);
}

.footer-join {
  font-size: var(--size-title);
  font-weight: 600;
  line-height: var(--line-title);
  letter-spacing: -0.01em;
}

.footer .footer-join {
  text-decoration: underline;
  text-decoration-color: var(--accent);
  text-decoration-thickness: var(--space-1);
  text-underline-offset: var(--space-2);
}

.footer-cols {
  margin-top: var(--space-12);
  padding-bottom: var(--space-12);
  border-bottom: 1px solid color-mix(in srgb, var(--on-ink) 18%, var(--ink));
  display: grid;
  grid-template-columns: repeat(5, auto);
  justify-content: space-between;
  gap: var(--space-8);
}

.footer-cols ul {
  margin-top: var(--space-3);
  display: flex;
  flex-direction: column;
  gap: var(--space-2);
  list-style: none;
}

.footer-title {
  font-weight: 600;
  color: var(--ink-quiet);
}

.footer-made {
  margin-top: var(--space-6);
  max-width: 44em;
  color: var(--ink-quiet);
}

.footer .footer-made a {
  color: var(--on-ink);
  text-decoration: underline;
}

/* Motion, once: the page reads complete at rest. The first screen enters
   once, its words rising, then the Mac, then the iPhone in front of it.
   site.js marks the page `moving` only where motion is welcome, and marks
   each part `seen` as it first comes into view: the marker draws itself
   under its word, and statements, the slides and the tiles rise a little
   and settle. The work plays its beats and the slides their pictures once,
   when they come into view. Nothing moves after that and nothing moves
   on paper; only an explainer repeats, while it is in view (below). */

@media screen and (prefers-reduced-motion: no-preference) {
  .bar-join {
    transition: grid-template-columns var(--motion-calm) var(--ease), margin var(--motion-calm) var(--ease), padding var(--motion-calm) var(--ease), opacity var(--motion-calm) var(--ease), visibility var(--motion-calm);
  }

  .hero > *,
  .work-tags,
  .work .device {
    animation: rise 900ms cubic-bezier(0.2, 0.7, 0.2, 1) both;
  }

  .hero-side {
    animation-delay: 60ms;
  }

  .work-tags {
    animation-delay: 160ms;
  }

  .work-app {
    animation-delay: 300ms;
  }

  .work-chat {
    animation-delay: 450ms;
  }

  @keyframes rise {
    from {
      opacity: 0;
      translate: 0 var(--space-6);
    }
  }
}

@media screen {
  .moving mark::before {
    transform: scaleX(0);
    transform-origin: left;
    transition: transform 700ms cubic-bezier(0.2, 0.7, 0.2, 1) 200ms;
  }

  .moving mark.seen::before {
    transform: none;
  }

  .moving .rises {
    opacity: 0;
    translate: 0 var(--space-3);
    transition: opacity 500ms ease, translate 500ms ease;
  }

  .moving .rises.seen {
    opacity: 1;
    translate: 0 0;
  }

  /* The playing scene's progress line fills over its length, which site.js
     sets. An animation, not a transition: the scene's words were hidden
     until now, and a box that only just appeared has nothing to move from. */
  .moving .tour.playing .tour-lines .now::after {
    animation: tour-progress var(--scene, 0ms) linear both;
  }

  @keyframes tour-progress {
    from {
      background-size: 0 100%, auto;
    }
  }
}

/* An explainer runs while it is in view and pauses out of it, since its
   motion is what it explains: its flows run, its tools breathe, and its
   story repeats on a calm cycle. site.js marks the page `moving` only
   where motion is welcome and each explainer `in-view` while it is.
   Scenes 1 and 3 run on 12 s, four sources taking turns of 3 s: a source
   lights, its light runs, and its thing lands in Omand's top row, glows,
   settles and gives way to the next. Scene 4 runs on 10 s: the chat fills
   past its line and thinks long, then misses; the light reads Omand's
   contents, one page flows to the AI, which answers at once. */
@media screen {
  .moving .explain .run {
    visibility: visible;
    animation: explain-run-q 12s cubic-bezier(0.5, 0, 0.3, 1) var(--d, 0s) infinite;
  }

  .moving .explain.files .run {
    animation-name: explain-run-q-long;
  }

  .moving .explain .run.hop {
    animation: explain-run-hop 3s cubic-bezier(0.5, 0, 0.3, 1) var(--d, 0s) infinite;
  }

  .moving .explain .run.book {
    animation: explain-run-book 10s cubic-bezier(0.5, 0, 0.3, 1) infinite;
  }

  .moving .explain .land {
    animation: explain-land 3s ease-out var(--d, 0s) infinite;
  }

  .moving .explain .tool {
    animation: explain-breathe var(--b) ease-in-out var(--bd) infinite alternate;
  }

  .moving .explain :is(.tool.lit, .files .sheet)::after {
    animation: explain-lit 12s ease-in-out var(--ld) infinite;
  }

  .moving .explain .ai > * {
    animation: explain-turn 12.5s ease-in-out var(--d) infinite;
  }

  .moving .explain .slot > .row {
    animation: explain-arrive 12s cubic-bezier(0.2, 0.7, 0.2, 1) var(--d) infinite;
  }

  .moving .explain .load .sheet {
    animation: explain-load-in 10s cubic-bezier(0.2, 0.7, 0.2, 1) var(--d) infinite backwards;
  }

  .moving .explain .load .past {
    animation-name: explain-load-past;
  }

  .moving .explain .think {
    animation: explain-think 10s linear infinite;
  }

  .moving .explain .without .think {
    animation-name: explain-think-long;
  }

  .moving .explain .think i {
    animation: explain-dots 1.2s ease-in-out calc(var(--i) * 0.15s) infinite;
  }

  .moving .explain .say.answer {
    animation: explain-reply 10s ease-out infinite;
  }

  .moving .explain .without .say.answer {
    animation-name: explain-reply-late;
  }

  .moving .explain .use b i {
    animation: explain-use 10s ease-out infinite;
  }

  .moving .explain .without .use b i {
    animation-name: explain-use-long;
  }

  .moving .explain .reader {
    animation: explain-read 10s cubic-bezier(0.45, 0, 0.55, 1) infinite;
  }

  .moving .explain .page {
    animation: explain-page 10s ease-out infinite;
  }

  /* The path runs on 15 s: the light hops station to station, a beat
     apart, and lands on Omand; then the check passes, the gap glows and
     says who the AI asks, the answer fills it, the conclusion lands and
     stands until the next round. */
  .moving .explain.path .run.hop {
    animation: explain-path-hop 15s cubic-bezier(0.5, 0, 0.3, 1) var(--d, 0s) infinite;
  }

  .moving .explain.path .land {
    animation: explain-path-land 15s ease-out infinite;
  }

  .moving .explain.path .check::before {
    animation: explain-path-sweep 15s cubic-bezier(0.45, 0, 0.55, 1) infinite;
  }

  .moving .explain.path .gap .empty {
    animation: explain-path-empty 15s ease-in-out infinite;
  }

  .moving .explain.path .gap .empty small {
    animation: explain-path-ask 15s ease-in-out infinite;
  }

  .moving .explain.path .gap .filled {
    animation: explain-path-filled 15s ease-in-out infinite;
  }

  .moving .explain.path .conclusion {
    animation: explain-path-conclude 15s cubic-bezier(0.2, 0.7, 0.2, 1) infinite;
  }

  .moving .explain.path .voice i {
    transform-origin: center;
    animation: explain-voice 1.1s ease-in-out var(--d, 0s) infinite alternate;
  }

  @keyframes explain-path-hop {
    0%, 1% { stroke-dashoffset: var(--l); }
    9%, 100% { stroke-dashoffset: -101; }
  }

  @keyframes explain-path-land {
    0%, 23% { opacity: 0; transform: scale(0.96); }
    26% { opacity: 1; transform: scale(1); }
    34%, 100% { opacity: 0; transform: scale(1.06); }
  }

  @keyframes explain-path-sweep {
    0%, 26% { top: -30%; }
    40%, 100% { top: 100%; }
  }

  @keyframes explain-path-empty {
    0%, 32% { opacity: 1; box-shadow: inset 0 0 0 1.5px color-mix(in srgb, var(--ink) 28%, transparent); }
    36%, 56% { opacity: 1; box-shadow: inset 0 0 0 2px var(--field-2), 0 0 var(--space-6) var(--field-2); }
    60%, 96% { opacity: 0; }
    100% { opacity: 1; box-shadow: inset 0 0 0 1.5px color-mix(in srgb, var(--ink) 28%, transparent); }
  }

  @keyframes explain-path-ask {
    0%, 39% { opacity: 0; }
    43%, 56% { opacity: 1; }
    60%, 100% { opacity: 0; }
  }

  @keyframes explain-path-filled {
    0%, 56% { opacity: 0; box-shadow: 0 0 0 0 transparent; }
    60% { opacity: 1; box-shadow: 0 0 0 2px var(--field-2), 0 0 var(--space-6) var(--field-2); }
    70%, 96% { opacity: 1; box-shadow: 0 0 0 0 transparent; }
    100% { opacity: 0; }
  }

  @keyframes explain-path-conclude {
    0%, 66% { opacity: 0; translate: 0 -8px; box-shadow: 0 0 0 0 transparent; }
    70% { opacity: 1; translate: 0 0; box-shadow: 0 0 0 2px var(--field-2), 0 0 var(--space-6) var(--field-2); }
    80%, 96% { opacity: 1; translate: 0 0; box-shadow: 0 0 0 0 transparent; }
    100% { opacity: 0; translate: 0 0; }
  }

  @keyframes explain-voice {
    from { scale: 1 0.2; }
    to { scale: 1 1; }
  }

  /* Out of view, nothing runs. Important because each part's animation
     shorthand above resets the play state to running. */
  .moving .explain:not(.in-view) *,
  .moving .explain:not(.in-view) *::before,
  .moving .explain:not(.in-view) *::after {
    animation-play-state: paused !important;
  }

  @keyframes explain-run-q {
    0%, 2% { stroke-dashoffset: var(--l); }
    13%, 100% { stroke-dashoffset: -100; }
  }

  @keyframes explain-run-q-long {
    0%, 2% { stroke-dashoffset: var(--l); }
    20%, 100% { stroke-dashoffset: -100; }
  }

  @keyframes explain-run-hop {
    0% { stroke-dashoffset: var(--l); }
    40%, 100% { stroke-dashoffset: -100; }
  }

  @keyframes explain-run-book {
    0%, 29% { stroke-dashoffset: var(--l); }
    42%, 100% { stroke-dashoffset: -100; }
  }

  @keyframes explain-land {
    0%, 72% { opacity: 0; transform: scale(0.96); }
    80% { opacity: 1; transform: scale(1); }
    100% { opacity: 0; transform: scale(1.06); }
  }

  @keyframes explain-breathe {
    from { scale: 0.92; }
    to { scale: 1.08; }
  }

  @keyframes explain-lit {
    0% { opacity: 0; }
    2%, 19% { opacity: 1; }
    23%, 100% { opacity: 0; }
  }

  @keyframes explain-turn {
    0% { opacity: 0; scale: 0.8; }
    3%, 17% { opacity: 1; scale: 1; }
    20%, 100% { opacity: 0; scale: 0.8; }
  }

  @keyframes explain-arrive {
    0% { opacity: 0; translate: 0 -10px; box-shadow: 0 0 0 0 transparent; }
    4% { opacity: 1; translate: 0 0; box-shadow: 0 0 0 2px var(--field-2), 0 0 var(--space-6) var(--field-2); }
    14% { box-shadow: 0 0 0 0 transparent; }
    23% { opacity: 1; }
    25%, 100% { opacity: 0; }
  }

  @keyframes explain-load-in {
    0% { opacity: 0; translate: 0 -8px; }
    4%, 92% { opacity: 1; translate: 0 0; }
    100% { opacity: 0; }
  }

  @keyframes explain-load-past {
    0% { opacity: 0; translate: 0 -8px; }
    4%, 12% { opacity: 1; translate: 0 0; }
    40%, 92% { opacity: 0.12; translate: 0 8px; }
    100% { opacity: 0; translate: 0 8px; }
  }

  @keyframes explain-think {
    0%, 43% { opacity: 0; }
    45%, 53% { opacity: 1; }
    55%, 100% { opacity: 0; }
  }

  @keyframes explain-think-long {
    0%, 34% { opacity: 0; }
    36%, 68% { opacity: 1; }
    70%, 100% { opacity: 0; }
  }

  @keyframes explain-dots {
    0%, 60%, 100% { translate: 0 0; opacity: 0.4; }
    30% { translate: 0 -3px; opacity: 1; }
  }

  @keyframes explain-reply {
    0%, 53% { opacity: 0; translate: 0 6px; }
    57%, 96% { opacity: 1; translate: 0 0; }
    100% { opacity: 0; }
  }

  @keyframes explain-reply-late {
    0%, 68% { opacity: 0; translate: 0 6px; }
    72%, 96% { opacity: 1; translate: 0 0; }
    100% { opacity: 0; }
  }

  @keyframes explain-use {
    0%, 42% { width: 0; }
    56%, 96% { width: var(--use); }
    100% { width: 0; }
  }

  @keyframes explain-use-long {
    0% { width: 0; }
    68%, 96% { width: var(--use); }
    100% { width: 0; }
  }

  @keyframes explain-read {
    0%, 4% { top: 0; opacity: 0; }
    8% { top: 0; opacity: 1; }
    28%, 84% { top: calc(var(--pick) * var(--explain-contents-row)); opacity: 1; }
    94%, 100% { top: calc(var(--pick) * var(--explain-contents-row)); opacity: 0; }
  }

  @keyframes explain-page {
    0%, 41% { opacity: 0; box-shadow: 0 0 0 0 transparent; }
    43% { opacity: 1; box-shadow: 0 0 0 2px var(--field-2), 0 0 var(--space-6) var(--field-2); }
    56%, 96% { opacity: 1; box-shadow: 0 0 0 0 transparent; }
    100% { opacity: 0; }
  }
}

/* Below a computer: the bar keeps the wordmark, its button and the picker,
   the first screen's words stand over the work, tiles go two to a row and
   the form under the steps. */
@media (width < 1024px) {
  .bar-nav {
    display: none;
  }

  .hero-side {
    margin-top: var(--space-4);
  }

  .section {
    padding: var(--space-12) 0;
  }

  .tiles {
    grid-template-columns: 1fr 1fr;
  }

  .join {
    grid-template-columns: 1fr;
    gap: var(--space-12);
  }

  .waitlist {
    max-width: none;
  }
}

@media (width < 640px) {
  .plans {
    grid-template-columns: 1fr;
  }

  .wrap {
    padding: 0 var(--space-6);
  }

  .bar {
    padding: var(--space-3) var(--space-6);
  }

  .bar-join {
    margin-right: var(--space-1);
  }

  .bar-lang summary {
    padding: 0 var(--space-2);
  }

  /* Each language's call to action is fitted to a 390 phone; narrower,
     the button and the code draw closer around their words, so the words
     stay whole beside the wordmark down to a 360 phone. */
  @media (max-width: 389px) {
    .bar-join {
      padding: 0 var(--space-3);
    }

    .bar-lang summary {
      gap: var(--space-1);
      padding: 0 var(--space-1);
    }
  }

  /* A finger's row on a phone. */
  .bar-lang a {
    padding: var(--space-3) var(--space-4);
  }

  .hero,
  .work {
    width: calc(100% - 2 * var(--space-6));
  }

  .intro {
    padding-bottom: var(--space-12);
  }

  .work {
    margin-top: var(--space-12);
  }

  /* The work on a phone: two iPhones, the AI's large in front and Omand's
     behind it at the right, where its figures stand; the work's foot cuts
     both where Omand's screen ends, its tab bar the last thing seen.
     Omand's phone is 60 wide, its screen 55.57, so the status bar (54
     points) and the app's screen (640) end 101.05 below its top. The AI's
     screen is held to what shows above that foot, 121.6% of its width. */
  .work-devices {
    aspect-ratio: 100 / 101.05;
    clip-path: inset(-50% -50% 0 -50%);
  }

  /* The AI's label at the left, Omand's at the right over its iPhone, their
     words wrapping within their half. */
  .work-place {
    max-width: 48%;
  }

  .work-app {
    width: 60cqw;
  }

  .work-chat {
    left: 0;
    top: 22cqw;
    width: 68cqw;
  }

  .work-chat .chat {
    height: 121.6cqw;
  }

  .work-saved {
    left: 3%;
    top: 59.4%;
    width: 94%;
    height: 17%;
  }

  .section {
    padding: var(--space-8) 0;
  }

  .footer-cols {
    grid-template-columns: 1fr 1fr;
  }

  .tiles,
  .field-pair {
    grid-template-columns: 1fr;
  }

  /* One field under another: each keeps its name and field together, and
     the pair parts as any two fields do. */
  .field-pair {
    grid-template-rows: none;
    row-gap: var(--space-6);
  }

  .field-pair > .field-row {
    grid-row: auto;
    grid-template-rows: none;
  }

  .choices {
    grid-template-columns: repeat(2, minmax(0, 1fr));
  }

  .waitlist {
    padding: var(--space-6);
  }

  .tile-art {
    height: auto;
  }

  /* The slides on a phone: the Mac becomes an iPhone with the phone's
     pictures, alone on the stage and whole on it: the phone is 76 wide and
     stands 10 down, so its foot is 168.6 below the stage's top. A still
     stands under the drawn status bar, 794 points tall; a recorded scene
     fills the whole screen. */
  .tour {
    margin-top: var(--space-12);
  }

  /* Held to the screen's height less the bar above it and the steps and
     the slide's words under it, so a short phone shows the device and its
     words together. */
  .tour-stage {
    width: min(100% - 2 * var(--space-6), (100svh - var(--bar-tall) - var(--tour-words-tall) - var(--tour-words-more, 0px)) * 100 / 172);
    aspect-ratio: 100 / 172;
  }

  .tour-mac {
    left: 12cqw;
    top: 10cqw;
    width: 76cqw;
  }

  .tour-phone {
    display: none;
  }

  .tour-mac .window-view {
    aspect-ratio: 390 / 794;
  }

  .recorded .tour-mac .window-view {
    position: absolute;
    inset: 0;
    aspect-ratio: auto;
  }

  /* Seven steps of a finger's size stand side by side on any phone: the row
     reaches into the gutters, to a hair from the screen's edges, and below
     336 points the steps narrow together, still 44 points wide on a
     320-point screen. */
  .tour-steps {
    align-self: stretch;
    flex-wrap: nowrap;
    gap: 0;
    margin-inline: calc(var(--space-1) - var(--space-6));
  }

  .tour-steps button {
    flex: 0 1 var(--space-12);
    min-width: 0;
    height: var(--space-12);
  }

  .tour.stepped .tour-lines {
    min-height: calc(3 * var(--line-lede) + var(--space-4) + var(--flow-line));
  }

  .tour.stepped .tour-lines b {
    display: block;
    margin: 0 0 var(--space-1);
  }

  /* Below 375 points the longest slides' words take a line more, so the
     stage leaves room for it and still shows them with the device. */
  @media (max-width: 374px) {
    .tour {
      --tour-words-more: var(--line-lede);
    }
  }

  /* A comparison on a phone: each question becomes a block of its own, every
     answer under the name of its column, so no column hides past the edge.
     tools/site.mjs gives each cell its column's name. */
  .table-card {
    padding: var(--space-2) var(--space-6);
  }

  .table-card table,
  .table-card tbody,
  .table-card tr,
  .table-card th,
  .table-card td {
    display: block;
    min-width: 0;
    width: auto;
  }

  .table-card thead {
    display: none;
  }

  .table-card tbody tr {
    padding: var(--space-4) 0;
  }

  .table-card tbody tr:first-child {
    border-top: 0;
  }

  .table-card th,
  .table-card td {
    padding: var(--space-1) 0;
  }

  .table-card tbody th {
    width: auto;
    font-size: var(--size-body);
    line-height: var(--line-body);
  }

  .table-card td::before {
    content: attr(data-label);
    display: block;
    font-weight: 600;
    color: var(--ink-soft);
  }

  .short {
    grid-template-columns: 1fr;
  }

  .short {
    gap: var(--space-1);
    padding: var(--space-6);
  }

  .short dd + dt {
    margin-top: var(--space-3);
  }
}
