/* Film grain over the whole page. One fixed layer of SVG fractal noise,
   multiplied over the warm ground so it reads as paper tooth rather than
   a grey wash. It never intercepts clicks. */
body::after {
  content: '';
  position: fixed;
  inset: 0;
  z-index: 9999;
  pointer-events: none;
  opacity: 0.082;
  /* No mix-blend-mode: a blended full-viewport layer forces the browser to
     re-composite the entire page underneath it on every single frame, which
     is what made scrolling feel heavy. Instead the turbulence is reduced to
     pure black at a sparse alpha (feColorMatrix zeroes RGB and keeps the
     shaped alpha), so painting it normally darkens exactly the way multiply
     did - measured to within a pixel level on cream, card and honey, and
     still invisible over the dark footer. */
  background-image: url("data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' width='180' height='180'><filter id='n'><feTurbulence type='fractalNoise' baseFrequency='0.9' numOctaves='3' stitchTiles='stitch'/><feComponentTransfer><funcA type='linear' slope='6' intercept='-3.4'/></feComponentTransfer><feColorMatrix type='matrix' values='0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0'/></filter><rect width='180' height='180' filter='url(%23n)'/></svg>");
  /* One tile, rasterised once and repeated, instead of one rect stretched
     over four viewports' worth of area. Own layer, so it never repaints. */
  background-size: 180px 180px;
  transform: translateZ(0);
}

/* ---- Page container ---------------------------------------------------
   One gutter and one content rail for the whole page. Section bands stay
   full-bleed so their colour still runs edge to edge; everything *inside*
   a band sits on `.shell`, and that is what makes the copy and card edges
   line up from the nav all the way down to the footer. Change --rail here
   and the whole page follows. */
:root { --rail: 1280px; }
.shell { width: 100%; max-width: var(--rail); margin-inline: auto; }

/* Lucide icons are stroke-drawn: without these they render as black fills. */
.icon { fill: none; stroke: currentColor; stroke-linecap: round; stroke-linejoin: round; }
.icon-brand { fill: currentColor; stroke: none; }

/* Hero doodles - the pen marks in the notebook margin around the headline.
   Three jobs, three wrappers, so no two of them ever fight over `transform`:
   the pointer drift lives on the outer [data-drift], the entry tween on the
   [data-enter] inside it, and the idle float on the innermost `.prop`. Each
   drift layer travels its own distance; that difference is the depth. */
.prop-layer { transition: transform 0.7s cubic-bezier(0.2, 0.8, 0.2, 1); }
@keyframes prop-float {
  0%, 100% { transform: translate3d(0, 0, 0); }
  50%      { transform: translate3d(0, var(--rise, -12px), 0); }
}
@media (prefers-reduced-motion: no-preference) {
  .prop { animation: prop-float var(--dur, 8s) ease-in-out var(--delay, 0s) infinite; }
}

/* A CSS animation set to `infinite` keeps asking the compositor for frames
   even after it has scrolled out of view, so the hero's doodles and the team
   wall's drifting columns go on costing the whole page for their entire
   life. `.is-still` is switched on by an observer once a section is off
   screen, and off again before it comes back. */
.is-still .prop,
.is-still .bee-wing, .is-still .hero-bee svg { animation-play-state: paused; }

/* The marked word. The honey block sits behind the glyphs on its own span,
   so the motion layer can wipe it in while the letters flick up on top.
   Sized in em off the headline, so it tracks the type at every width. */
.hl-pill {
  position: relative;
  isolation: isolate;
  display: inline-block;
  padding-inline: 0.16em 0.2em;
}
.hl-pill-bg {
  position: absolute;
  inset: 0.06em 0 -0.1em;
  z-index: -1;
  border-radius: 0.2em;
  background-image: linear-gradient(135deg, #FFC24D 0%, #F5A521 62%, #E8931A 100%);
  box-shadow: 0 0.16em 0.4em -0.2em rgba(138, 101, 8, 0.55);
}

/* The note-to-self above the headline. The arrow's ends are fixed points in
   its viewBox - the tail at 67% of its height, the tip at 96% across and 89%
   down - so both pills are placed off the arrow's own width, and they keep
   landing where it points when the arrow is shortened to fit a phone. */
.hero-note { --aw: 10.5em; }
.hero-note-arrow { width: var(--aw); margin-left: 0.4em; }
.hero-note-ask { margin-top: calc(var(--aw) * 0.3 - 1.25em); }
.hero-note-answer { margin-top: calc(var(--aw) * 0.4 + 0.2em); margin-left: calc(var(--aw) * -0.21); }
/* The note's text never drops below 13px, so on a phone the room comes
   out of the arrow and the pills' side padding instead. */
@media (max-width: 479px) {
  .hero-note { --aw: 5em; }
  .hero-note-arrow { margin-left: 0.25em; }
  .hero-note-ask .prop > span { padding-inline: 1em; }
  .hero-note-answer .prop > span { padding-left: 0.9em; }
}

/* The corners. A honey orb inside a thin orbit rises half out of the
   left edge, level with the headline, and another sits in the
   bottom-right; a looser arc with a bead on it takes the top-right and
   bottom-left. The left orb used to fill the top-left corner, where it
   swallowed the logo in the see-through nav - that corner is left bare
   now. Every number is in `--u`, a pixel of the 1458px-wide layout they
   were drawn at, so the pieces keep their size against each other - and
   how far each one bleeds past the panel edge - at every width. The panel
   runs up under the see-through nav, so the top arc is let down by the
   nav's band (`--nav-h`) to keep its place against the copy; its stroke
   is long enough to still leave through the top edge. */
.hero-corners { --u: clamp(0.42px, calc(100vw / 1458), 1.3px); --nav-h: 80px; }
@media (min-width: 640px) { .hero-corners { --nav-h: 88px; } }
.hero-orb { position: absolute; aspect-ratio: 1; }
.hero-orb--ml { width: calc(632 * var(--u)); left: calc(-436 * var(--u)); top: calc(46% - 316 * var(--u)); }
.hero-orb--br { width: calc(540 * var(--u)); right: calc(-280 * var(--u)); bottom: calc(-270 * var(--u)); }
.hero-arc { position: absolute; }
.hero-arc--tr { width: calc(825 * var(--u)); right: calc(-162 * var(--u)); top: calc(-290 * var(--u) + var(--nav-h)); }
.hero-arc--bl { width: calc(275 * var(--u)); left: calc(-60 * var(--u)); bottom: calc(-55 * var(--u)); }
/* The lines scale with the rest rather than holding a screen width -
   `non-scaling-stroke` would throw the draw-on dash out of step with
   pathLength - so they are thickened back up as `--u` shrinks. */
.hero-line { stroke-width: 1.5px; }
@media (max-width: 1199px) { .hero-line { stroke-width: 2px; } }
@media (max-width: 899px)  { .hero-line { stroke-width: 2.6px; } }

/* The bee sketched beside the last line. It hangs off the word rather than
   taking part in the centring, the way a margin doodle would. */
.hero-bee {
  position: absolute;
  left: calc(100% + 0.04em);
  top: 0.02em;
  width: 0.84em;
}

/* Its wingbeat. Each wing sits in its own <g> so the flap doesn't
   overwrite the rotate() already on the ellipse, and pivots on its root,
   which is just inside the body so the joint never shows. One cycle holds
   seven beats of uneven height, so the loop reads as a live buzz rather
   than a metronome, and the front wing trails the back by a hair. The
   body gets a quicker, smaller hover on top of the slow `.prop` float
   the other doodles share - a couple of pixels, no more. */
.bee-wing { transform-box: view-box; }
.bee-wing--back  { --tilt: -13deg; transform-origin: 49px 56px; }
.bee-wing--front { --tilt: 10deg;  transform-origin: 56px 53px; }
@keyframes bee-flap {
  0%, 14%, 28.5%, 42.5%, 57%, 71.5%, 86%, 100% { transform: rotate(0deg) scaleY(1); }
  7%    { transform: rotate(var(--tilt)) scaleY(0.82); }
  21.5% { transform: rotate(calc(var(--tilt) * 0.75)) scaleY(0.87); }
  35.5% { transform: rotate(calc(var(--tilt) * 0.95)) scaleY(0.83); }
  50%   { transform: rotate(calc(var(--tilt) * 0.6)) scaleY(0.9); }
  64%   { transform: rotate(var(--tilt)) scaleY(0.8); }
  78.5% { transform: rotate(calc(var(--tilt) * 0.8)) scaleY(0.86); }
  93%   { transform: rotate(calc(var(--tilt) * 0.9)) scaleY(0.84); }
}
@keyframes bee-hover {
  0%, 100% { transform: translate3d(0, 0, 0); }
  28%      { transform: translate3d(0, -2.4%, 0); }
  52%      { transform: translate3d(0, 0.6%, 0); }
  76%      { transform: translate3d(0, -1.4%, 0); }
}
@media (prefers-reduced-motion: no-preference) {
  .bee-wing { animation: bee-flap 1.05s ease-in-out infinite; }
  .bee-wing--front { animation-delay: -0.03s; }
  .hero-bee svg { animation: bee-hover 1.7s ease-in-out infinite; }
}

/* The 3D bee (js/bee/). Its canvas covers the whole panel behind the copy,
   so the bee can fly to the mouse (tracked across the whole window)
   anywhere over the hero; it rests at the pen bee's spot until the mouse
   first moves and is sized off the headline. It never takes the
   pointer, so everything under it stays clickable. The pen bee is the
   fallback - without WebGL and while three.js loads - and steps aside
   once the 3D one is on screen. */
.hero-bee-3d { opacity: 0; transition: opacity 0.6s ease; }
.hero-bee-3d.is-on { opacity: 1; }
.hero-bee svg { transition: opacity 0.3s ease; }
.hero-bee.is-3d svg { opacity: 0; }
.hero-bee.is-3d svg, .hero-bee.is-3d .bee-wing { animation: none; }

/* Form errors arrive rather than appear: the slot opens from zero height
   while the message slides up into it, so the layout below is pushed down
   in one motion instead of jumping. The rust ring fades in alongside. */
[data-error-for] {
  display: grid;
  grid-template-rows: 0fr;
  opacity: 0;
  transition: grid-template-rows 0.28s cubic-bezier(0.2, 0.8, 0.2, 1), opacity 0.2s ease, margin-top 0.28s cubic-bezier(0.2, 0.8, 0.2, 1);
  margin-top: 0;
}
[data-error-for] > span { overflow: hidden; transform: translateY(-4px); transition: transform 0.28s cubic-bezier(0.2, 0.8, 0.2, 1); }
[data-error-for].is-shown { grid-template-rows: 1fr; opacity: 1; margin-top: 0.375rem; }
[data-error-for].is-shown > span { transform: none; }
#demoForm input, #demoForm select, #demoForm [aria-haspopup='listbox'] { transition: background-color 0.2s ease, box-shadow 0.2s ease, --tw-ring-color 0.2s ease, opacity 0.2s ease; }
@media (prefers-reduced-motion: reduce) {
  [data-error-for], [data-error-for] > span { transition: none; }
}

@keyframes status-rise { from { opacity: 0; transform: translateY(6px); } to { opacity: 1; transform: none; } }
#demoStatusRow.is-shown { animation: status-rise 0.3s cubic-bezier(0.2, 0.8, 0.2, 1) both; }
@media (prefers-reduced-motion: reduce) { #demoStatusRow.is-shown { animation: none; } }

/* A formula on a note wants maths typesetting, not the UI face. */
.formula { font-family: 'Iowan Old Style', 'Palatino Linotype', Palatino, Georgia, serif; font-style: italic; }



/* ---- Motion layer (js/motion.js) --------------------------------------
   Nothing here animates on its own. These are the states the page holds
   *before* the motion layer boots, plus the two pieces of structure GSAP
   cannot express in a tween: the word clipping box and the wipe panels.
   `html.motion-ready` is added the moment motion.js has built its tweens
   (or decided not to), and every pre-state below is scoped to its absence,
   so a blocked CDN or reduced-motion preference leaves a plain page. */

html:not(.motion-ready) [data-reveal],
html:not(.motion-ready) [data-enter],
html:not(.motion-ready) [data-reveal-group] > * { opacity: 0; }
html:not(.motion-ready) [data-reveal="clip"] { opacity: 1; clip-path: inset(46% 8% 46% 8% round 36px); }

/* Type splitting. A word stays one unit so lines still break on spaces,
   and the characters inside it are what actually move. No clipping box:
   each glyph rotates as it rises, and a mask would shear the corners. */
.rv-w { display: inline-block; white-space: nowrap; }

/* One clipping box per word, split further into characters. Each glyph
   pivots about a point near its own baseline (50% 90%) as it rises, which
   is what gives the reveal its flick rather than a flat slide. */
.rv-c { display: inline-block; transform-origin: 50% 90%; }
/* will-change only while a heading is actually typing. Left on permanently
   it hands every single glyph on the page its own compositor layer, which
   costs memory and slows every frame for motion that has already finished.
   motion.js adds .is-typing for the length of the tween and takes it off. */
.is-typing .rv-c { will-change: transform, opacity; }

/* The curtain covers the viewport from first paint. Its path is drawn at
   the covered position so there is no flash of page before motion.js
   takes over; the failsafe below hides the whole layer if it never does. */
#curtain { display: block; }

/* Sticker eyebrows - the rotated, offset-shadowed label CRAV uses to tag a
   section. Kept to honey on ink so it reads as a label, not a callout. */
.sticker {
  display: inline-block;
  transform: rotate(-2.5deg);
  border-radius: 999px;
  background: #FFFFFF;
  padding: 0.3rem 0.85rem;
  box-shadow: 2px 2px 0 rgba(20, 20, 15, 0.82);
}


/* ---- App section phone ------------------------------------------------
   A drawn handset around the top of the app's home screen
   (assets/app-home.webp, cropped to the screen's proportions). The phone
   is taller than its slot and the panel's floor crops it, so it reads as
   rising out of the panel. */
.app-phone {
  position: absolute;
  left: 0;
  top: 0;
  width: 272px;
  height: 556px;
  padding: 9px;
  border-radius: 46px;
  background: linear-gradient(155deg, #45453C 0%, #23231D 38%, #0F0F0C 100%);
  box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.10), 0 40px 90px rgba(0, 0, 0, 0.55);
  transform: rotate(4deg);
  transform-origin: 50% 100%;
}
.app-phone-screen {
  position: relative;
  height: 100%;
  overflow: hidden;
  border-radius: 38px;
  background: #F7F4EC;
}
/* Below `nav` the phone sits at the top of the panel, so it turns about
   the part that shows (keeping its top corner inside the panel) and its
   lower half fades into the ink ahead of the copy. */
@media (max-width: 899.98px) {
  .app-phone { transform: rotate(3deg); transform-origin: 50% 35%; }
  .app-shot {
    -webkit-mask-image: linear-gradient(to bottom, #000 62%, transparent);
            mask-image: linear-gradient(to bottom, #000 62%, transparent);
  }
}

/* Footer. Links sit at cream on the ink sheet and warm to honey on hover;
   keyboard focus gets its own honey ring, since the hover shift alone is
   too quiet to find on a dark ground. */
.footer-link {
  color: rgba(253, 252, 247, 0.78);
  text-decoration: none;
  width: fit-content;
  border-radius: 6px;
  transition: color 0.2s ease;
}
.footer-link:hover { color: #FFC24D; }
.footer-link:focus-visible { outline: 2px solid #FFC24D; outline-offset: 3px; }
/* The comb only shows at the top-right corner and thins out across the
   sheet, so it reads as texture behind the columns, never under the copy. */
.footer-comb {
  -webkit-mask-image: radial-gradient(75% 110% at 100% 0%, #000 0%, rgba(0, 0, 0, 0.35) 45%, transparent 75%);
  mask-image: radial-gradient(75% 110% at 100% 0%, #000 0%, rgba(0, 0, 0, 0.35) 45%, transparent 75%);
}
/* ---- Gallery coverflow -------------------------------------------------
   A rack of square covers with the perspective reversed. The centre cover
   sits square to the viewer while the ones beside it swing their OUTER
   edges forward, so the rack opens toward you instead of folding away.
   Every cover on the rack is fully opaque - depth and the turn mark the
   centre, so none of the others is faded to make the point. Positions come
   from JS (see the carousel block in the page script); the transition here
   is what turns a snap into a glide. */
.cf { --cf-size: clamp(232px, 58vw, 420px); --cf-h: calc(var(--cf-size) * 0.78); }
.cf-stage {
  position: relative;
  height: calc(var(--cf-h) + 2.5rem);
  perspective: 1200px;
  cursor: grab;
  touch-action: pan-y;
  -webkit-user-select: none;
  user-select: none;
  -webkit-tap-highlight-color: transparent;
}
.cf-stage.is-dragging { cursor: grabbing; }
.cf-card {
  position: absolute;
  left: 50%;
  top: 50%;
  width: var(--cf-size);
  height: var(--cf-h);
  margin: calc(var(--cf-h) / -2) 0 0 calc(var(--cf-size) / -2);
  padding: 6px;
  border: 0;
  border-radius: 21px;
  background: #fff;
  box-shadow: 0 16px 34px -18px rgba(20, 20, 15, 0.5);
  backface-visibility: hidden;
  will-change: transform;
  transition: transform 0.62s cubic-bezier(0.22, 1, 0.36, 1),
              opacity 0.45s ease, box-shadow 0.45s ease;
}
.cf-stage.is-dragging .cf-card { transition: opacity 0.2s linear; }
/* The first placement is a layout, not a move - the covers should already
   be on the rack rather than slide out of a stack. */
.cf-stage.is-setup .cf-card { transition: none; }
/* The whole rack reads as draggable - the covers carry the stage's grab
   hand rather than the button pointer, and switch with it mid-drag. */
.cf-card { cursor: grab; }
.cf-stage.is-dragging .cf-card { cursor: grabbing; }
.cf-card.is-active {
  box-shadow: 0 34px 64px -26px rgba(20, 20, 15, 0.55);
}
.cf-card:focus-visible { outline: 3px solid #F5A521; outline-offset: 5px; }
/* Covers that have travelled off the end fade out and stop catching the
   pointer, so a click always lands on something visible. */
.cf-card.is-offstage { pointer-events: none; }
.cf-caption { transition: opacity 0.26s ease, transform 0.26s ease; }
.cf-caption.is-swapping { opacity: 0; transform: translateY(7px); }
@media (prefers-reduced-motion: reduce) {
  .cf-card, .cf-caption { transition: none; }
}

/* ── Dealt deck ───────────────────────────────────────────────────
   Shared by the blog and the video testimonials: a hand of cards dealt
   across the page. Three transforms are kept on
   three separate channels so none can clobber another: `translate` holds
   the card's own height on the row (and doubles as the entry slide),
   `transform` is the hover lift alone, and the image inside scales on its
   own element. The deck is a native horizontal scroller - touch swipe and
   trackpad come free, so the pointer drag in the page script only has to
   cover the mouse. Per-deck differences (card width, what sits in the
   photo well) live in the `.deck--video` block further down. */
.deck {
  display: flex;
  align-items: flex-start;
  overflow-x: auto;
  overscroll-behavior-x: contain;
  scrollbar-width: none;
  /* The first card starts on the page rail; the last is free to run off
     the right edge, which is the whole point of the layout. */
  --deck-gutter: max(5%, calc(50% - var(--rail) / 2));
  padding-inline: var(--deck-gutter) 5%;
  scroll-padding-inline-start: var(--deck-gutter);
  /* Headroom for the lowest card's offset, its shadow and the hover lift. */
  padding-block: 26px 92px;
  cursor: grab;
  --ystep: 1px;
  --rstep: 1deg;
}
.deck::-webkit-scrollbar { display: none; }
/* Snapping is for a finger only. A wheel or trackpad on Linux sends no
   gesture phase, so the browser re-snaps after every event - each nudge
   was pulled back to the nearest card and the deck crawled sideways. A
   touch fling has a real end, so the snap lands once, where it should. */
@media (pointer: coarse) {
  .deck { scroll-snap-type: x proximity; }
}
.deck.is-dragging { cursor: grabbing; scroll-snap-type: none; }
.deck.is-dragging .deck-card { transition: none; }
/* A swipe slides every card past a still pointer, and each one it crossed
   would lift, swap its shadow and drain its neighbours mid-scroll. Taking
   the cards out of hit-testing until the rail settles holds hover off the
   same way a drag does; the rail itself still takes the wheel. */
.deck.is-scrolling .deck-card { pointer-events: none; }

.deck-card {
  position: relative;
  z-index: var(--z, 1);
  display: flex;
  flex-direction: column;
  flex: 0 0 auto;
  /* wide enough for a 13px kicker and the read pill on one line */
  width: clamp(228px, 19vw, 240px);
  /* the shingle: every card laps the one before it */
  margin-left: -30px;
  scroll-snap-align: start;
  border-radius: 21px;
  padding: 15px;
  overflow: hidden;
  text-decoration: none;
  box-shadow: 0 1px 2px rgba(20, 20, 15, 0.05), 0 14px 30px -18px rgba(20, 20, 15, 0.45);
  opacity: 0;
  translate: 0 calc(var(--y, 0) * var(--ystep) + 30px);
  /* The card pivots about a point low in its own body rather than its
     centre, so the tilt reads as one corner being lifted off the deck
     instead of the whole card spinning. */
  transform-origin: 50% 88%;
  /* A resting angle, on its own channel beside the other two. Each card
     sets its own `--r`, neighbours leaning opposite ways. */
  rotate: calc(var(--r, 0) * var(--rstep));
  /* Only compositor properties glide. `box-shadow` and `filter` swap in
     one step: tweened, they re-rasterise the whole card - photo, type and
     a 58px blur - on every frame, and the drain does it to all seven
     neighbours at once, which is what made sweeping the deck stutter. */
  transition: opacity .5s ease var(--d, 0s),
              translate .65s cubic-bezier(.2, .7, .3, 1) var(--d, 0s),
              transform .5s cubic-bezier(.2, .7, .3, 1),
              rotate .5s cubic-bezier(.2, .7, .3, 1);
}
.deck-card:first-child { margin-left: 0; }
.deck.is-in .deck-card { opacity: 1; translate: 0 calc(var(--y, 0) * var(--ystep)); }

/* Hover is held off while a drag is running: the pointer sweeps straight
   across the deck, and every card it crossed would otherwise pop. The
   cards already lie at an angle, so picking one up squares it to the page
   instead of adding a lean. */
.deck.is-in:not(.is-dragging) .deck-card:hover,
.deck.is-in:not(.is-dragging) .deck-card:focus-visible,
.deck.is-in:not(.is-dragging) .deck-card:has(:focus-visible) {
  z-index: 30;
  rotate: 0deg;
  transform: translateY(-16px) scale(1.035);
  box-shadow: 0 38px 58px -24px rgba(138, 101, 8, 0.7);
}
/* The rest of the deck drains rather than dims - `opacity` is already
   carrying the staggered entry with its own delay on it, and borrowing it
   here would make the drain arrive late. */
.deck.is-in:not(.is-dragging):has(.deck-card:hover) .deck-card:not(:hover) {
  filter: saturate(0.78);
}
.deck-card:focus-visible { outline: 3px solid #14140F; outline-offset: 4px; }

/* The honeycomb the CTA panel is tessellated with, reused at card scale.
   It is painted as a mask over `currentColor` rather than a fixed ink, so
   the comb comes up white on the dark cards and ink on the light ones
   without a second class. z-index -1 keeps it above the card's own colour
   and below its type. */
.deck-card::after {
  content: '';
  position: absolute;
  z-index: -1;
  inset: 0;
  pointer-events: none;
  background: currentColor;
  opacity: 0;
  -webkit-mask-image: url("data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' width='56' height='100'><g fill='none' stroke='white' stroke-width='1.3'><path d='M28 66L0 50L0 16L28 0L56 16L56 50L28 66L28 100'/><path d='M28 0L28 34L0 50L0 84L28 100L56 84L56 50L28 34'/></g></svg>");
  mask-image: url("data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' width='56' height='100'><g fill='none' stroke='white' stroke-width='1.3'><path d='M28 66L0 50L0 16L28 0L56 16L56 50L28 66L28 100'/><path d='M28 0L28 34L0 50L0 84L28 100L56 84L56 50L28 34'/></g></svg>");
  -webkit-mask-size: 45px 80px;
  mask-size: 45px 80px;
  transition: opacity .55s ease;
}
.deck.is-in:not(.is-dragging) .deck-card:hover::after,
.deck.is-in:not(.is-dragging) .deck-card:focus-visible::after { opacity: 0.1; }

.deck-kicker {
  margin-bottom: 0.4rem;
  font-size: 0.8125rem;
  font-weight: 500;
  letter-spacing: 0.1em;
  text-transform: uppercase;
}
.deck-title {
  margin-bottom: 1.1rem;
  font-family: 'Sora', system-ui, sans-serif;
  font-size: 0.97rem;
  font-weight: 600;
  line-height: 1.22;
  letter-spacing: -0.02em;
  /* three lines is where every headline in the set lands, so the images
     below them all start on the same line of the card */
  min-height: calc(1.22em * 3);
  display: -webkit-box;
  -webkit-line-clamp: 3;
  -webkit-box-orient: vertical;
  overflow: hidden;
}
.deck-shot {
  position: relative;
  display: block;
  margin-top: auto;
  aspect-ratio: 4 / 3;
  overflow: hidden;
  border-radius: 10px;
  background: rgba(255, 255, 255, 0.16);
}
.deck-shot img {
  display: block;
  height: 100%;
  width: 100%;
  object-fit: cover;
  transition: transform .6s cubic-bezier(.2, .7, .3, 1);
}
.deck.is-in:not(.is-dragging) .deck-card:hover .deck-shot img,
.deck.is-in:not(.is-dragging) .deck-card:focus-visible .deck-shot img { transform: scale(1.08); }

/* The call to read rises out of the bottom of the photo, the same move the
   team wall's captions make. White at near-full alpha so it lands legibly
   on any of the eight shots behind it. */
.deck-read {
  position: absolute;
  inset-inline: 9px;
  bottom: 9px;
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: 0.5rem;
  border-radius: 999px;
  padding: 0.28rem 0.3rem 0.28rem 0.7rem;
  background: rgba(255, 255, 255, 0.95);
  color: #14140F;
  font-family: 'Sora', system-ui, sans-serif;
  font-size: 0.8125rem;
  font-weight: 600;
  letter-spacing: -0.01em;
  white-space: nowrap;
  opacity: 0;
  translate: 0 16px;
  transition: opacity .3s ease, translate .42s cubic-bezier(.2, .7, .3, 1);
}
.deck.is-in:not(.is-dragging) .deck-card:hover .deck-read,
.deck.is-in:not(.is-dragging) .deck-card:focus-visible .deck-read { opacity: 1; translate: 0 0; }
.deck-read i {
  display: flex;
  align-items: center;
  justify-content: center;
  height: 20px;
  width: 20px;
  flex: 0 0 auto;
  border-radius: 999px;
  background: #F5A521;
}

/* ---- the video deck ---------------------------------------------------
   The same dealt hand with a wider card: a testimonial has to show a face
   big enough to recognise, and there are four of them rather than eight.
   The photo well keeps the thumbnail's own 16:9, the shape of the player
   it opens in the lightbox. */
.deck--video .deck-card { width: clamp(260px, 27vw, 348px); margin-left: -24px; }
.deck--video .deck-card:first-child { margin-left: 0; }
.deck--video .deck-title { font-size: 1.02rem; }
.deck--video .deck-shot { aspect-ratio: 16 / 9; cursor: pointer; }

.deck-scrim {
  position: absolute;
  inset: 0;
  background: linear-gradient(to top, rgba(20, 20, 15, 0.5) 0%, rgba(20, 20, 15, 0.1) 46%, rgba(20, 20, 15, 0.2) 100%);
  transition: opacity .4s ease;
}
.deck-card:hover .deck-scrim { opacity: 0.6; }

.deck-play {
  position: absolute;
  z-index: 1;
  left: 50%;
  top: 50%;
  translate: -50% -50%;
  display: flex;
  align-items: center;
  justify-content: center;
  height: 50px;
  width: 50px;
  border-radius: 999px;
  background-image: linear-gradient(135deg, #FFC24D 0%, #F5A521 62%, #E8931A 100%);
  color: #14140F;
  box-shadow: 0 6px 20px rgba(232, 147, 26, 0.42);
  transition: transform .35s cubic-bezier(.2, .7, .3, 1), box-shadow .35s ease;
}
/* the glyph is a triangle, so it reads centred only once nudged right */
.deck-play svg { margin-left: 2px; }
.deck-card:hover .deck-play {
  transform: scale(1.12);
  box-shadow: 0 10px 28px rgba(232, 147, 26, 0.55);
}
.deck-play:focus-visible { outline: 3px solid #FFFFFF; outline-offset: 3px; }
/* The ring travels only while the card is under the pointer. An infinite
   animation left running off screen goes on asking the compositor for
   frames for the whole life of the page - the same reason the hero's props
   are parked by an observer. */
.deck-play::after {
  content: '';
  position: absolute;
  inset: 0;
  border-radius: inherit;
  border: 2px solid rgba(245, 165, 33, 0.9);
  opacity: 0;
}
.deck-card:hover .deck-play::after { animation: deck-ping 1.5s cubic-bezier(0, 0, 0.2, 1) infinite; }
@keyframes deck-ping {
  0%   { transform: scale(1); opacity: 0.85; }
  100% { transform: scale(1.75); opacity: 0; }
}

/* The rating rides on the thumbnail rather than the card, so it reads the
   same on all four card colours. */
.deck-stars {
  position: absolute;
  z-index: 1;
  left: 9px;
  bottom: 9px;
  display: flex;
  align-items: center;
  gap: 2px;
  border-radius: 999px;
  padding: 0.24rem 0.45rem;
  background: rgba(255, 255, 255, 0.95);
  color: #F5A521;
}
.deck-stars svg { height: 10px; width: 10px; fill: currentColor; }

@media (prefers-reduced-motion: reduce) {
  .deck-play, .deck-scrim { transition: none !important; }
  .deck-card:hover .deck-play { transform: translate(0); }
  .deck-play::after { display: none; }
}

/* The deck's arrows. Ink on white, matching the sticker's offset shadow so
   the two controls in the header read as one family. */
.deck-nav {
  display: inline-flex;
  align-items: center;
  justify-content: center;
  height: 40px;
  width: 40px;
  border-radius: 999px;
  background: #FFFFFF;
  color: #14140F;
  box-shadow: 2px 2px 0 rgba(20, 20, 15, 0.82);
  transition: transform .2s ease, opacity .2s ease, background-color .2s ease;
}
.deck-nav:hover { background: #FFC24D; transform: translateY(-2px); }
.deck-nav:active { transform: translateY(0); }
.deck-nav[disabled] { opacity: 0.35; pointer-events: none; }
.deck-nav:focus-visible { outline: 3px solid #F5A521; outline-offset: 3px; }

/* The video lightbox's panel. As wide as the page allows, but never so
   wide that its 16:9 frame and the caption bar under it would run past a
   short viewport - a phone held sideways, a laptop with its toolbars. */
.video-panel { width: min(100%, 60rem, calc((100vh - 8rem) * 16 / 9)); }
@supports (height: 100dvh) {
  .video-panel { width: min(100%, 60rem, calc((100dvh - 8rem) * 16 / 9)); }
}

/* On a phone the row is read two cards at a time, so the stagger is halved
   and the shingle tightened - at full depth the low cards would push the
   section's floor down for no gain. */
@media (max-width: 639px) {
  .deck { --ystep: 0.48px; --rstep: 0.6deg; padding-block: 16px 60px; }
  .deck-card { margin-left: -22px; border-radius: 21px; }
  /* a quote needs more measure than a headline: on a phone the video card
     takes most of the screen rather than sharing it with its neighbour */
  .deck--video .deck-card { width: clamp(236px, 74vw, 288px); margin-left: -18px; }
}

@media (prefers-reduced-motion: reduce) {
  .deck-card, .deck-card::after, .deck-shot img, .deck-read, .deck-nav { transition: none !important; }
  /* the lift stays as a plain rise; the tilt and the zoom go */
  .deck.is-in .deck-card:hover,
  .deck.is-in .deck-card:focus-visible { transform: translateY(-8px); }
}

/* ---- Nav dropdowns ----------------------------------------------------
   Courses and Resources each gather their links behind one button.
   From `menu` up the list drops as a card under the button; below that,
   inside the Menu sheet, it opens in place as an indented group. The
   button's aria-expanded is the only state - the script flips it and
   everything here reads it. */
.nav-dd { position: relative; }
.nav-dd-link {
  display: block;
  white-space: nowrap;
  border-radius: 10px;
  padding: 8px 12px;
  font-size: 14.5px;
  font-weight: 500;
  color: #55554B;
  text-decoration: none;
  transition: background-color .15s ease, color .15s ease;
}
.nav-dd-link:hover,
.nav-dd-link[aria-current="page"] { background: #F2EEE3; color: #14140F; }
/* Current page in the main nav: ink text over a honey bar the width of the label, rather
   than the grey chip that hover already uses. The mobile menu stacks the
   links, so there the bar moves to the left edge over a honey wash. */
#navLinks > li > a[aria-current="page"],
#navLinks > li > button[data-current] { position: relative; color: #14140F; }
#navLinks > li > a[aria-current="page"]::after,
#navLinks > li > button[data-current]::after {
  content: "";
  position: absolute;
  left: 12px;
  right: 12px;
  bottom: 0;
  height: 3px;
  border-radius: 999px;
  background: #F5A521;
}
@media (max-width: 1023.98px) {
  #navLinks > li > a[aria-current="page"],
  #navLinks > li > button[data-current] {
    background: linear-gradient(135deg, rgba(255,194,77,0.26) 0%, rgba(245,165,33,0.17) 62%, rgba(232,147,26,0.14) 100%);
  }
  #navLinks > li > a[aria-current="page"]::after,
  #navLinks > li > button[data-current]::after {
    left: 0; right: auto; top: 50%; bottom: auto;
    width: 3px; height: 60%;
    transform: translateY(-50%);
  }
}
@media (min-width: 1024px) {
  .nav-dd-panel {
    position: absolute;
    top: calc(100% + 10px);
    left: 50%;
    min-width: 180px;
    padding: 6px;
    border-radius: 16px;
    background: #FFFFFF;
    box-shadow: 0 2px 6px rgba(20, 20, 15, 0.05), 0 18px 44px rgba(138, 101, 8, 0.14);
    opacity: 0;
    visibility: hidden;
    transform: translate(-50%, -6px);
    transition: opacity .18s ease, transform .18s ease, visibility 0s linear .18s;
  }
  /* bridges the gap under the button, so the pointer can cross to the card
     without the group closing on the way */
  .nav-dd-panel::before { content: ''; position: absolute; inset: -10px 0 auto; height: 10px; }
  [aria-expanded="true"] + .nav-dd-panel {
    opacity: 1;
    visibility: visible;
    transform: translate(-50%, 0);
    transition: opacity .18s ease, transform .18s ease, visibility 0s;
  }
}
@media (max-width: 1023.98px) {
  .nav-dd-panel { margin: 2px 0 4px 14px; padding-left: 10px; border-left: 2px solid #E9E3D3; }
  [aria-expanded="false"] + .nav-dd-panel { display: none; }
  .nav-dd-link { padding: 10px 14px; font-size: 15px; }
}
@media (prefers-reduced-motion: reduce) {
  .nav-dd-panel { transition: none !important; }
}

/* ---- Menu sheet (below `menu`) ----------------------------------------
   Stays laid out while closed so it can animate: it unrolls downward from
   the bar and the rows follow one after another. On close it rolls back
   up quicker than it came down. The script only toggles .is-open. */
@media (max-width: 1023.98px) {
  #navLinks {
    display: flex;
    visibility: hidden;
    opacity: 0;
    transform: translateY(-10px);
    clip-path: inset(0 0 100% 0);
    transition: clip-path .32s cubic-bezier(.4,0,.2,1), transform .32s cubic-bezier(.4,0,.2,1), opacity .24s ease .06s, visibility 0s linear .32s;
  }
  #navLinks.is-open {
    visibility: visible;
    opacity: 1;
    transform: none;
    clip-path: inset(0 -60px -60px -60px);
    transition: clip-path .5s cubic-bezier(.22,1,.36,1), transform .5s cubic-bezier(.22,1,.36,1), opacity .2s ease, visibility 0s;
  }
  #navLinks > li { opacity: 0; transform: translateY(-8px); transition: opacity .15s ease, transform .15s ease; }
  #navLinks.is-open > li {
    opacity: 1;
    transform: none;
    transition: opacity .35s ease var(--d, 0s), transform .5s cubic-bezier(.22,1,.36,1) var(--d, 0s);
  }
  #navLinks.is-open > li:nth-child(1) { --d: .06s; }
  #navLinks.is-open > li:nth-child(2) { --d: .1s; }
  #navLinks.is-open > li:nth-child(3) { --d: .14s; }
  #navLinks.is-open > li:nth-child(4) { --d: .18s; }
  #navLinks.is-open > li:nth-child(5) { --d: .22s; }
  #navLinks.is-open > li:nth-child(6) { --d: .26s; }
  #navLinks.is-open > li:nth-child(7) { --d: .3s; }
  #navLinks.is-open > li:nth-child(8) { --d: .34s; }
}
@media (max-width: 1023.98px) and (prefers-reduced-motion: reduce) {
  #navLinks, #navLinks > li { transform: none !important; transition: none !important; }
}

/* Back to top. Held out of sight until the reader is most of a screen down,
   then it rises into the corner. The honey ring fills with how far through
   the page they are - pathLength="1" on the circle makes its dash offset a
   plain 0-1 fraction. Visibility flips at the end of the fade, so a hidden
   button can be neither clicked nor tabbed to. */
.to-top {
  margin-bottom: env(safe-area-inset-bottom);
  opacity: 0;
  visibility: hidden;
  translate: 0 14px;
  scale: 0.9;
  transition: opacity 0.25s ease, translate 0.35s cubic-bezier(0.22, 1, 0.36, 1), scale 0.35s cubic-bezier(0.22, 1, 0.36, 1), box-shadow 0.2s ease, visibility 0s linear 0.35s;
}
.to-top.is-shown { opacity: 1; visibility: visible; translate: 0 0; scale: 1; transition-delay: 0s; }
.to-top.is-shown:hover { translate: 0 -2px; box-shadow: 0 16px 34px -10px rgba(20,20,15,0.6); }
.to-top-ring { stroke-dasharray: 1; stroke-dashoffset: 1; }
@media (prefers-reduced-motion: reduce) {
  .to-top, .to-top.is-shown, .to-top.is-shown:hover { translate: none; scale: none; }
}

/* ── Review cards ─────────────────────────────────────────────────
   The dealt deck's cards, filled with a Google review in place of a
   photo: a fixed height so the row stays even, and the text clamped. */
.rv-card { min-height: 270px; }
.deck--reviews .deck-card { width: clamp(300px, 26vw, 360px); margin-left: -28px; padding: 16px; }
.deck--reviews .deck-card:first-child { margin-left: 0; }
.rv-text { display: -webkit-box; -webkit-line-clamp: 6; -webkit-box-orient: vertical; overflow: hidden; }
.rv-card .deck-read { position: static; box-sizing: border-box; width: 100%; margin-top: auto; opacity: 1; translate: 0 0; }
.rv-text { margin-bottom: 0.9rem; }

/* ── Why-us illustrations ────────────────────────────────────────
   Each drawing keeps moving: the whole picture floats in its tile and one
   part of it plays on a loop. Hovering the card makes the tile jump. */
#why-us svg * { transform-box: fill-box; }
#why-us li > span { transition: transform .4s cubic-bezier(.3,1.6,.5,1); }
#why-us li:hover > span { transform: translateY(-6px) rotate(-8deg) scale(1.1); }
#why-us li > span svg { animation: wy-float 3s ease-in-out infinite; }
#why-us li:nth-child(even) > span svg { animation-delay: -1.5s; }
.wy-blink { animation: wy-blink 1s steps(2, jump-none) infinite; }
.wy-bob { animation: wy-bob 1.6s ease-in-out infinite; }
.wy-draw { stroke-dasharray: 1; animation: wy-draw 2.4s ease-in-out infinite; }
.wy-write { transform-origin: 0% 100%; animation: wy-write .8s ease-in-out infinite; }
.wy-sweep { transform-origin: 50% 100%; animation: wy-sweep 2s linear infinite; }
.wy-bar { transform-origin: 50% 100%; animation: wy-bar 2s cubic-bezier(.3,1.5,.5,1) infinite; }
.wy-twinkle { transform-origin: center; animation: wy-twinkle 1.6s ease-in-out infinite; }
.wy-wave { animation: wy-wave 1.2s ease-in-out infinite; }
.wy-progress { stroke-dasharray: 1; animation: wy-progress 3s linear infinite; }
.wy-beat { transform-origin: center; animation: wy-beat 1s ease-in-out infinite; }
@keyframes wy-wave { 0%, 100% { opacity: .15; } 50% { opacity: 1; } }
@keyframes wy-progress { 0% { stroke-dashoffset: 1; } 90%, 100% { stroke-dashoffset: 0; } }
@keyframes wy-float { 0%, 100% { transform: translateY(0) rotate(0); } 50% { transform: translateY(-4px) rotate(-4deg); } }
@keyframes wy-blink { 50% { opacity: 0; } }
@keyframes wy-bob { 50% { transform: translateY(-5px) rotate(-6deg); } }
@keyframes wy-draw { 0% { stroke-dashoffset: 1; } 45%, 80% { stroke-dashoffset: 0; } 100% { stroke-dashoffset: 1; } }
@keyframes wy-write { 0%, 100% { transform: rotate(0) translateX(0); } 50% { transform: rotate(-16deg) translateX(-3px); } }
@keyframes wy-sweep { to { transform: rotate(360deg); } }
@keyframes wy-bar { 0%, 100% { transform: scaleY(.15); } 40%, 75% { transform: scaleY(1); } }
@keyframes wy-twinkle { 0%, 100% { transform: scale(.8) rotate(0); } 50% { transform: scale(1.5) rotate(72deg); } }
@keyframes wy-beat { 0%, 100% { transform: scale(1); } 15% { transform: scale(1.45); } 30% { transform: scale(.9); } 45% { transform: scale(1.3); } }
@media (prefers-reduced-motion: reduce) {
  #why-us svg, #why-us svg * { animation: none !important; }
  #why-us li > span { transition: none; }
}
