/* ══════════════════════════════════════════════════════════════════════════
   prod-features-fig.css — v1.0.6
   Product features figure. Shared by every product page.

   VERSION: overhaul.major.minor. Bump it on every upload, because the CDN can
   serve a stale copy for a while. To check which one a page actually has:

     getComputedStyle(document.documentElement).getPropertyValue('--fig-version')

   The page supplies --fig-hl and --fig-base on .section-features; the :root
   values below are only a fallback, so a page that forgets still renders. The
   section is nearer than :root in the inheritance chain, so its values win
   without any specificity contest.

   Pairs with prod-features-fig.js (same version) and with the SVG pasted
   inline in the grid's centre cell.
   ══════════════════════════════════════════════════════════════════════════ */

/* ██ 1. TOKENS ██████████████████████████████████████████████████████████████ */
:root {
  --fig-version: "1.0.6";   /* Read it back from the console; see the header. */

  /* ── COLOUR — fallbacks only. The page sets these on .section-features. ── */
  --fig-hl:        #0C72E9;
  --fig-base:      #FFFFFF;

  /* ── DIALS — every number that drives motion. Nothing below is a literal
        time; the derived block welds these into the triples the transitions
        consume. Tune here and only here. ─────────────────────────────────── */
  --fig-curve:                ease-in-out;

  --fig-d-polygon-in:          300ms;  /* Facet arriving; card stroke too.      */
  --fig-d-polygon-out:         300ms;  /* Facet leaving.                        */
  --fig-d-glow-in:             300ms;  /* Figure bloom and card wash arriving.  */
  --fig-d-glow-out:            300ms;  /* Same, leaving.                        */
  --fig-d-outline:             120ms;  /* Grid opacity.                         */

  /* Intro */
  --fig-intro-grid:            500ms;  /* Grid builds, centre outward.          */
  --fig-intro-pause:           300ms;  /* Beat before the facets start.         */
  --fig-intro-facets:          700ms;  /* One facet's flash.                    */
  --fig-intro-stagger:          60ms;  /* Between flash waves.                  */
  --fig-intro-boot:            300ms;  /* Top takes the accent, after its blinks.*/
  --fig-intro-boot-at:          0.68;  /* Where in wave 1 that starts. 0.68 = the
                                          frame its last blink settles on.      */
  --fig-intro-curve:        ease-out;  /* Grid fade-in.                         */
  --fig-intro-flash:          linear;  /* Flash steps want even timing.         */

  /* ── APPEARANCE ─────────────────────────────────────────────────────────── */
  --fig-grid-color:   #FFFFFF;
  --fig-grid-opacity: 0.15;
  --fig-grid-dash:    4 3;
  --fig-el-glow: 1;           /* Card overlay intensity. 1 = matches Figma. */
  --fig-el-wash: 0.2;         /* Card wash: broad accent ellipse, centre alpha. */
  --fig-el-core: 0.1;         /* Card wash: tight white core on top of it. */

  /* ── DERIVED — composition only, no new numbers. Each token is
        "<duration> <curve> <delay>", consumed whole by one transition.
        polygon = a facet or a card's stroke; glow = a bloom or a card wash. ── */
  --fig-t-polygon-in:       var(--fig-d-polygon-in) var(--fig-curve) 0ms;
  --fig-t-polygon-out:      var(--fig-d-polygon-out) var(--fig-curve) 0ms;
  --fig-t-glow-in:          var(--fig-d-glow-in) var(--fig-curve) 0ms;
  --fig-t-glow-out:         var(--fig-d-glow-out) var(--fig-curve) 0ms;

  --fig-t-card-stroke-in:   var(--fig-t-polygon-in);
  --fig-t-card-stroke-out:  var(--fig-t-polygon-out);
  --fig-t-card-glow-in:     var(--fig-t-glow-in);
  --fig-t-card-glow-out:    var(--fig-t-glow-out);

  --fig-ease: var(--fig-d-outline) var(--fig-curve);

  --fig-intro-at: calc(var(--fig-intro-grid) + var(--fig-intro-pause));

  /* Five flash waves: 1 Top · 2 MidTop pair · 3 MidBot pair · 4 Bot pair
     · 5 Bottom. -at is split out so anything else can offset from it. */
  --fig-wave-1-at: var(--fig-intro-at);
  --fig-wave-2-at: calc(var(--fig-intro-at) + 1 * var(--fig-intro-stagger));
  --fig-wave-3-at: calc(var(--fig-intro-at) + 2 * var(--fig-intro-stagger));
  --fig-wave-4-at: calc(var(--fig-intro-at) + 3 * var(--fig-intro-stagger));
  --fig-wave-5-at: calc(var(--fig-intro-at) + 4 * var(--fig-intro-stagger));

  --fig-wave-1: var(--fig-intro-facets) var(--fig-intro-flash) var(--fig-wave-1-at);
  --fig-wave-2: var(--fig-intro-facets) var(--fig-intro-flash) var(--fig-wave-2-at);
  --fig-wave-3: var(--fig-intro-facets) var(--fig-intro-flash) var(--fig-wave-3-at);
  --fig-wave-4: var(--fig-intro-facets) var(--fig-intro-flash) var(--fig-wave-4-at);
  --fig-wave-5: var(--fig-intro-facets) var(--fig-intro-flash) var(--fig-wave-5-at);

  /* The boot: when the figure stops being monochrome. */
  --fig-boot-at: calc(var(--fig-wave-1-at)
                 + var(--fig-intro-facets) * var(--fig-intro-boot-at));
}

/* ██ 2. FIGURE — base state ████████████████████████████████████████████████ */
#prod-features_fig {
  --fig-o-Top:          1;
  --fig-o-MidTopLeft:   0.5;
  --fig-o-MidTopRight:  0.5;
  --fig-o-MidBotLeft:   0.5;
  --fig-o-MidBotRight:  0.5;
  --fig-o-BotLeft:      0.3;
  --fig-o-BotRight:     0.3;
  --fig-o-Bottom:       0.3;

  /* Base accents Top and glows it; each state hands both to its own facet.
     Top arrives white though — see the boot animations in section 3. */
  --fig-fill-Top:         var(--fig-hl);
  --fig-fill-MidTopLeft:  var(--fig-base);
  --fig-fill-MidTopRight: var(--fig-base);
  --fig-fill-MidBotLeft:  var(--fig-base);
  --fig-fill-MidBotRight: var(--fig-base);
  --fig-fill-BotLeft:     var(--fig-base);
  --fig-fill-BotRight:    var(--fig-base);

  --fig-glow-Top:         1;
  --fig-glow-MidTopLeft:  0;
  --fig-glow-MidTopRight: 0;
  --fig-glow-MidBotLeft:  0;
  --fig-glow-MidBotRight: 0;
  --fig-glow-BotLeft:     0;
  --fig-glow-BotRight:    0;

  /* Timing is per facet because in and out differ, and CSS resolves a transition
     from the after-change style — so it has to sit beside the target values, in
     every state block. Base is the state where Top is incoming.
     tp drives a facet's fill and fill-opacity, tg its bloom's. */
  --fig-tp-Top:          var(--fig-t-polygon-in);
  --fig-tp-MidTopLeft:   var(--fig-t-polygon-out);
  --fig-tp-MidTopRight:  var(--fig-t-polygon-out);
  --fig-tp-MidBotLeft:   var(--fig-t-polygon-out);
  --fig-tp-MidBotRight:  var(--fig-t-polygon-out);
  --fig-tp-BotLeft:      var(--fig-t-polygon-out);
  --fig-tp-BotRight:     var(--fig-t-polygon-out);
  --fig-tp-Bottom:       var(--fig-t-polygon-out);

  --fig-tg-Top:          var(--fig-t-glow-in);
  --fig-tg-MidTopLeft:   var(--fig-t-glow-out);
  --fig-tg-MidTopRight:  var(--fig-t-glow-out);
  --fig-tg-MidBotLeft:   var(--fig-t-glow-out);
  --fig-tg-MidBotRight:  var(--fig-t-glow-out);
  --fig-tg-BotLeft:      var(--fig-t-glow-out);
  --fig-tg-BotRight:     var(--fig-t-glow-out);

  /* The two lines the Designer cannot reach, because this element lives inside
     an HTML Embed. display, or the SVG sits on the text baseline; overflow,
     because the UA stylesheet forces hidden on a root <svg> and a presentation
     attribute cannot beat it — the bloom would clip at the viewBox edge. */
  display: block;
  overflow: visible;
}

/* `1fr` is `minmax(auto, 1fr)`: a min-content floor the fr units cannot eat
   into. Delete if you set Min W: 0 in Webflow. */
.prod-features_grid > * { min-width: 0; min-height: 0; }

/* ██ 3. WIRING █████████████████████████████████████████████████████████████ */
#fig_grid path { stroke-dasharray: var(--fig-grid-dash); }

#fig_grid {
  stroke: var(--fig-grid-color);
  opacity: var(--fig-grid-opacity);
  transition: opacity var(--fig-ease), stroke var(--fig-ease);
}

/* -- FIRST LOAD -----------------------------------------------------------
   Grid builds, a beat, then the facets flash on in five waves.

   The grid BUILDS rather than draws: a line-drawing reveal needs the dash
   offset and these lines already spend their dashes on being dashed. Each path
   fades in on a delay set by its own ring, so the lattice arrives as an
   expanding wavefront. The ring is baked into the path as r0-r7, which
   re-ordering cannot break. */
@keyframes fig-build { from { opacity: 0; } to { opacity: 1; } }

/* Three flashes: full white, resting + 0.25, then resting.

   This rides fill-opacity, not opacity. opacity only MULTIPLIES the declared
   fill-opacity, and the deepest facets rest at 0.3 — they could never flash
   brighter than that. Absolute values need the property itself.

   So the fill mode is `backwards`, never `both`: backwards holds the 0% frame
   through the delay, which is what lets the build sit paused until the section
   arrives, then hands the property back to the state blocks. `both` would
   freeze every facet on its last keyframe and kill hover.

   --fig-o-base is the facet's own resting alpha, deliberately not --fig-o-Top,
   which a hover rewrites. Top rests at 1, so its middle step clamps and it
   holds white; lower its resting alpha if it should pulse. */
/* THE BOOT. Everything flashes on white; only once Top's last blink has settled
   does it take the accent and its bloom rise, so the figure reads as powering up
   rather than as already on.

   Neither animation uses `forwards`. Each ENDS on exactly the value its element
   declares, so when it finishes the property simply reverts to that declaration
   with no visible step — and nothing is left holding the property, so hover
   transitions work normally afterwards. `backwards` holds the 0% frame through
   the delay, which is what keeps Top white while the blinks run and lets the
   whole thing sit paused until the section arrives. */
@keyframes fig-boot-tint {
  from { fill: var(--fig-base); }
  to   { fill: var(--fig-hl); }
}

@keyframes fig-boot-bloom {
  from { fill-opacity: 0; }
  to   { fill-opacity: var(--fig-glow-Top); }
}

@keyframes fig-flash {
  0%, 10% { fill-opacity: 0; }
  16%     { fill-opacity: 1; }                               /* white    */
  26%     { fill-opacity: 0; }
  42%     { fill-opacity: calc(var(--fig-o-base) + 0.25); }  /* mid step */
  52%     { fill-opacity: 0; }
  68%     { fill-opacity: var(--fig-o-base); }               /* resting  */
  100%    { fill-opacity: var(--fig-o-base); }
}

.fig_gridline {
  animation: fig-build calc(var(--fig-intro-grid) / 2.5) var(--fig-intro-curve) both;
}
.fig_gridline.r0 { animation-delay: calc(var(--fig-intro-grid) * 0.000); }
.fig_gridline.r1 { animation-delay: calc(var(--fig-intro-grid) * 0.089); }
.fig_gridline.r2 { animation-delay: calc(var(--fig-intro-grid) * 0.177); }
.fig_gridline.r3 { animation-delay: calc(var(--fig-intro-grid) * 0.266); }
.fig_gridline.r4 { animation-delay: calc(var(--fig-intro-grid) * 0.354); }
.fig_gridline.r5 { animation-delay: calc(var(--fig-intro-grid) * 0.443); }
.fig_gridline.r6 { animation-delay: calc(var(--fig-intro-grid) * 0.531); }
.fig_gridline.r7 { animation-delay: calc(var(--fig-intro-grid) * 0.620); }

/* Only the facets take pointer events, so hovering a shape lights it and its
   card. The blooms sit over them and would swallow every hover — blurred far
   past their own outline. Everything else is inert. */
#fig_glows, #fig_grid { pointer-events: none; }
.fig_facet { pointer-events: auto; }

/* Facets. fill and fill-opacity share --fig-tp-*, so a facet tints and dims on
   one clock. Bottom never highlights, so it has no fill variable. */
#facet_Top         { --fig-o-base: 1;   fill: var(--fig-fill-Top);         fill-opacity: var(--fig-o-Top);
  transition: fill var(--fig-tp-Top), fill-opacity var(--fig-tp-Top);
  animation: fig-flash var(--fig-wave-1) backwards,
             fig-boot-tint var(--fig-intro-boot) var(--fig-curve) var(--fig-boot-at) backwards; }
#facet_MidTopLeft  { --fig-o-base: 0.5; fill: var(--fig-fill-MidTopLeft);  fill-opacity: var(--fig-o-MidTopLeft);
  transition: fill var(--fig-tp-MidTopLeft), fill-opacity var(--fig-tp-MidTopLeft);
  animation: fig-flash var(--fig-wave-2) backwards; }
#facet_MidTopRight { --fig-o-base: 0.5; fill: var(--fig-fill-MidTopRight); fill-opacity: var(--fig-o-MidTopRight);
  transition: fill var(--fig-tp-MidTopRight), fill-opacity var(--fig-tp-MidTopRight);
  animation: fig-flash var(--fig-wave-2) backwards; }
#facet_MidBotLeft  { --fig-o-base: 0.5; fill: var(--fig-fill-MidBotLeft);  fill-opacity: var(--fig-o-MidBotLeft);
  transition: fill var(--fig-tp-MidBotLeft), fill-opacity var(--fig-tp-MidBotLeft);
  animation: fig-flash var(--fig-wave-3) backwards; }
#facet_MidBotRight { --fig-o-base: 0.5; fill: var(--fig-fill-MidBotRight); fill-opacity: var(--fig-o-MidBotRight);
  transition: fill var(--fig-tp-MidBotRight), fill-opacity var(--fig-tp-MidBotRight);
  animation: fig-flash var(--fig-wave-3) backwards; }
#facet_BotLeft     { --fig-o-base: 0.3; fill: var(--fig-fill-BotLeft);     fill-opacity: var(--fig-o-BotLeft);
  transition: fill var(--fig-tp-BotLeft), fill-opacity var(--fig-tp-BotLeft);
  animation: fig-flash var(--fig-wave-4) backwards; }
#facet_BotRight    { --fig-o-base: 0.3; fill: var(--fig-fill-BotRight);    fill-opacity: var(--fig-o-BotRight);
  transition: fill var(--fig-tp-BotRight), fill-opacity var(--fig-tp-BotRight);
  animation: fig-flash var(--fig-wave-4) backwards; }
#facet_Bottom      { --fig-o-base: 0.3; fill: var(--fig-base);             fill-opacity: var(--fig-o-Bottom);
  transition: fill var(--fig-tp-Bottom), fill-opacity var(--fig-tp-Bottom);
  animation: fig-flash var(--fig-wave-5) backwards; }

/* Blooms. No intro animation — they sit at 0 through the build and light on
   hover. No colour path either: a bloom rises from nothing already at hl.

   Top is the exception: the base state glows it, so its bloom would be lit from
   the first paint. fig-boot-bloom holds it at 0 and raises it with the tint. */
#glow_Top         { fill: var(--fig-fill-Top);         fill-opacity: var(--fig-glow-Top);
                    transition: fill-opacity var(--fig-tg-Top), fill var(--fig-tg-Top);
                    animation: fig-boot-bloom var(--fig-intro-boot) var(--fig-curve) var(--fig-boot-at) backwards; }
#glow_MidTopLeft  { fill: var(--fig-fill-MidTopLeft);  fill-opacity: var(--fig-glow-MidTopLeft);
                    transition: fill-opacity var(--fig-tg-MidTopLeft), fill var(--fig-tg-MidTopLeft); }
#glow_MidTopRight { fill: var(--fig-fill-MidTopRight); fill-opacity: var(--fig-glow-MidTopRight);
                    transition: fill-opacity var(--fig-tg-MidTopRight), fill var(--fig-tg-MidTopRight); }
#glow_MidBotLeft  { fill: var(--fig-fill-MidBotLeft);  fill-opacity: var(--fig-glow-MidBotLeft);
                    transition: fill-opacity var(--fig-tg-MidBotLeft), fill var(--fig-tg-MidBotLeft); }
#glow_MidBotRight { fill: var(--fig-fill-MidBotRight); fill-opacity: var(--fig-glow-MidBotRight);
                    transition: fill-opacity var(--fig-tg-MidBotRight), fill var(--fig-tg-MidBotRight); }
#glow_BotLeft     { fill: var(--fig-fill-BotLeft);     fill-opacity: var(--fig-glow-BotLeft);
                    transition: fill-opacity var(--fig-tg-BotLeft), fill var(--fig-tg-BotLeft); }
#glow_BotRight    { fill: var(--fig-fill-BotRight);    fill-opacity: var(--fig-glow-BotRight);
                    transition: fill-opacity var(--fig-tg-BotRight), fill var(--fig-tg-BotRight); }

/* ── THE BUILD WAITS FOR THE SECTION ───────────────────────────────────────
   Every intro animation has a fill mode holding its 0% frame while it waits, so
   pausing at time zero leaves the figure invisible rather than half-built, and
   the delays freeze too so the waves still stagger from the moment of release.
   The script adds .fig-in when the section scrolls in, once per load.

   .fig-js gates the PAUSE, so with JavaScript off nothing is ever paused and
   the build just runs — no separate fallback needed. The specificity is
   deliberate: `animation` is a shorthand and resets play-state to running from
   an id selector, so each pause outranks it at 1-2-0 and each release outranks
   the pause at 1-3-0, independent of source order. */
.fig-js #prod-features_fig .fig_gridline,
.fig-js #prod-features_fig .fig_glow,
.fig-js #prod-features_fig .fig_facet { animation-play-state: paused; }

.fig-js.fig-in #prod-features_fig .fig_gridline,
.fig-js.fig-in #prod-features_fig .fig_glow,
.fig-js.fig-in #prod-features_fig .fig_facet { animation-play-state: running; }

/* ██ 4. CARD — Figma "Element 1" 1135:4346 ████████████████████████████████
   ::before = the wash: TWO overlapped radial gradients sharing one centre on
              the lit edge — a broad accent ellipse (100% by 50%, alpha 0.2) and
              a tight white core over it (19.35% by 37.23%, alpha 0.1). Both
              fade to transparent accent, never to `transparent`, which would go
              grey. In CSS the FIRST gradient listed paints on top, the reverse
              of Figma's fills array.
   ::after  = the 1px stroke, a vertical gradient: nothing at the ends, accent at
              the quarters, white at the centre. inset: 0 -1px puts it outside
              the edge, as align OUTSIDE does.
   Two pseudo-elements so the layers can run on separate clocks; ::after paints
   last so the line sits over the wash. isolation: isolate keeps z-index: -1
   inside the card, under the text but over its background.
   The lit edge faces the figure: left-column card lights right, and vice versa.

   The two accent derivations live HERE, on the card, not up in :root with the
   rest of the derived tokens. A var() inside a custom property is substituted
   where that property is DECLARED, and the result is what descendants inherit —
   so declaring them at :root baked in :root's fallback accent, and the page's
   own --fig-hl on .section-features never reached them. The figure was tinting
   correctly because it reads var(--fig-hl) straight into `fill`; the cards were
   reading a value that had already resolved to the fallback. Declared on the
   card, they resolve against the card's inherited accent. */
.prod-features_element-card-left,
.prod-features_element-card-right {
  position: relative;
  isolation: isolate;
  --fig-hl-0:    rgb(from var(--fig-hl) r g b / 0);
  --fig-hl-wash: rgb(from var(--fig-hl) r g b / var(--fig-el-wash));
}

.prod-features_element-card-left  { --fig-el-side: right; --fig-el-x: 100%; }
.prod-features_element-card-right { --fig-el-side: left;  --fig-el-x: 0%; }

/* Tablet and below the grid stacks, so "facing the figure" stops meaning
   anything and every card lights its left edge. Both layers read these two. */
@media (max-width: 991px) {
  .prod-features_element-card-left,
  .prod-features_element-card-right { --fig-el-side: left; --fig-el-x: 0%; }
}

.prod-features_element-card-left::before,
.prod-features_element-card-left::after,
.prod-features_element-card-right::before,
.prod-features_element-card-right::after {
  content: "";
  position: absolute;
  z-index: -1;
  pointer-events: none;
  opacity: 0;
  background-repeat: no-repeat;
}

.prod-features_element-card-left::before,
.prod-features_element-card-right::before {
  inset: 0;
  transition: opacity var(--fig-t-card-glow-out);
  background-image:
    radial-gradient(ellipse 19.35% 37.23% at var(--fig-el-x) 50%,
      rgb(255 255 255 / var(--fig-el-core)) 0%,
      var(--fig-hl-0)                     100%),
    radial-gradient(ellipse 100% 50% at var(--fig-el-x) 50%,
      var(--fig-hl-wash) 0%,
      var(--fig-hl-0)  100%);
}

.prod-features_element-card-left::after,
.prod-features_element-card-right::after {
  inset: 0 -1px;
  transition: opacity var(--fig-t-card-stroke-out);
  background-size: 1px 100%;
  background-position: var(--fig-el-side) 0;
  background-image:
    linear-gradient(to bottom,
      var(--fig-hl-0)    0%,
      var(--fig-hl)     25%,
      #FFFFFF           50%,
      var(--fig-hl)     75%,
      var(--fig-hl-0)  100%);
}

/* :hover for the pointer, .is-active for scroll/touch where there is none. */
.prod-features_element-card-left:hover::before,
.prod-features_element-card-right:hover::before,
.prod-features_element-card-left:focus-visible::before,
.prod-features_element-card-right:focus-visible::before,
.prod-features_element-card-left.is-active::before,
.prod-features_element-card-right.is-active::before {
  opacity: var(--fig-el-glow);
  transition: opacity var(--fig-t-card-glow-in);
}

.prod-features_element-card-left:hover::after,
.prod-features_element-card-right:hover::after,
.prod-features_element-card-left:focus-visible::after,
.prod-features_element-card-right:focus-visible::after,
.prod-features_element-card-left.is-active::after,
.prod-features_element-card-right.is-active::after {
  opacity: var(--fig-el-glow);
  transition: opacity var(--fig-t-card-stroke-in);
}

/* ██ 5. STATES █████████████████████████████████████████████████████████████
   Each block rewrites the outgoing Top, the incoming facet, and their timings.
   The :not(.fig-js) pair is the CSS-only fallback for when the script has not
   run; it cannot cover the facets as hit targets, which need the script. */

/* 01 — Mid-Top-Left */
.prod-features_grid:not(.fig-js):has(.is-midtopleft:is(:hover, :focus-visible)) #prod-features_fig,
.prod-features_grid.state-midtopleft #prod-features_fig {
  --fig-o-Top: 0.3;
  --fig-fill-Top: var(--fig-base);
  --fig-glow-Top: 0;
  --fig-tp-Top: var(--fig-t-polygon-out);
  --fig-tg-Top: var(--fig-t-glow-out);
  --fig-o-MidTopLeft: 1;
  --fig-fill-MidTopLeft: var(--fig-hl);
  --fig-glow-MidTopLeft: 1;
  --fig-tp-MidTopLeft: var(--fig-t-polygon-in);
  --fig-tg-MidTopLeft: var(--fig-t-glow-in);
}

/* 02 — Mid-Bot-Left */
.prod-features_grid:not(.fig-js):has(.is-midbotleft:is(:hover, :focus-visible)) #prod-features_fig,
.prod-features_grid.state-midbotleft #prod-features_fig {
  --fig-o-Top: 0.3;
  --fig-fill-Top: var(--fig-base);
  --fig-glow-Top: 0;
  --fig-tp-Top: var(--fig-t-polygon-out);
  --fig-tg-Top: var(--fig-t-glow-out);
  --fig-o-MidBotLeft: 1;
  --fig-fill-MidBotLeft: var(--fig-hl);
  --fig-glow-MidBotLeft: 1;
  --fig-tp-MidBotLeft: var(--fig-t-polygon-in);
  --fig-tg-MidBotLeft: var(--fig-t-glow-in);
}

/* 03 — Mid-Bot-Right */
.prod-features_grid:not(.fig-js):has(.is-midbotright:is(:hover, :focus-visible)) #prod-features_fig,
.prod-features_grid.state-midbotright #prod-features_fig {
  --fig-o-Top: 0.3;
  --fig-fill-Top: var(--fig-base);
  --fig-glow-Top: 0;
  --fig-tp-Top: var(--fig-t-polygon-out);
  --fig-tg-Top: var(--fig-t-glow-out);
  --fig-o-MidBotRight: 1;
  --fig-fill-MidBotRight: var(--fig-hl);
  --fig-glow-MidBotRight: 1;
  --fig-tp-MidBotRight: var(--fig-t-polygon-in);
  --fig-tg-MidBotRight: var(--fig-t-glow-in);
}

/* 04 — Mid-Top-Right */
.prod-features_grid:not(.fig-js):has(.is-midtopright:is(:hover, :focus-visible)) #prod-features_fig,
.prod-features_grid.state-midtopright #prod-features_fig {
  --fig-o-Top: 0.3;
  --fig-fill-Top: var(--fig-base);
  --fig-glow-Top: 0;
  --fig-tp-Top: var(--fig-t-polygon-out);
  --fig-tg-Top: var(--fig-t-glow-out);
  --fig-o-MidTopRight: 1;
  --fig-fill-MidTopRight: var(--fig-hl);
  --fig-glow-MidTopRight: 1;
  --fig-tp-MidTopRight: var(--fig-t-polygon-in);
  --fig-tg-MidTopRight: var(--fig-t-glow-in);
}

/* 05 — Bot-Right. The two Bot states re-weight the whole shape, off Figma. */
.prod-features_grid:not(.fig-js):has(.is-botright:is(:hover, :focus-visible)) #prod-features_fig,
.prod-features_grid.state-botright #prod-features_fig {
  --fig-o-Top: 0.15;
  --fig-fill-Top: var(--fig-base);
  --fig-glow-Top: 0;
  --fig-tp-Top: var(--fig-t-polygon-out);
  --fig-tg-Top: var(--fig-t-glow-out);
  --fig-o-MidTopLeft: 0.3; --fig-o-MidTopRight: 0.3;
  --fig-o-MidBotLeft: 0.3; --fig-o-MidBotRight: 0.3;
  --fig-o-BotLeft: 0.5; --fig-o-BotRight: 1; --fig-o-Bottom: 0.5;
  --fig-fill-BotRight: var(--fig-hl);
  --fig-glow-BotRight: 1;
  --fig-tp-BotRight: var(--fig-t-polygon-in);
  --fig-tg-BotRight: var(--fig-t-glow-in);
}

/* 06 — Bot-Left */
.prod-features_grid:not(.fig-js):has(.is-botleft:is(:hover, :focus-visible)) #prod-features_fig,
.prod-features_grid.state-botleft #prod-features_fig {
  --fig-o-Top: 0.15;
  --fig-fill-Top: var(--fig-base);
  --fig-glow-Top: 0;
  --fig-tp-Top: var(--fig-t-polygon-out);
  --fig-tg-Top: var(--fig-t-glow-out);
  --fig-o-MidTopLeft: 0.3; --fig-o-MidTopRight: 0.3;
  --fig-o-MidBotLeft: 0.3; --fig-o-MidBotRight: 0.3;
  --fig-o-BotLeft: 1; --fig-o-BotRight: 0.5; --fig-o-Bottom: 0.5;
  --fig-fill-BotLeft: var(--fig-hl);
  --fig-glow-BotLeft: 1;
  --fig-tp-BotLeft: var(--fig-t-polygon-in);
  --fig-tg-BotLeft: var(--fig-t-glow-in);
}

/* Collapse the DIALS and every composed token follows; nothing here restates a
   triple. --fig-curve is left alone — at 1ms no curve is perceptible. */
@media (prefers-reduced-motion: reduce) {
  :root {
    --fig-d-polygon-in:         1ms;
    --fig-d-polygon-out:        1ms;
    --fig-d-glow-in:            1ms;
    --fig-d-glow-out:           1ms;
    --fig-d-outline:            1ms;
    --fig-intro-grid:           1ms;
    --fig-intro-pause:          1ms;
    --fig-intro-facets:         1ms;
    --fig-intro-stagger:        0ms;
    --fig-intro-boot:           1ms;
  }
}
