/* GENERATED by tools/build-css.py. Do not edit: edit the files in
   css/ and run the script. This bundle is, in order:
     css/layout.css
     css/hero.css
     css/work.css
     css/spine.css
     css/about.css
     css/pookalam.css
     css/masthead.css
     css/footer.css
     css/cursor.css
     css/kuri.css
*/

/* ===== css/layout.css ===== */
/* ==========================================================================
   LAYOUT — containers and the fixed-ratio image system
   ========================================================================== */

/* --- Containers ----------------------------------------------------------
   Width is chosen by role, not by nesting depth. A container never sets
   vertical rhythm; sections do that. */

.container,
.container--wide,
.container--text {
  width: 100%;
  margin-inline: auto;
  padding-inline: var(--gutter);
}

.container       { max-width: var(--w-content); }
.container--wide { max-width: var(--w-wide); }
.container--text { max-width: calc(var(--w-text) + var(--gutter) * 2); }

/* Full-bleed escape for image runs that should touch the viewport edge. */
.bleed {
  width: 100vw;
  margin-inline: calc(50% - 50vw);
  padding-inline: 0;
}

.section {
  position: relative;
  z-index: var(--z-content);
  padding-block: var(--sp-section);
}

.section--deep { background: var(--paper-deep); }


/* --- The frame -----------------------------------------------------------
   CLAUDE.md §6. Every image sits in a fixed-ratio box and is centered
   inside it — never stretched, never cropped to fit. The frame absorbs odd
   source shapes so a viewer never notices the assets came from different
   projects, years and export settings.

   Three buckets only. Ratios live in tokens.css and were measured off the
   real files; see the note there. */

/* FLEX, NOT GRID — and this matters.
   With `display: grid; place-items: center`, a child's `height: 100%` has to
   resolve against a grid area whose block size comes from the frame's own
   `aspect-ratio`. That is a cyclic dependency, so the percentage falls back
   to `auto`, the image sizes to its natural ratio, and a portrait source
   overflows and gets cropped by `overflow: hidden` — the exact thing §6
   forbids. The Global Retail cover (0.757) painted 279x368 inside a 319x213
   frame before this was changed.

   In a flex container the height from aspect-ratio is definite to the item,
   so max-height resolves. Sizing with max-width/max-height and auto
   dimensions also means the element itself is letterboxed rather than
   object-fit painting inside a stretched box — the mat is real layout, so
   the frame background shows through exactly where it should. */

.frame {
  position: relative;
  display: flex;
  align-items: center;
  justify-content: center;
  overflow: hidden;
  aspect-ratio: var(--frame-ratio, var(--ratio-wide));
  /* Named once, so an image laid out inside the padding (below) uses the
     same inset the padding does. */
  --frame-pad-used: var(--frame-pad, clamp(var(--sp-s), 2.5vw, var(--sp-m)));
  padding: var(--frame-pad-used);
  background: var(--frame-bg, transparent);
}

.frame > img,
.frame > video,
.frame > picture > img,
.frame > .zoom-btn > img,
.frame > .zoom-btn > picture > img {
  width: auto;
  height: auto;
  max-width: 100%;
  max-height: 100%;
  object-fit: contain;   /* contain, never cover — cropping is not ours to do */
  object-position: center;
}

/* THE ZOOM BUTTON (js/zoom.js) wraps an image a reader can open, and takes
   the image's place in its frame: every rule below that sizes a framed image
   sizes the button the same way, and the image fills it, so nothing moves.
   Checked against the rectangles of every zoomable image on every project
   page at 390, 768, 1024, 1440 and 1920, before and after. */
.zoom-btn {
  display: block;
  max-width: 100%;
  margin: 0;
  padding: 0;
  border: 0;
  border-radius: 0;
  background: none;
  line-height: 0;
}
.zoom-btn > img,
.zoom-btn > picture > img { display: block; }

.frame--wide   { --frame-ratio: var(--ratio-wide); }
.frame--square { --frame-ratio: var(--ratio-square); }
.frame--tall   { --frame-ratio: var(--ratio-tall); }

/* NO IMAGE IS CROPPED, IN ANY ENGINE.
   The note above holds in Chrome and Firefox, not in Safari: WebKit does not
   resolve the image's max-height: 100% against a height that comes from
   aspect-ratio, so a source taller than its frame overflowed and
   overflow: hidden cut it, at every width (Global Retail's booth renders and
   two packaging shots, Mailchimp's email builder, Spotify's home pair), which
   §6 forbids. So the image is laid out over the frame's padded box,
   absolutely, and contained inside it by object-fit, which every engine
   honours. In Chrome and Firefox it paints exactly where it did, since
   contain inside the padded box is what max-width/max-height produced; the
   mat still shows wherever the image doesn't reach.

   Frames whose height comes from their image keep it in flow: solo frames
   the FISHNESS screen rows, and .row--fit rows. The selector is zoom.js's
   own target list (images in a figure, a contained block, or the EIKIRA
   proof grid), so it reaches the images a reader can open and nothing in the
   shell. */
:is(.pj-figure, .pj-contained, .surfaces__proof)
  .frame:not(.frame--solo, .row--screens > .frame, .fish-v1 .row > .frame, .row--fit > .frame) > :is(img, .zoom-btn:has(> img)) {
  position: absolute;
  top: var(--frame-pad-used);
  left: var(--frame-pad-used);
  width: calc(100% - 2 * var(--frame-pad-used));
  height: calc(100% - 2 * var(--frame-pad-used));
  max-width: none;
  max-height: none;
}
:is(.pj-figure, .pj-contained, .surfaces__proof)
  .frame:not(.frame--solo, .row--screens > .frame, .fish-v1 .row > .frame, .row--fit > .frame) > .zoom-btn > img {
  width: 100%;
  height: 100%;
  max-width: none;
  max-height: none;
}

/* ON A PHONE OR TABLET, EVERY IMAGE FILLS ITS COLUMN.
   Up to 64rem two more rules took width from images, and on a phone they
   read as the image sitting short of its column with gaps either side:

   - The mat. Its padding is clamp(--sp-s, 2.5vw, --sp-m): 20px a side at
     390, 11% of the column, in --surface, a tone so close to --paper that it
     reads as empty page rather than as a mat. At 768 and 1024 the paired and
     four-up rows give each image a 170-460px column, a phone's width, and
     the mat took 13-37% of it. On desktop the same 32px frames a 600-1300px
     image and reads as matting, so it stays there. Here image frames inside
     a project figure drop the padding; the mat colour stays, so a shot whose
     ratio differs from its bucket still letterboxes on --surface.
   - The tall cap. .frame--tall was capped at 68svh so a 9:16 screen fitted
     the viewport whole; on a 664px-tall phone that left the image 214px of a
     350px column. Click-to-zoom shows any tall screen whole, so a tall frame
     on its own takes its image's height and runs the column's full width
     (its image back in flow, which the rule above would otherwise take out).

   Desktop, above 64rem, keeps the mat and the tall frame's ratio. */
@media (max-width: 64rem) {
  :is(.pj-figure, .pj-contained, .surfaces__proof) .frame:has(> img, > .zoom-btn > img) {
    --frame-pad: 0px;
  }

  :is(.pj-figure, .pj-contained, .surfaces__proof) .frame--tall:not(.row > .frame) {
    aspect-ratio: auto;
  }

  /* As specific as the rule above (0,5,1) and later, so it wins. */
  :is(.pj-figure, .pj-contained, .surfaces__proof) .frame.frame--tall:not(.row > .frame, .row--screens > .frame) > :is(img, .zoom-btn:has(> img)),
  :is(.pj-figure, .pj-contained, .surfaces__proof) .frame.frame--tall:not(.row > .frame, .row--screens > .frame) > .zoom-btn > img {
    position: static;
    width: 100%;
    height: auto;
    max-height: none;
  }
}

/* Backing surface for flat and product shots — packaging, POS panels, any
   asset with its own baked-in background. One tone site-wide (§6), applied
   by adding this class, never by inventing a per-image colour. */
.frame--matted { --frame-bg: var(--surface); }

/* Photographs and in-situ shots sit directly on the paper: no mat, no pad,
   so the image itself carries the edge. */
.frame--bare {
  --frame-bg: transparent;
  --frame-pad: 0px;
}

/* A sheet on the paper: bare, plus a hairline edge. For flat artwork printed on
   the page's own paper (the Job Hunting readout deck's slides are #F4EEE2, the
   same as --paper), which on a bare frame dissolves into the page and on the
   --surface mat loses its edge almost as badly. The line is drawn inside the
   image's box (offset -1px), so the frame keeps its exact size and ratio. */
.frame--sheet {
  --frame-bg: transparent;
  --frame-pad: 0px;
}

.frame--sheet img {
  outline: 1px solid color-mix(in srgb, var(--ink) 16%, transparent);
  outline-offset: -1px;
}

/* Solo hero — exempt from the bucket system.
   Named --solo rather than --native to avoid colliding with .row--native
   below, which means something different (native pixel size, for the
   packaging renders). This one means "size to your own ratio".

   For images with no neighbour to match, a bucket only costs letterbox and
   buys nothing: the booths show-floor hero (0.76) would lose ~26% vertically
   in the tall frame, and the POS production hero (2.41) ~61% in the wide
   one. Both are named in CLAUDE.md §10 as among the strongest images on the
   site, so they size to themselves and are capped by viewport height rather
   than by a ratio. */
.frame--solo {
  aspect-ratio: auto;
  padding: 0;
}

.frame--solo > img,
.frame--solo > .zoom-btn > img {
  width: auto;
  height: auto;
  max-width: 100%;
  max-height: var(--solo-max-h, 88vh);
}

/* Contained dark frame (§7, §10). Two jobs: hard-quarantining Studio
   Eikira's gold so it cannot read as this site's palette, and giving the
   edge-to-edge black Flexx assets a ground — dropped straight onto cream
   they read as holes punched in the page. */
.frame--dark,
.contained-dark {
  --frame-bg: var(--ink);
  color: var(--paper);
  background: var(--ink);
}


/* --- Rows and stacks -----------------------------------------------------
   Side-by-side images must share a ratio (§6). .row sets the ratio once on
   the container and every frame inside inherits it, so a mismatched pair is
   awkward to build by accident rather than easy to ship. */

.row {
  display: grid;
  grid-template-columns: repeat(var(--row-count, 2), 1fr);
  gap: var(--row-gap, clamp(var(--sp-s), 2vw, var(--sp-m)));
  align-items: start;
}

/* This deliberately overrides .frame--wide/--square/--tall on children: a
   bucket class inside a .row is ignored, and the row's ratio wins. That is
   the rule from §6 made structural — "never mix wide and tall in the same
   row" cannot be violated by accident. To change a row's ratio, change the
   row (.row--tall), not the frames inside it. */
.row > .frame { --frame-ratio: var(--row-ratio, var(--ratio-wide)); }

.row--wide   { --row-ratio: var(--ratio-wide); }
.row--square { --row-ratio: var(--ratio-square); }
.row--tall   { --row-ratio: var(--ratio-tall); }

.row--3 { --row-count: 3; }
.row--4 { --row-count: 4; }

/* PHONE SCREENS AT ONE SCALE.
   The ratio sits just under the narrowest screen in the row, so every screen
   is bound by WIDTH rather than height. Equal widths mean the phone viewport
   inside each capture renders at the same scale — which is what a before and
   after have to do to be compared. Bound by height instead, a 0.489 capture
   beside a 0.462 one draws its UI about 6% larger.
   Tops aligned rather than centred, so a shorter capture ends early instead
   of floating in its mat, the way two phones laid side by side would.
   Capped in width: two phone screens stretched across the full figure are
   each over a thousand pixels tall. */
.row--screens {
  --row-ratio: 0.46;
  max-width: 44rem;
  margin-inline: auto;
}

.row--screens.row--3 { max-width: 62rem; }

.row--screens > .frame { align-items: flex-start; }

/* ONE HEIGHT FOR DIFFERENT SHAPES (Jabra & BlueParrott, November 2026).
   A row of images that don't share a ratio (a 9:16, a 4:5 and a 1:1 ad) and
   must share a height. Each frame names its image's ratio, width over height,
   as --r on the frame. Flex gives each frame its two mats as a basis and
   shares out the rest of the row by --r, so every image is r * k wide for one
   k: all the same height, uncropped, no letterbox, with an even mat round
   each. Bottom-aligned, so subpixel rounding can't stagger the bases.
   Phones stack them, as every .row does, except a .row--tall, which stays
   side by side there as the tall rows do. */
.row--fit {
  display: flex;
  align-items: flex-end;
  gap: var(--row-gap, clamp(var(--sp-s), 2vw, var(--sp-m)));
}
.row--fit > .frame {
  /* x100: flex shares out only part of the spare room when the grow factors
     add up to less than 1, as two 0.419 roll-ups do. Only the proportions
     matter, so scaling them all keeps every row exact. */
  flex: calc(var(--r, 1) * 100) 1 calc(2 * var(--frame-pad-used));
  min-width: 0;
  aspect-ratio: auto;
  display: block;
}
.row--fit > .frame > :is(img, .zoom-btn),
.row--fit > .frame > .zoom-btn > img {
  display: block;
  width: 100%;
  height: auto;
  max-width: none;
  max-height: none;
}
@media (max-width: 46rem) {
  .row--fit:not(.row--tall) { flex-direction: column; align-items: stretch; }
  .row--fit:not(.row--tall) > .frame { flex: none; }

  /* NO STACKED IMAGE TALLER THAN THREE-QUARTERS OF THE SCREEN (November 2026).
     Stacked one per row, a tall image takes the column's full width and can
     run past the screen (a 9:16 ad is 623px tall at 390). Each image is
     capped at 75svh, the screen a reader sees with the browser's bars showing,
     at its own ratio: never cropped, never stretched, centred in its frame,
     which shows --surface either side. An image that already fits, every
     landscape or square one, sizes exactly as before. */
  .row--fit:not(.row--tall) > .frame > :is(img, .zoom-btn) {
    width: fit-content;
    max-width: 100%;
    margin-inline: auto;
  }
  .row--fit:not(.row--tall) > .frame > img,
  .row--fit:not(.row--tall) > .frame > .zoom-btn > img {
    width: auto;
    height: auto;
    max-width: 100%;
    max-height: 75svh;
  }
}

/* Rows collapse to a single column on narrow viewports. A four-up phone row
   at 375px is four unreadable slivers. */
@media (max-width: 46rem) {
  .row { grid-template-columns: 1fr; }
  .row--tall { grid-template-columns: repeat(2, 1fr); }

  /* A three-up tall row goes two-up here, which strands the third on a row
     of its own at the left. Centre it at its siblings' width, so the set
     keeps one scale and the page keeps its one axis. */
  .row--tall.row--3 > .frame:nth-child(3):last-child {
    grid-column: 1 / -1;
    justify-self: center;
    width: calc((100% - var(--row-gap, clamp(var(--sp-s), 2vw, var(--sp-m)))) / 2);
  }
}

/* For before/after pairs whose sources do not share a ratio. Stacking is
   the documented fallback (§16) — it is a correct outcome, not a failure. */
.stack {
  display: grid;
  gap: var(--sp-s);
}

/* Native-size run. The packaging renders are ~460px and cannot be
   re-exported; they run at roughly native size rather than upscaled (§10).
   This is the one place the near-full-width rule is deliberately broken. */
.row--native {
  --row-count: 3;
  max-width: 60rem;
  margin-inline: auto;
}

.row--native > .frame > img,
.row--native > .frame > .zoom-btn > img {
  width: auto;
  height: auto;
  max-width: 100%;
  image-rendering: auto;
}


/* --- Figures and captions ------------------------------------------------ */

figure { margin: 0; }

figure > figcaption {
  margin-top: var(--sp-xs);
  font-size: var(--type-small);
  line-height: var(--lh-snug);
  color: var(--ink-muted);
  max-width: var(--measure-narrow);
}

/* Caption belonging to a whole row rather than one image. */
.row-caption {
  margin-top: var(--sp-xs);
  font-size: var(--type-small);
  color: var(--ink-muted);
}


/* --- Copy blocks ---------------------------------------------------------
   Copy follows the hero image directly (§15) — it is not stranded in a
   narrow centered block at the bottom of a section. */

.copy > * + * { margin-top: var(--sp-s); }

.copy h3 + p { margin-top: var(--sp-xs); }

/* ===== css/hero.css ===== */
/* ==========================================================================
   HERO — the homepage load sequence
   CLAUDE.md §3 (the conch) and §4 (the load sequence).

   ARCHITECTURE NOTE, read before editing:
   The resolved state is the DEFAULT. Nothing here is hidden until an
   .hero-animate class is put on <html>, and removing that class at any
   moment snaps straight to the finished hero. That inversion is what makes
   the three hard requirements in §4 cheap instead of fragile:

     - never block content   — if JS never runs, the hero is simply there
     - play once per session — the class is only added on a fresh session
     - dismiss on scroll     — remove the class, done, no teardown

   The alternative (hide by default, reveal with JS) puts the content behind
   a script, which is the failure mode §4 explicitly forbids.
   ========================================================================== */

/* --- Timeline ------------------------------------------------------------
   Every beat derives from --t-base, so the whole sequence retimes from one
   number. §4 asks for a single continuous moment: the name starts while the
   curve is still drawing, not after it. */

/* THE TWO CONCHES NOW DRAW AT THE SAME SPEED. The footer's mark sweeps the
   same 1000-unit path in --t-slow; the hero's took --t-draw, which is 2.8x
   --t-base against the footer's 1.3x — the same gesture at less than half the
   rate. Same path, same duration, same speed.

   THE BEATS ARE SCALED, NOT LEFT WHERE THEY WERE. The name used to land at
   43.6% of the draw and the tagline at 64.3%; against a 1.27s draw those old
   absolute delays would have put the name 78ms before the curve finished and
   the tagline well after it, which breaks §4's one continuous moment. The
   ratios are preserved instead: 0.57 and 0.84 of --t-base land at 43.8% and
   64.6% of the new draw. The opening is faster; it is not re-choreographed. */
.hero {
  --draw:         var(--t-slow);                    /* ~1.27s, as the footer */
  --name-in:      calc(var(--t-base) * 0.57);       /* ~0.56s, 44% of draw   */
  /* The Malayalam mark used to hold a beat here. It now lives in About, so
     the tagline inherits it rather than arriving after a silent one. */
  --tag-in:       calc(var(--t-base) * 0.84);       /* ~0.82s, 65% of draw   */
  --reveal-dur:   var(--t-slow);
}


/* --- Shell ---------------------------------------------------------------- */

.hero {
  position: relative;
  z-index: var(--z-content);
  min-height: 100svh;
  display: grid;
  justify-items: center;
  align-content: center;
  gap: clamp(var(--sp-s), 3vh, var(--sp-l));
  text-align: center;

  /* The masthead is fixed, so it takes no space in flow — but align-content:
     center measures against the full 100svh, and any overflow spills equally
     top and bottom. With the name at its old size the stack was 164px taller
     than the viewport, and the half that went upward put the conch behind the
     bar. Reserving the bar's height here means centring happens in the space
     that is actually visible. */
  padding-block: calc(var(--masthead-h) + var(--sp-m)) var(--sp-xl);
  padding-inline: var(--gutter);
}


/* --- The conch -----------------------------------------------------------
   A centred stack: the conch sits above the name at a medium size, and the
   name, Malayalam mark and tagline centre beneath it.

   THIS PERMANENTLY RETIRES THE COLLISION PROBLEM. Every previous approach —
   hand-tuned crops, a clipped corridor, a measured-DOM solver — existed to
   keep an overlapping stroke off overlapping type. Stacked, they occupy
   different rows and cannot overlap at any viewport, so there is nothing left
   to solve. js/hero-conch.js is deleted; do not reintroduce a solver here.

   The conch is no longer cropped or bled. It is a whole object at a
   deliberate size, which is also what lets the draw read start to finish. */

.hero { --conch-opacity: 1; }

/* The box now matches the cropped viewBox, so the width below is the width
   the conch actually draws at — it used to be the width of a square that the
   mark sat inside at 63%. Sized off the smaller of the two axes: vh because
   this is a stack and height is what runs out, vw so it does not swell on a
   wide short window. */
.hero__conch {
  display: block;
  width: clamp(92px, min(15vh, 13vw), 156px);
  aspect-ratio: 666 / 908;
  pointer-events: none;
}

.hero__conch svg {
  display: block;
  width: 100%;
  height: 100%;
  max-width: none;
  overflow: visible;
  opacity: var(--conch-opacity);
}

/* THE TAPER IS THE ARTWORK, NOT A RECONSTRUCTION.
   conch-outline.svg is the visible element — a filled path with the real
   taper already drawn into it. conch-stroke.svg is never seen; it is the
   mask, a uniform wide stroke swept along the same spine by
   stroke-dashoffset. As the mask advances it uncovers the tapered shape
   underneath, so every width transition is the illustrator's curve rather
   than something CSS approximates.

   (The earlier approach stacked strokes at decreasing widths. Every width
   change was a hard ledge — stacking cannot produce a continuous taper.)

   Both files share the 1000x1000 viewBox and both begin at M537.262,337.691,
   so they are co-registered and need no transform to align.

   MASK WIDTH — measured, not guessed. Sampling the outline's fill along 400
   normals to the stroke spine gives a spindle profile, thin at both ends and
   thickest in the middle:

     fraction  0.0  0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9  1.0
     width       0    8   14   18   20   21   20   18   14    8    0

   Peak full width is 21 user units (half-width 10.5). The mask is set to 32
   — comfortably over the peak so nothing clips at the waist, with margin for
   the slight registration drift between two independently drawn Beziers.
   Wider would be safe too but sloppier: the round cap leads the reveal by
   half the stroke width, so an over-wide mask pushes a visible bulge ahead
   of the drawing point. At 32 that lead is 16 units on a 3353-unit path,
   under half a percent. */

.hero__conch-art {
  fill: var(--kumkumam);
}

.hero__conch-mask {
  fill: none;
  stroke: #fff;                 /* mask luminance: white reveals */
  stroke-width: 32;
  stroke-linecap: round;
  stroke-linejoin: round;
  stroke-dasharray: 1000 1000;  /* pathLength normalised to 1000 */
  stroke-dashoffset: 0;         /* resolved state: fully revealed */
}


/* --- Type ----------------------------------------------------------------- */

.hero__type {
  position: relative;
  z-index: 1;
  width: 100%;
  max-width: min(var(--w-wide), 46rem);
  margin-inline: auto;
}

.hero__name {
  font-family: var(--font-display);
  font-size: var(--type-mega);
  line-height: var(--lh-tight);
  letter-spacing: var(--ls-mega);
  font-weight: 400;
  margin: 0;
}

/* Each line gets its own clipping window so the words rise from behind a
   hard edge — §4's "mask from below a line". */
.hero__line {
  display: block;
  overflow: hidden;
  padding-block: 0.06em;   /* room for descenders inside the mask */
}

.hero__line > span { display: block; }

.hero__tagline {
  /* auto side margins, not just text-align: the block is narrower than its
     parent, so centring the text inside a left-hugging box still leaves the
     box off-centre. */
  margin: var(--sp-m) auto 0;
  max-width: 44ch;
  font-size: var(--type-lead);
  line-height: var(--lh-snug);
  color: var(--ink-muted);
  text-wrap: balance;
}


/* ==========================================================================
   THE SEQUENCE
   Applies only while <html> carries .hero-animate. Everything above is the
   resolved state.
   ========================================================================== */

/* The conch draws from bare paper — one mask, one sweep.
   Linear, not --ease. --ease is cubic-bezier(0.16, 1, 0.30, 1), which puts
   roughly 80% of the curve down in the first 30% of the time and then
   crawls; a drawn line wants a steady hand, not an arrival. */
.hero-animate .hero__conch-mask {
  stroke-dashoffset: 1000;
  animation: conch-draw var(--draw) linear forwards;
  /* Held while the first-load intro's doors are shut (CLAUDE.md §15e), so the
     conch starts drawing as they open: --intro-hold is set only by that
     intro, and to the moment they open if a tap opens them early. */
  animation-delay: var(--intro-hold, 0s);
}

@keyframes conch-draw {
  to { stroke-dashoffset: 0; }
}

/* Name — starts at ~1.2s, while the curve is still drawing. */
.hero-animate .hero__line > span {
  transform: translateY(110%);
  animation: rise var(--reveal-dur) var(--ease) forwards;
  animation-delay: calc(var(--intro-hold, 0s) + var(--name-in));
}

/* The second-line delay that lived here is GONE with the second line. It
   staggered "Nair" behind "Prateek" by --t-base * 0.065; the name is one line
   now, so the rule matched nothing and a stagger has nothing to stagger. */

@keyframes rise {
  to { transform: translateY(0); }
}

/* Malayalam mark, then tagline. Both fade up rather than mask — the name is
   the only element that gets the hard edge, so it stays the loudest moment. */
.hero-animate .hero__tagline {
  opacity: 0;
  animation: fade-up var(--t-base) var(--ease) forwards;
}

.hero-animate .hero__tagline { animation-delay: calc(var(--intro-hold, 0s) + var(--tag-in)); }

@keyframes fade-up {
  from { opacity: 0; transform: translateY(0.6em); }
  to   { opacity: 1; transform: translateY(0); }
}


/* --- Reduced motion -------------------------------------------------------
   Belt and braces. hero.js already refuses to add .hero-animate when the
   preference is set, but if the class arrives by any other route the
   sequence is neutralised here rather than merely sped up. The resolved
   state is what remains, which is the bypass §4 asks for. */

@media (prefers-reduced-motion: reduce) {
  .hero-animate .hero__conch-mask,
  .hero-animate .hero__line > span,
  .hero-animate .hero__tagline {
    animation: none;
    opacity: 1;
    transform: none;
    stroke-dashoffset: 0;
  }
}


/* --- The name pattern ------------------------------------------------------
   The hero's ground: പ്രതീക്, the name in Malayalam, tiled in brickwork rows
   in Manjari Thin, ink at 7% on the paper. A second use of Manjari, by
   Prateek's decision (CLAUDE.md §2). js/hero-pattern.js draws one tile of
   each layer to a canvas once the faces have loaded and sets it here as a
   background; nothing in it is text, so there is nothing to select or read.

   THE CALM ZONE. Behind the conch, the name and the tagline the pattern
   quietens rather than stopping, so the hero reads as one surface: an
   ellipse round their joint box, measured once per layout and written as
   --cz-* on .hero__pattern. Inside it the base pattern is at 3% (0.43 of its
   7%) and the lamp at 12% of its strength, blending to full at the ellipse's
   edge.

   12%, not the 40% first asked for, because of the tagline. Its worst case
   is a pixel wholly inside a lit Bold stroke, with the lamp at its peak and
   the 3% pattern under it: at 40% that measured 2.97:1, below AA's 4.5. The
   most the zone can take with the tagline at 4.5 is 13%; at 12% it is 4.6:1
   and the name 11.5:1. Without the lamp, ink is 13.7:1 and the tagline 5.5:1
   on the 3% pattern.

   THE LAMP. A soft circle (--lamp-d, 260px at 1440) that lights the pattern
   in kumkumam Bold around the pointer: Bold over Thin, so at the circle's
   soft edge the Thin shows through and the letters swell from Thin to Bold
   toward its centre. It moves by transform only: .hp__lamp is the circle,
   translated to the pointer, and .hp__lit inside it, the hero-sized Bold
   layer, is translated back by the same amount, so the pattern stays put and
   the light moves over it. Nothing repaints as it moves; every mask is static
   in its own element.

   Reduced motion: the faint pattern only, no lamp. */

/* BLOCK, AND PRELOADED (index.html): the pattern must never show in a
   fallback face. It is drawn only once both cuts have loaded, and not at all
   if either fails (js/hero-pattern.js). */
@font-face {
  font-family: 'Manjari Name';
  font-weight: 100;
  font-display: block;
  src: url('/assets/fonts/manjari-name-100.woff2') format('woff2');
}
@font-face {
  font-family: 'Manjari Name';
  font-weight: 700;
  font-display: block;
  src: url('/assets/fonts/manjari-name-700.woff2') format('woff2');
}

.hero__pattern {
  position: absolute;
  inset: 0;
  z-index: -1;
  overflow: hidden;
  pointer-events: none;
  user-select: none;
  -webkit-user-select: none;
  opacity: 0;
  transition: opacity var(--t-slow) var(--ease);
  --hp-size: clamp(30px, 3.33vw, 56px);
  --lamp-d: clamp(200px, 18vw, 320px);
  --cz-at: ellipse var(--cz-rx, 0px) var(--cz-ry, 0px) at var(--cz-x, 50%) var(--cz-y, 50%);
  --cz-mask-base: radial-gradient(var(--cz-at), rgba(0,0,0,.43) 0, rgba(0,0,0,.43) 75%, #000 100%);
  --cz-mask-lit:  radial-gradient(var(--cz-at), rgba(0,0,0,.12) 0, rgba(0,0,0,.12) 75%, #000 100%);
}
.hero__pattern.is-ready { opacity: 1; }

.hp__base,
.hp__lit {
  position: absolute;
  top: 0;
  left: 0;
  width: var(--hw, 100%);
  height: var(--hh, 100%);
  background-repeat: repeat;
}
.hp__base {
  opacity: 0.07;
  -webkit-mask-image: var(--cz-mask-base);
          mask-image: var(--cz-mask-base);
}
.hp__lit {
  -webkit-mask-image: var(--cz-mask-lit);
          mask-image: var(--cz-mask-lit);
}

.hp__lamp {
  position: absolute;
  top: 0;
  left: 0;
  width: var(--lamp-d);
  height: var(--lamp-d);
  overflow: hidden;
  -webkit-mask-image: radial-gradient(circle closest-side, rgba(0,0,0,.92) 0, rgba(0,0,0,.92) 28%, transparent 100%);
          mask-image: radial-gradient(circle closest-side, rgba(0,0,0,.92) 0, rgba(0,0,0,.92) 28%, transparent 100%);
  opacity: 0;
  transition: opacity var(--t-quick) var(--ease);
  will-change: transform, opacity;
}
.hp__lit { will-change: transform; }

.hero__pattern.lamp-on   .hp__lamp { opacity: 1; }
.hero__pattern.lamp-rest .hp__lamp { opacity: 0.55; transition-duration: var(--t-slow); }

@media (prefers-reduced-motion: reduce) {
  .hero__pattern { transition: none; }
  .hp__lamp { display: none; }
}

/* ===== css/work.css ===== */
/* ==========================================================================
   WORK — the project grid
   CLAUDE.md §9. Six projects, two columns, staggered.
   ========================================================================== */

/* ONE SOURCE OF TRUTH FOR THE LINE AND ITS CLEARANCE.
   --rail-x is where the rail sits on narrow viewports; js/spine.js reads this
   same value rather than computing its own, so CSS and the drawn line cannot
   disagree. --rail-gutter is the clearance every element keeps from the line,
   used by the label and by every part of every stack so they stay aligned to
   one edge. Tune either here and everything follows. */
.work {
  position: relative;
  z-index: var(--z-content);
  padding-block: var(--sp-section);
  --rail-x: clamp(0.9rem, 4.5vw, 1.75rem);

  /* ONE CLEARANCE, BOTH LAYOUTS. The stop dot is the same size at every
     width (radius 14.7px, from the stroke), and the hover field outsets
     --wash-pad past the content toward the line, so the free space between
     them is (clearance - pad) in the centred layout and exactly the same
     subtraction against the rail on narrow. Deriving both from one value is
     what stops them drifting apart: the desktop corridor was fixed first and
     the narrow rail still overlapped the dot by 7.4px at 375, because the
     two were separate numbers that happened to be checked at different
     widths. */
  --wash-pad: clamp(0.85rem, 1.6vw, 1.6rem);
  --field-clear: calc(var(--wash-pad) + clamp(1.75rem, 2.4vw, 2.25rem));

  --rail-gutter: var(--field-clear);

  /* The stop dot's radius, in px, matching what js/spine.js draws: the dot is
     2.1x the stroke width and the stroke is --spine-w, so this is the one
     place the two representations of the same mark have to agree. */
  --dot-r: calc(var(--spine-w) * 2.1);
}

/* Centred on the LINE's starting position, not on the page. Its own container
   is centred and padded, so "centre the box" is not the same as "centre on
   the line" — js/spine.js measures the difference and publishes it as
   --head-shift once it has solved the route. */
.work__head {
  margin-bottom: var(--sp-2xl);
  text-align: center;
  transform: translateX(var(--head-shift, 0px));
}

/* base.css caps every <p> at --measure (62ch). Left as a block with that cap
   and no auto margins, the eyebrow sat left-aligned inside a centred head and
   landed 153px off the line. */
.work__head .eyebrow {
  max-width: none;
  font-size: clamp(1.05rem, 2.1vw, 2rem);
  letter-spacing: 0.26em;
}


/* --- The sequence --------------------------------------------------------
   ONE PROJECT PER ROW, FULL WIDTH, ALTERNATING SIDES.
   §9 asked for a staggered two-column grid specifically to avoid the uniform
   3x2 that reads as a template. An alternating full-width sequence achieves
   that more directly and gives each project a whole row of its own rather
   than a cell in a matrix — image left / text right, then image right / text
   left, down the page.

   It also fixes the arrival clustering for free. Two columns meant two cards
   at nearly the same height, so the line reached them in near-pairs no matter
   how far the stagger was pushed. One project per row makes the spacing
   between arrivals uniform by construction. */

.work__grid {
  display: grid;
  grid-template-columns: 1fr;
  /* Re-tuned after the covers grew. At 20vw the gap was 256px against a
     621px card at 1280 — 41% of the card's own height, which read as drift
     rather than separation, because it was set when cards were half as tall.
     14vw puts it near 30%: each project still gets its own moment without the
     page feeling like it has run out of content. */
  row-gap: clamp(var(--sp-2xl), 14vw, calc(var(--sp-3xl) * 1.4));
  list-style: none;
  margin: 0;
  padding: 0;
}

/* --- Card ----------------------------------------------------------------
   Each project is a vertical stack — coil and title on one line, subtitle
   under it, cover image under that — and the whole stack sits on one side of
   the line, alternating down the page. Not side-by-side: the stack reads as
   one block, so the image belongs under its own title rather than across a
   gutter from it.

   Source order is text then image, matching the visual order, so a screen
   reader hears the project named before its picture.

   The li is the two-column frame; the link is the stack and occupies one
   column of it. That keeps the alternation on the container and leaves the
   stack itself simple. */

/* COVER WIDTH IS DECOUPLED FROM THE TEXT MEASURE.
   Previously the whole stack — type and cover together — sat inside one
   column, so widening the cover meant widening the measure with it and the
   type sprawled. They are now sized independently: the cover fills its
   column and bleeds outward toward the viewport edge, while the text keeps a
   narrow measure centred inside that same column.

   The column gap is the line's clearance, so the covers grow until they are
   a set distance from the centre rather than being sized by a guess. */
.card {
  /* --wash-pad is inherited from .work, which derives --field-clear from it.
     Redeclaring it here would let the field and the clearance disagree. */
  /* How close a cover may come to the line. */
  --line-clear: clamp(1.6rem, 5vw, 5.5rem);
  /* How far it may bleed past the container toward the viewport edge —
     everything except a small outer margin. */
  --cover-bleed: calc(var(--gutter) - clamp(0.6rem, 1.4vw, 1.4rem));
  --text-measure: 34ch;

  display: grid;
  grid-template-columns: 1fr 1fr;
  column-gap: calc(var(--line-clear) * 2);
}

.work__grid > li:nth-child(odd)  .card__link { grid-column: 1; }
.work__grid > li:nth-child(even) .card__link { grid-column: 2; }

/* The cover bleeds outward, away from the line, toward the viewport edge. */
.work__grid > li:nth-child(odd)  .card__media { margin-inline-start: calc(-1 * var(--cover-bleed)); }
.work__grid > li:nth-child(even) .card__media { margin-inline-end:   calc(-1 * var(--cover-bleed)); }

/* The text/cover centring correction that used to live here is retired. It
   existed because both sat in one column and the cover's outward bleed moved
   its centre away from the text's; across the line they are in different
   columns and there is no shared centre left to reconcile. */

.card__link {
  display: grid;
  /* The highlight field is outset by --wash-pad, so the gap has to clear that
     outset before it is a gap at all — otherwise the rectangle's bottom edge
     lands flush on the cover, which is what it did. Derived from the pad
     rather than guessed, so the two cannot drift apart. */
  row-gap: calc(var(--wash-pad) + clamp(0.4rem, 0.9vw, 1.1rem));
  grid-row: 1;
  color: inherit;
  text-decoration: none;
  outline-offset: 4px;
}

/* EVERY COVER THE SAME: the same mat on all four sides and, inside it, a
   3:2 window the image fills, centred (October 2026). The box takes its
   height from that window, not from an aspect-ratio of its own, so the mat
   is even all round. Before, the images were contained in a 3:2 box with an
   even mat, which left a 1.6:1 space: each cover filled a different share of
   it (75-95% of the height), and after the cover was stacked in a grid
   (two copies, one cell) the browser no longer held its height to the box,
   so the 3:2 covers ran into the bottom mat and sat about 10px low.

   Cropping follows §6: the 3:2 covers, every logo among them (Eikira, Metis,
   FISHNESS), fill the window exactly and are not cropped; the three that
   aren't 3:2 (the Motion & Video still at 16:9, the Mailchimp and Spotify
   screens) are cropped to it, centred. */
.card__media { background: var(--surface); }
.card .card__media.frame { aspect-ratio: auto; }
.card .card__media > img {
  display: block;
  width: 100%;
  height: auto;
  max-width: none;
  max-height: none;
  aspect-ratio: var(--ratio-wide);
  object-fit: cover;
  object-position: center;
}


.card__media img { transition: transform var(--t-slow) var(--ease); }

:is(html:not(.no-hover) .card__link:hover, .card__link.is-pressed) .card__media img,
.card__link:focus-visible .card__media img { transform: scale(1.02); }


/* --- Text block ----------------------------------------------------------- */

/* --wash-pad is the inset between the type and the edge of the highlight
   field. It is applied by growing the field OUTWARD rather than padding the
   text inward: padding would push the type off the edge its cover is aligned
   to, which is the alignment the stack depends on. Declared on .card so the
   stack's row gap can be derived from it. */
/* Option C: centred within its block, in a measure of its own. The cover is
   free to be much wider without dragging the type out with it. */
.card__text {
  position: relative;
  isolation: isolate;
  display: grid;
  justify-items: center;
  text-align: center;
  row-gap: var(--sp-3xs);
  width: min(var(--text-measure), 100%);
  margin-inline: auto;
  padding: var(--sp-xs) 0 var(--sp-2xs);
  transition: color var(--t-quick) var(--ease);
}

/* Coil and title share one line, with the index tucked above the title. */
/* One centred column: coil above the index, index above the title, so the
   head reads as a single vertical alignment rather than a mark hung off the
   side of the type. */
.card__head {
  display: grid;
  justify-items: center;
  grid-template-columns: 1fr;
  grid-template-areas: 'coil' 'index' 'title';
  row-gap: var(--sp-2xs);
}

.card__head .card__index { grid-area: index; }
.card__head .card__title { grid-area: title; }

.card__coil {
  grid-area: coil;
  display: block;
  /* Smaller. At 56-92px it competed with the title for the eye; the coil is
     a marker for the stop, not the headline of the project. */
  width: clamp(30px, 3.2vw, 52px);
  aspect-ratio: 3 / 4;
  align-self: center;
}

.card__coil svg { width: 100%; height: 100%; overflow: visible; }

/* VARIANT A — the full conch. The outer-sweep crop is kept behind these two
   values as the documented fallback: set --coil-crop to "0 450 550 1000" and
   --coil-start to 550 to restore it. */
.card__coil {
  --coil-crop: 1000 1000;
  --coil-start: 1000;
}

.coil__art { fill: var(--kumkumam); }

/* THE SPIRAL WAITS FAINTLY (October 2026). Each card's spiral is drawn in
   when the line reaches it; until then its ghost shows at the ghost line's
   strength (0.26), so the space above a card's number never reads as a hole.
   The same art in the same crop, under the drawn one, which covers it as it
   draws. Only while live: at rest the spiral is simply drawn. */
.coil__ghost { fill: var(--kumkumam); opacity: 0; }
.spine-live .coil__ghost { opacity: 0.26; }

.coil__crop,
.coil__mask {
  fill: none;
  stroke: #fff;
  stroke-width: 32;
  stroke-linecap: round;
}

.coil__crop { stroke-dasharray: var(--coil-crop); }

.coil__mask {
  stroke-dasharray: 1000 1000;
  stroke-dashoffset: 0;
}


/* --- Card text and the wash ----------------------------------------------
   §9: "Kumkumam wash bleeds in from the left on hover, text inverting to
   paper." The wash is a pseudo-element scaled from the left edge rather than
   a background-position animation, so it composites on the GPU and does not
   repaint the text under it.

   It is scoped to the text block, not the whole card: washing over the cover
   image would obscure the work, which §1 puts above any interaction. */

.card__text::before {
  content: '';
  position: absolute;
  /* Outset on every side, so nothing in the stack — coil, index, title,
     subtitle or year — ever sits against the boundary of the field. */
  inset: calc(-1 * var(--wash-pad));
  z-index: -1;
  background: var(--kumkumam);
  transform: scaleX(0);
  transform-origin: left center;
  transition: transform var(--t-quick) var(--ease);
}

:is(html:not(.no-hover) .card__link:hover, .card__link.is-pressed) .card__text::before,
.card__link:focus-visible .card__text::before {
  transform: scaleX(1);
}

:is(html:not(.no-hover) .card__link:hover, .card__link.is-pressed) .card__text,
.card__link:focus-visible .card__text {
  color: var(--paper);
}

/* The coil inverts with the type it belongs to. */
:is(html:not(.no-hover) .card__link:hover, .card__link.is-pressed) :is(.coil__art, .coil__ghost),
.card__link:focus-visible :is(.coil__art, .coil__ghost) {
  fill: var(--paper);
}

/* Every text colour inside the body has to invert together, or the subtitle
   stays --ink-muted on kumkumam — 2.6:1, which fails AA. */
:is(html:not(.no-hover) .card__link:hover, .card__link.is-pressed) .card__sub,
.card__link:focus-visible .card__sub,
:is(html:not(.no-hover) .card__link:hover, .card__link.is-pressed) .card__year,
.card__link:focus-visible .card__year,
:is(html:not(.no-hover) .card__link:hover, .card__link.is-pressed) .card__index,
.card__link:focus-visible .card__index {
  color: var(--paper);
}

/* --- The wrapped card: cover reveal and Kerala frame ------------------------
   The card the line wraps (js/spine.js, WRAP). Two things happen to it.

   THE COVER COMES UP IN STEP WITH THE LOOP. It starts muted, desaturated and
   a little dim, and reaches full colour as the loop closes, over the same
   stretch of scroll as the loop, so scrolling back up mutes it again. Hover keeps the full wash, as on every card.

   TWO COPIES, ONE OPACITY. spine.js stacks a muted copy of the cover
   (.card__mute) under the cover itself (.card__lit) in one grid cell, so
   they lay out identically, and only the top copy's opacity moves. The
   filter on the muted copy never changes, so it is painted once. It used to
   be one image with its filter animated, which repaints the whole cover on
   every frame of the scroll and was most of the jank on an iPhone.

   THE FRAME GROWS OUT OF THE LOOP once it has closed. spine.js builds it
   (.wrapframe) and toggles .is-framed on the threshold; each band scales
   outward from the inner line, the corners after it. Taking the class away
   runs it backwards: the bands retract into the line. Timed, not scrubbed,
   and every duration comes from --t-base. There is no outer rule (October
   2026): the band ends where its own motifs do. */
@property --frame-d {
  syntax: '<length>';
  inherits: true;
  initial-value: 18px;
}

.work { --frame-d: clamp(16px, 1.8vw, 26px); }   /* 26 at 1440, 16 on phones */

.card--wrap.has-wrap .card__media {
  display: grid;
  place-items: center;
  /* A column the box's full width (November 2026). Left auto, it sized to
     its content, and an image still loading has none: the column was 0px,
     the 3:2 cover 0×0 and the card only its mat, until each image arrived.
     The work grid grew by ~790px over the first seconds on a cold load, and
     a click on About in that time stopped short. Now the cover's space is
     there from the first paint. */
  grid-template-columns: minmax(0, 1fr);
}
.card--wrap.has-wrap .card__media > img { grid-area: 1 / 1; }
.card--wrap.has-wrap .card__mute { filter: grayscale(1) brightness(0.84); }

/* The cover above its muted copy, explicitly: a copy with a filter can be
   given its own layer, and the order must not be left to the engine. */
.card--wrap.has-wrap .card__mute { z-index: 0; }
.card--wrap.has-wrap .card__lit  { z-index: 1; will-change: opacity; }

/* spine.js writes the opacity per frame (litAt); 0 is where it starts. Once
   the loop has closed the cover is in full colour whatever was written. */
.spine-live .card--wrap.has-wrap .card__lit { opacity: 0; }
.spine-live .card--wrap.has-wrap.is-lit .card__lit { opacity: 1 !important; }

@media (prefers-reduced-motion: reduce) {
  .spine-live .card--wrap.has-wrap .card__lit { opacity: 1; }
}

/* Each frame sits in its own card, placed in the line's own coordinates
   less its box's origin and the card's offset (spine.js), so the loop and
   the band are drawn from one set of numbers. Above the card's content,
   below the draggable tip. A card more than a screen away (.is-far) does
   not show its frame at all, so far frames are neither painted nor
   composited. */
.card--wrap.has-wrap { position: relative; }
.card.is-far .wrapframe { display: none; }

.wrapframe {
  position: absolute;
  left: 0;
  top: 0;                  /* placed and sized to its own box by spine.js */
  z-index: 1;
  /* A layer of its own: it is small, and its loop drawing, its growth and
     its fade then never repaint the card beneath it. */
  will-change: transform;
  overflow: visible;
  pointer-events: none;
  color: var(--kumkumam);
  fill: none;
  stroke: none;
  max-width: none;
  /* Turns to paper with the wash, at the wash's pace, as the axis does. */
  transition: color var(--t-quick) var(--ease);
}

/* THE CARD'S LINE: in from the axis, round the cover and back to the joint,
   in the spine's weight and colour (currentColor, so it turns to paper with
   the frame over the hover wash). Drawn by its own dash, which spine.js
   writes only while this card is the one drawing (cardT); a ghost of the
   whole route under it, as on the spine. */
.wrapframe .wf__line,
.wrapframe .wf__ghost {
  fill: none;
  stroke: currentColor;
  stroke-width: var(--spine-w);
  stroke-linecap: round;
  stroke-linejoin: miter;
}
.wrapframe .wf__line { stroke-dasharray: 1000 1000; stroke-dashoffset: 0; }
.wrapframe .wf__ghost { stroke-opacity: 0; }
.spine-live .wrapframe .wf__line { stroke-dashoffset: 1001; }
.spine-live .wrapframe .wf__ghost { stroke-opacity: 0.26; }

/* The ornaments fade in as they grow, over --t-slow (see the timing note
   below); the line has its own draw and never fades. */
.wrapframe .wf__orn { transition: opacity var(--t-slow) var(--ease); }

.wrapframe .wf__stroke {
  fill: none;
  stroke: currentColor;
  stroke-width: var(--wf-sw, 1.5px);
  stroke-linecap: round;
  stroke-linejoin: round;
}
.wrapframe .wf__fill { fill: currentColor; }
/* The joint's block is knocked out in the ground colour, so the line stops at
   its edge and the lotus reads over the crossing; on hover, in the wash's. */
.wrapframe .wf__knock { fill: var(--paper); transition: fill var(--t-quick) var(--ease); }

/* THE FRAME DRAWS IN SLOWLY AND FOLDS AWAY QUICKLY (October 2026: at
   --t-base it came and went too fast to see). Growing, the whole thing runs
   over --t-draw on --ease, which spends most of its time settling: the top
   and bottom bands (and their medallions) first, the side bands a tenth
   later, the corners a tenth after that, each over 0.8 of it, so the last
   settles as --t-draw ends. The ornaments fade from 0 to full over
   --t-slow as they grow. Folding back on the way up takes --t-quick, with
   the fade in reverse; spine.js holds the line for exactly that long. */

/* Each band grows outward from the inner line: a scale on its own y, inside
   the matrix that places it (written by spine.js as --m). */
.wrapframe .wf__grow {
  transform-box: view-box;
  transform-origin: 0 0;
  transform: var(--m) scale(1, 1);
  transition: transform calc(var(--t-draw) * 0.8) var(--ease)
              calc(var(--t-draw) * 0.1 * var(--i, 0));
}

/* No transitions until spine.js has applied the first state, or a frame
   below the fold would visibly fold itself away on load. */
html.spine-live:not(.spine-ready) .wrapframe .wf__orn,
html.spine-live:not(.spine-ready) .wrapframe .wf__grow { transition: none; }

/* Live and not yet closed: every ornament folded into the line, and faded
   out. The transitions here are the way back. */
.spine-live .wrapframe:not(.is-framed) .wf__orn {
  opacity: 0;
  transition: opacity var(--t-quick) var(--ease);
}
.spine-live .wrapframe:not(.is-framed) .wf__grow {
  transform: var(--m) scale(1, 0);
  transition: transform var(--t-quick) var(--ease);
}
.spine-live .wrapframe:not(.is-framed) .wf__grow--corner {
  transform: var(--m) scale(0, 0);
}
@media (prefers-reduced-motion: reduce) {
  .wrapframe .wf__orn,
  .wrapframe .wf__grow { transition: none; }
  .spine-live .wrapframe:not(.is-framed) .wf__orn { opacity: 1; }
  .spine-live .wrapframe .wf__line { stroke-dashoffset: 0; }
  .spine-live .wrapframe:not(.is-framed) .wf__grow { transform: var(--m); }
}

/* Phones: the band, and the medallion breaking past it, sit between the
   type and the cover, so the cover drops until the medallion's tip — the
   line, the band and a band's depth again above the cover — is 16px clear of
   the type's highlight (the field outset --wash-pad past the text), net of
   the row gap the link already has. The same 16px the desktop highlight
   keeps from its frame. Clear of the text alone, the highlight ended about
   2px above the tip. */
@media (max-width: 46rem) {
  .work__grid > li.card--wrap.has-wrap:nth-child(n) .card__media {
    margin-block-start: calc(var(--frame-d) * 2 + var(--spine-w) + 16px
                             - clamp(0.4rem, 0.9vw, 1.1rem));
  }
}

.card__index {
  display: block;
  font-size: var(--type-micro);
  letter-spacing: var(--ls-wide);
  color: var(--kumkumam);
  transition: color var(--t-quick) var(--ease);
}

/* Sized to fit on ONE line at every viewport — the longest title is
   "Mailchimp Concept". The stack is half the grid wide, so this is much
   smaller than --type-title; text-wrap: nowrap is deliberately NOT used,
   because silently overflowing would be worse than wrapping if a longer
   title is ever added. Verified single-line across the range instead. */
.card__title {
  margin: 0;
  font-family: var(--font-display);
  font-weight: 400;
  font-size: clamp(1.4rem, 2.5vw, 2.5rem);
  line-height: 1.04;
  letter-spacing: var(--ls-display);
}

/* Larger than before: with the title reduced, the subtitle carries more of
   the description in this arrangement. */
.card__sub {
  display: block;
  margin-top: var(--sp-2xs);
  max-width: none;
  font-size: clamp(1.0625rem, 1.75vw, 1.45rem);
  line-height: 1.34;
  color: var(--ink-muted);
  transition: color var(--t-quick) var(--ease);
}

/* RECEDES BY TYPE, NOT BY AN ILLEGAL CONTRAST. This carried the retired
   faint tone, which measured 2.07:1 on 12px text — below both AA bars. It now
   takes the same --ink-muted as the subtitle and stays a clearly lower tier
   through size (half the subtitle), tracking (0.26em against the subtitle's
   normal) and the space above it. */
.card__year {
  display: block;
  margin-top: var(--sp-s);
  font-size: var(--type-micro);
  letter-spacing: 0.26em;
  color: var(--ink-muted);
  transition: color var(--t-quick) var(--ease);
}


/* The card-6 placeholder rules that lived here are gone. They were the other
   consumer of the retired faint tone, and the markup they styled no longer
   exists — card 6 carries the Supra still now. */


/* --- Reduced motion -------------------------------------------------------
   The wash carries the hover state, so it is kept — removing it would leave
   no affordance at all. Only the image scale goes, which is decoration. */

@media (prefers-reduced-motion: reduce) {
  .card__media img { transition: none; }
  :is(html:not(.no-hover) .card__link:hover, .card__link.is-pressed) .card__media img,
  .card__link:focus-visible .card__media img { transform: none; }
}


/* ==========================================================================
   THE CROSS-LINE LAYOUT — DESKTOP ONLY

   The cover sits on one side of the centre line and the text block on the
   other, alternating down the spine: image-left/text-right, then
   image-right/text-left. The line runs between them rather than beside a
   stack that happens to sit on one side of it.

   SCOPED BY A COMPLEMENTARY MEDIA QUERY, NOT BY SPECIFICITY, and that is the
   whole point of writing it this way. On narrow the line is a left rail with
   a single column of content to its right — there is no opposite side to move
   anything to, so this arrangement is not merely unnecessary there, it is
   impossible. Specificity has silently lost this argument repeatedly in this
   build (a:hover, ul[role='list'], h3 colour), so the guard here is
   structural: `not all and (max-width: 46rem)` is the exact complement of the
   narrow block in spine.css. Neither can apply at a width the other covers,
   and there is no gap between them where a third behaviour could appear.
   ========================================================================== */

@media not all and (max-width: 46rem) {

  /* The link spans both columns and becomes the two-column grid itself. Not
     `display: contents` on the anchor — that has historically dropped
     interactive elements out of the accessibility tree, and this element is
     the card's only link. */
  /* :nth-child(n) is load-bearing. The base rules above are
     `.work__grid > li:nth-child(odd) .card__link` at (0,3,1); a plain
     `.work__grid > li .card__link` is (0,2,1) and loses, which left the link
     inside one column and made the covers SMALLER instead of larger.
     Matching the specificity and coming later in the file is what wins. */
  .work__grid > li:nth-child(n) .card__link {
    grid-column: 1 / -1;
    display: grid;
    grid-template-columns: 1fr 1fr;
    column-gap: calc(var(--line-clear) * 2);
    align-items: center;
    row-gap: 0;
  }

  /* Placement is explicit, so source order stays text-then-media: a screen
     reader hears the project named before its picture, whichever side the
     picture is on. */
  .work__grid > li:nth-child(odd)  .card__media { grid-column: 1; grid-row: 1; }
  .work__grid > li:nth-child(odd)  .card__text  { grid-column: 2; grid-row: 1; }
  .work__grid > li:nth-child(even) .card__media { grid-column: 2; grid-row: 1; }
  .work__grid > li:nth-child(even) .card__text  { grid-column: 1; grid-row: 1; }

  /* FREED ROOM, SPENT — and bounded by arithmetic rather than by taste.
     With a line down the centre, each cover can occupy at most
       (viewport / 2) - (edge margin) - (clearance from the line)
     so the ceiling is fixed by the composition, not by the CSS. Three dials
     move it and all three are set to the edge of what stays comfortable:

       - the card outsets past the container to sit ~18px from the viewport
         edge, instead of a full gutter in
       - the line's clearance drops from 5vw to 3vw a side
       - the cover fills its column outright, so no separate bleed is needed

     Anything past this needs the line to stop being centred, which is a
     different composition and not what was asked for. */
  /* `li.card`, not `li .card`. The <li> IS the card — a descendant selector
     matched nothing at all, so every value below silently fell back to the
     base rule and the covers came out narrower than before the change. */
  .work__grid > li.card {
    /* THE EDGE MARGIN HAS TO CLEAR THE HOVER FIELD. The field
       (.card__link::before, and the ::after that redraws the line over it)
       is outset --wash-pad past the card on every side, and --wash-pad,
       clamp(0.85rem, 1.6vw, 1.6rem), is larger than this margin alone,
       clamp(0.75rem, 1.4vw, 1.5rem), at every width. So the field ran
       1.6-2.9px past the viewport edge and the homepage scrolled sideways by
       2-3px from 737px up. With the margin never smaller than the field's
       outset, the field ends exactly at the viewport edge, which is where it
       was visibly cut off before; the cards come in by the same 1.6-2.9px. */
    --card-outset: calc(var(--gutter) - max(clamp(0.75rem, 1.4vw, 1.5rem), var(--wash-pad)));
    /* CLEARANCE IS DERIVED FROM THE FIELD, NOT CHOSEN.
       The hover field outsets --wash-pad past the column toward the line, so
       the free corridor either side of the axis is (clearance - pad), and the
       stop dot's radius is a hard floor under it: at the old 3vw the corridor
       came out at 8px against a 14.7px radius on a 736 viewport, so the
       highlight ran straight into the circle. Expressing clearance as the pad
       plus a real gap makes the corridor a constant of the composition rather
       than something that happens to work at the width it was checked at.
       Cost is 13px of cover width at 1280 — 2%, and the circle is clear at
       every width instead of at none. */
    --line-clear: var(--field-clear);
    --text-measure: 40ch;
    margin-inline: calc(-1 * var(--card-outset));
  }

  /* The cover now fills its own column, so the outward bleed that used to
     widen it inside a shared column is off. Left on, it pushed the artwork
     57px past the viewport edge and cropped it. */
  .work__grid > li:nth-child(odd)  .card__media,
  .work__grid > li:nth-child(even) .card__media { margin-inline: 0; }

  /* Both up. Measured against the base rules rather than eyeballed: the
     title goes 32 -> 43.5 at 1280 and 40 -> 54.4 at 1920. The subtitle's
     first pass was 1.5vw, which came out at 19.2 against the base rule's
     22.4 — smaller, not larger, at exactly the width the change is for. */
  .card__title { font-size: clamp(2rem, 3.4vw, 3.4rem); }
  .card__sub   { font-size: clamp(1.15rem, 1.85vw, 1.75rem); }

  /* --- The highlight encloses both halves ------------------------------
     One region across the line rather than a field behind the type only.
     It is BEHIND the content, so the opaque cover paints over its own part
     and the field reads as a surround rather than as a tint over the work —
     §1 keeps anything that obscures an image off the table. */

  .card__link {
    position: relative;
    isolation: isolate;
  }

  /* THE FIELD WIPES IN FROM THE COVER'S SIDE.
     Direction is derived from where the cover sits, not from the index: the
     odd/even rules that place the cover also set --wipe-from, so if the
     alternation ever changes the wipe follows it instead of going stale.
     Cover left -> wipes left to right; cover right -> right to left. The
     motion starts at the image and runs toward the type, so the field reads
     as spreading out of the work rather than arriving from nowhere. */
  /* ONE FIELD ACROSS THE WHOLE CARD. The project and its cover light up
     together — they are one thing being hovered, and a gap down the middle
     read as two.

     The corridor that used to sit here solved a real problem the wrong way:
     it kept the stop dot out of the field by removing the field from around
     it. The line and the dot are now drawn back over the field in paper
     instead (below), so the mark stays legible without the field's edge
     cutting across it. */
  .card__link::before {
    content: '';
    position: absolute;
    inset: calc(-1 * var(--wash-pad));
    z-index: -2;
    background: var(--kumkumam);
    transform: scaleX(0);
    transform-origin: var(--wipe-from, left) center;
    transition: transform var(--t-quick) var(--ease);
  }

  /* Hover and focus only. The scroll-driven arrival state is untouched. */
  :is(html:not(.no-hover) .card__link:hover, .card__link.is-pressed)::before,
  .card__link:focus-visible::before { transform: scaleX(1); }

  /* A wrapped card's frame needs room at the screen edge: the cover comes
     in by the band, the line and a margin, so the band stays on
     screen; and on the spine side, so the band keeps a clear gap from the
     line. The cover sits left of the axis on odd cards and right of it on
     even ones, so the two insets swap sides. The grid, and its stagger, are
     untouched. */
  .work__grid > li.card--wrap.has-wrap:nth-child(odd) .card__media {
    margin-inline-start: calc(var(--frame-d) + var(--spine-w) + 0.75rem);
    margin-inline-end: calc(var(--frame-d) * 0.75);
  }
  .work__grid > li.card--wrap.has-wrap:nth-child(even) .card__media {
    margin-inline-start: calc(var(--frame-d) * 0.75);
    margin-inline-end: calc(var(--frame-d) + var(--spine-w) + 0.75rem);
  }
  /* And down by half a band and the line, so the stop sits level with the
     joint's centre and the line runs straight into it (spine.js, THE
     JOINT). */
  .work__grid > li.card--wrap.has-wrap:nth-child(n) .card__media {
    margin-block-start: calc(var(--frame-d) / 2 + var(--spine-w));
  }

  /* Hover and focus: the wash swallows kumkumam, so the card's own frame
     turns to paper and its loop is redrawn in paper over the wash, as the
     axis already is. */
  li.card--wrap:has(:is(html:not(.no-hover) .card__link:hover, .card__link:focus-visible)) .wrapframe,
  li.card--wrap.is-pressed .wrapframe { color: var(--paper); }
  li.card--wrap:has(:is(html:not(.no-hover) .card__link:hover, .card__link:focus-visible)) .wf__knock,
  li.card--wrap.is-pressed .wf__knock { fill: var(--kumkumam); }

  /* The field round the wrapped card is measured off its frame (spine.js,
     washFrame): 16px past the frame's outermost point on the cover's side
     and above and below it. The paper line and dot over the field follow
     the axis by --wash-axis, since the field is no longer centred on it. */
  .work__grid > li.card--wrap.has-wrap .card__link::before,
  .work__grid > li.card--wrap.has-wrap .card__link::after {
    inset: calc(-1 * var(--wash-t, var(--wash-pad))) calc(-1 * var(--wash-r, var(--wash-pad)))
           calc(-1 * var(--wash-b, var(--wash-pad))) calc(-1 * var(--wash-l, var(--wash-pad)));
  }
  .work__grid > li.card--wrap.has-wrap .card__link::after {
    background:
      radial-gradient(circle at var(--wash-axis, 50%) var(--wash-t, var(--wash-pad)),
                      var(--paper) var(--dot-r),
                      transparent calc(var(--dot-r) + 0.5px)),
      linear-gradient(var(--paper), var(--paper));
    background-repeat: no-repeat;
    background-size: 100% 100%, var(--spine-w) 100%;
    background-position: 0 0,
      calc(var(--wash-axis, 50%) - var(--spine-w) / 2) calc(var(--wash-t, var(--wash-pad)) - var(--dot-r));
  }

  /* Paired with the placement rules above, so the two cannot disagree. */
  .work__grid > li:nth-child(odd)  .card__link { --wipe-from: left; }
  .work__grid > li:nth-child(even) .card__link { --wipe-from: right; }

  /* Reduced motion: the field is still there, it simply does not travel.
     scaleX is what animates, so removing the transition and starting at 1
     gives the highlight with no slide. */
  @media (prefers-reduced-motion: reduce) {
    .card__link::before,
    .card__link::after { transition: none; }
    :is(html:not(.no-hover) .card__link:hover, .card__link.is-pressed)::before,
    .card__link:focus-visible::before { transform: scaleX(1); }
  }

  /* THE LINE AND ITS STOP, REDRAWN IN PAPER OVER THE FIELD.
     Both are --kumkumam, so a solid field of the same colour simply swallows
     them: the line vanishes for the height of the card and the dot — which
     marks this project's place on the route — vanishes with it.

     Two background layers on one element rather than two elements, because
     ::before is already the field. The bar is a 1-stop gradient sized to
     --spine-w, the same value the drawn stroke uses; the disc is a radial
     stop at the dot's real radius, centred on the axis at the card's top edge
     because that is where spine.js puts every stop ("level with the TOP of
     the stack"). --wash-pad is therefore the distance from the field's top
     edge down to the dot's centre.

     The half-pixel on the outer radial stop is antialiasing: an abrupt
     transparent stop leaves a hard, slightly ragged rim.

     It sits at 50% of the link, which is the axis the line is fitted to — the
     link spans the grid and spine.js centres the route on the grid — so the
     two cannot drift. */
  .card__link::after {
    content: '';
    position: absolute;
    inset: calc(-1 * var(--wash-pad));
    z-index: -1;
    background:
      radial-gradient(circle at 50% var(--wash-pad),
                      var(--paper) var(--dot-r),
                      transparent calc(var(--dot-r) + 0.5px)),
      linear-gradient(var(--paper), var(--paper));
    background-repeat: no-repeat;
    background-size: 100% 100%, var(--spine-w) 100%;
    /* THE BAR STARTS AT THE DISC, NOT AT THE FIELD'S EDGE.
       The field outsets --wash-pad above the card and the stop sits exactly
       on the card's top edge, so a bar drawn from the field's own top left
       (pad - radius) of paper standing above the circle — 5.8px at 1280 — and
       it read as a stray white tick rather than as the line.

       Nothing is lost by starting lower: above the disc the real line is
       kumkumam running into a kumkumam field, so it reads as continuing
       whether or not paper is painted over it. Where the radius exceeds the
       pad the value goes negative, the bar is clipped at the top edge, and
       there was no stub to remove in the first place. */
    background-position: 0 0, 50% calc(var(--wash-pad) - var(--dot-r));
    opacity: 0;
    transition: opacity var(--t-quick) var(--ease);
  }

  :is(html:not(.no-hover) .card__link:hover, .card__link.is-pressed)::after,
  .card__link:focus-visible::after { opacity: 1; }

  /* The old field was a pseudo-element of the text block alone. It stays for
     narrow, where it is still correct, and is switched off here. */
  .card__text::before { display: none; }


}

/* ===== css/spine.css ===== */
/* ==========================================================================
   SPINE — scroll-linked drawing, markers, and card activation.
   Geometry is fitted in js/spine.js; this file only drives it.

   ARCHITECTURE NOTE — the same inversion the hero uses, for the same reason.
   THE RESOLVED STATE IS THE DEFAULT: line fully drawn, cards fully visible,
   markers at full strength. Nothing animates until js/spine.js puts
   .spine-live on <html>, which it only does once the path has actually been
   fitted and reduced-motion is off.

   Written the other way round — cards hidden until scroll reveals them — a
   failed script, an unsupported timeline or a thrown error leaves the entire
   project grid blank. An earlier revision of this file did exactly that.
   Portfolio content must never be behind a script.
   ========================================================================== */

.work {
  position: relative;
  view-timeline-name: --spine;
  view-timeline-axis: block;
}

.spine {
  position: absolute;
  inset: 0;
  z-index: 0;              /* behind the cards, above the paper */
  pointer-events: none;
  /* NO LAYER OF ITS OWN (October 2026). It had will-change: transform, which
     on an iPhone made it one composited layer the height of the section,
     split into tiles that WebKit did not all repaint: loops and frames out
     of register, a loop edge missing, a stop mark stuck mid-pop. The loops
     now live in the cards, so the spine is a single straight stroke, and
     redrawing it repaints only a thin strip. Don't put the layer back. */
}

.work__grid { position: relative; z-index: 1; }

.spine__svg {
  position: absolute;
  inset: 0;
  width: 100%;
  height: 100%;
  max-width: none;
  overflow: visible;
}


/* --- Resting state = finished --------------------------------------------
   The line is continuous and each stop is a dot. The geometry is drawn
   twice: once in .spine__ghost at reduced strength for the route ahead of
   the head, once in .spine__live at full strength behind it, drawn by its
   own dash.

   IT WAS A MASK UNTIL OCTOBER 2026, because the mask revealed the line and
   its dots together. The dots left it when they became marks that pop in on
   their own, and a mask whose contents move every frame is the costliest
   way to draw a line: WebKit renders it offscreen, the whole section's
   height, every frame, and on an iPhone it showed stale copies of it, a
   faded stretch behind the tip. A dash on the line repaints only the line. */

.spine__line,
.spine__ghost-line {
  stroke: var(--kumkumam);
  stroke-width: var(--spine-w);
  stroke-linecap: round;
  fill: none;
}

.spine__dots circle,
.spine__ghost-dots circle,
.spine__cap,
.spine__ghost-cap {
  fill: var(--kumkumam);
}

/* THE STOP MARKS POP IN. Live, every mark — the cap at the top included — is
   hidden until the head reaches it; spine.js adds .is-reached on the
   threshold, and the mark scales up from nothing past its size and settles.
   Scrolling back above it takes .is-reached away and it shrinks out, without
   the overshoot. The ghost layer carries no marks at all in this state: a mark
   is only ever there once the line has reached it. Resting (no .spine-live:
   no script, no timeline, reduced motion) every mark is simply there. */
.spine__marks circle {
  transform-box: fill-box;
  transform-origin: center;
}

.spine-live .spine__marks circle {
  transform: scale(0);
  transition: transform calc(var(--t-quick) * 0.6) var(--ease);
}

/* No transitions until the first state has been applied, or every mark
   visibly shrinks away on load. spine.js adds .spine-ready a beat later. */
.spine-live:not(.spine-ready) .spine__marks circle { transition: none; }

.spine-live .spine__marks circle.is-reached {
  transform: scale(1);
}
.spine-live.spine-ready .spine__marks circle.is-reached {
  transition: transform var(--t-quick) cubic-bezier(0.34, 1.56, 0.64, 1);
}

.spine-live .spine__ghost-cap,
.spine-live .spine__ghost-dots { display: none; }

@media (prefers-reduced-motion: reduce) {
  .spine-live .spine__marks circle { transform: none; transition: none; }
}

.spine__reveal {
  stroke-dasharray: 1000 1000;              /* pathLength normalised to 1000 */
  stroke-dashoffset: 0;                     /* resting: fully revealed */
}

/* 7px flat. At clamp(3px, 0.42vw, 6px) the stroke was too light to carry a
   19-44px swing — the curve read as a wobble rather than a gesture. */
/* Declared on .work, not on .spine, so the card's paper cross-bar (work.css)
   and the drawn line read the same number. Two hardcoded 7s in two files was
   one edit away from a visible mismatch. */
.work { --spine-w: 7px; }

/* THE GHOST CARRIES THE TWO STATES.
   With deviation as the marker there is no separate element to colour, so
   "colour is earned by arrival" moves onto the route itself: the whole path
   is present at reduced strength ahead of the head, and the drawn portion
   sits over it at full kumkumam. Approaching and arrived are then true at
   every point on the line, not only at the six stops.

   Reduced strength is opacity over paper, never an interpolated fill —
   animating fill from a color-mix() to the token produced oklab(1 43 37),
   which renders yellow. */
.spine__ghost { opacity: 0; }   /* resting: the line is already complete */


/* --- Live: scroll drives everything --------------------------------------
   The line, the tip and the wrapped cover's colour are written by spine.js
   from the scroll offset, against a viewport height that does not move with
   a phone's toolbar (frame(), refHeight()). The cards' fades and coils ride
   the scroll timeline, with animation-range written inline per element by
   spine.js, because animation-range cannot read a custom property and each
   one sits at its own measured fraction along the fitted path. */

.spine-live .spine__reveal {
  /* Just past empty, so the round cap of a zero-length dash never leaves a
     dot at the start before the line has begun. */
  stroke-dashoffset: 1001;
}

/* As stroke-opacity on the path, not opacity on the group: group opacity
   needs an offscreen buffer every time the line above it repaints, and a
   single path's stroke is one shape, so where the route retraces itself it
   still never doubles up. */
.spine-live .spine__ghost { opacity: 1; }
.spine-live .spine__ghost-line { stroke-opacity: 0.26; }


/* --- The head ---------------------------------------------------------------
   Placed by offset-path along the fitted route (spine.js writes the path), and
   moved along it by the same scroll timeline and range as the reveal, so it is
   always on the line's leading end. Nothing is drawn: the tip is just the line.
   The box is an invisible grab area, 44px square, centred on the tip.

   Above the cards (z-index 2), or the card links — which span the row — would
   take every press near the line. Hidden until .spine-live, so it never shows
   on the finished resting state or under reduced motion. */

.spine__handle { display: none; }

.spine-live .spine__handle {
  display: block;
  position: absolute;
  top: 0;
  left: 0;
  z-index: 2;
  width: 44px;
  height: 44px;
  offset-anchor: center;
  offset-rotate: 0deg;
  offset-distance: 0%;
  pointer-events: auto;
  touch-action: pan-down pinch-zoom;
  cursor: grab;
}

.spine__handle.is-dragging { cursor: grabbing; }

@media (prefers-reduced-motion: reduce) {
  .spine-live .spine__handle { display: none; }
}


/* --- The coil ------------------------------------------------------------
   A coil is absent, then draws in at full --kumkumam as the head arrives,
   then STAYS. Scrolling back up above it reverses the draw, because a
   scroll timeline is scrubbed rather than played — that reversal is free.

   THE ONLY STATE IS DRAWN OR NOT DRAWN. No reduced strength before arrival,
   no fade after the head passes. Opacity is never animated: visibility comes
   entirely from the reveal mask, which starts fully retracted, so nothing
   needs to fade anything in or out.

   Because they persist, several coils are visible at once further down the
   page. That is intended now — the earlier "only one on screen" rule went
   with the fading. */

.card__coil { opacity: 1; }

/* Live: retracted until the head reaches it. animation-fill-mode is
   `forwards`, so before its range the base style below applies (hidden) and
   after it the final keyframe persists (drawn). */
.spine-live .coil__mask {
  stroke-dashoffset: 1000;
  animation: coil-draw 1s linear forwards;
  animation-timeline: --spine;
}

@keyframes coil-draw {
  to { stroke-dashoffset: 0; }
}

@media (prefers-reduced-motion: reduce) {
  .spine-live .coil__mask { animation: none; stroke-dashoffset: 0; }
}

/* Fallback: spine.js toggles .is-drawn once the head has passed, and it is
   not removed until the head goes back above. */
.spine-live.no-scroll-timeline .coil__mask {
  animation: none;
  stroke-dashoffset: 1000;
  transition: stroke-dashoffset var(--t-base) var(--ease);
}
.spine-live.no-scroll-timeline .card.is-drawn .coil__mask { stroke-dashoffset: 0; }


/* --- The card follows the coil -------------------------------------------
   Index, title, subtitle, year and cover fade in TOGETHER, starting once the
   coil has closed. The project resolves as one object: the coil is the
   arrival, and this is what arrives.

   This reverses an earlier decision recorded here, which held that nothing
   but the coil should move because withholding the work until it is scrolled
   to is a cost. That cost is real and it is being paid deliberately — the
   fade is short, it runs on the second half of the card's approach, and by
   the time a project reaches reading position it is fully resolved.

   RANGE COMES FROM THE CARD, VIA CUSTOM PROPERTIES. These elements sit at
   different depths of the card's subtree and animation-range does not
   inherit; custom properties do, so spine.js writes --fade-from/--fade-to
   once per card and every element below reads the same pair.

   The base opacity is scoped inside .spine-live, which spine.js only adds
   after the route has been fitted successfully. A thrown error, an
   unsupported timeline or reduced motion therefore all leave the cards at
   full strength rather than blank — the failure mode is "no animation", never
   "no content". */

.spine-live .card__index,
.spine-live .card__title,
.spine-live .card__sub,
.spine-live .card__year,
.spine-live .card__media {
  opacity: 0;
  animation: card-arrive var(--t-base) linear forwards;
  animation-timeline: --spine;
  animation-range: var(--fade-from, 0%) var(--fade-to, 100%);
}

@keyframes card-arrive {
  to { opacity: 1; }
}

/* The covers fade on every card as it arrives; on a layer each, the fade is
   composited instead of repainting the image on every frame of it. */
.spine-live .card__media { will-change: opacity; }

/* Fallback: no scroll timeline, so spine.js toggles .is-active instead. The
   transition delay stands in for the gap the range provides above — the coil
   closes, then the card follows. */
.spine-live.no-scroll-timeline .card__index,
.spine-live.no-scroll-timeline .card__title,
.spine-live.no-scroll-timeline .card__sub,
.spine-live.no-scroll-timeline .card__year,
.spine-live.no-scroll-timeline .card__media {
  animation: none;
  opacity: 0;
  transition: opacity var(--t-base) var(--ease) var(--t-quick);
}

.spine-live.no-scroll-timeline .card.is-active .card__index,
.spine-live.no-scroll-timeline .card.is-active .card__title,
.spine-live.no-scroll-timeline .card.is-active .card__sub,
.spine-live.no-scroll-timeline .card.is-active .card__year,
.spine-live.no-scroll-timeline .card.is-active .card__media { opacity: 1; }

@media (prefers-reduced-motion: reduce) {
  .spine-live .card__index,
  .spine-live .card__title,
  .spine-live .card__sub,
  .spine-live .card__year,
  .spine-live .card__media {
    animation: none;
    transition: none;
    opacity: 1;
  }
}


/* --- Fallback ------------------------------------------------------------
   No animation-timeline: spine.js also toggles .is-active and .is-drawn
   for the cards. Animations are off here so both paths can never drive the
   same property at once. */

.spine-live.no-scroll-timeline .card {
  animation: none;
}

.spine-live.no-scroll-timeline .card__text,
.spine-live.no-scroll-timeline .card__media {
  transform: translateY(1.25rem);
  opacity: 0;
  transition: transform var(--t-quick) var(--ease), opacity var(--t-quick) var(--ease);
}

.spine-live.no-scroll-timeline .card.is-active .card__text,
.spine-live.no-scroll-timeline .card.is-active .card__media {
  transform: translateY(0);
  opacity: 1;
}


/* --- Reduced motion ------------------------------------------------------
   Full bypass (§4, §12). spine.js will not add .spine-live at all, so the
   resting state above already is the bypass — line complete, cards active.
   This block is the belt to that braces: if the class arrives by any other
   route, the sequence is neutralised rather than merely sped up. */

@media (prefers-reduced-motion: reduce) {
  .spine-live .spine__reveal {
    animation: none;
    stroke-dashoffset: 0;
  }
  .spine-live .spine__ghost { opacity: 0; }
  .spine-live .spine__ghost-line { stroke-opacity: 1; }
  .spine-live .card { animation: none; }
  .spine-live .card__text,
  .spine-live .card__media {
    transform: none;
    opacity: 1;
    transition: none;
  }
}


/* --- Narrow: one column, stack set back from the rail -------------------- */

@media (max-width: 46rem) {
  /* The whole stack clears the rail by the same gutter, so the coil, title,
     subtitle, year and cover all align to one left edge rather than sitting
     at varying distances from the line. Applied on the link — and with
     :nth-child(n) so it beats work.css's (0,3,1) placement rules rather than
     losing to them, which is the specificity trap this layout hit before. */
  .work__grid > li:nth-child(n) .card__link {
    grid-column: 1;
    padding-inline: calc(var(--rail-x) + var(--rail-gutter)) var(--gutter);
  }

  /* No outward bleed in one column — the cover already spans the row. */
  .work__grid > li:nth-child(n) .card__media {
    margin-inline: 0;
  }

  /* And so no correction for it either. work.css nudges the text by half the
     bleed to keep it centred on the cover; with the bleed off, that nudge is
     the only thing left moving, and it knocked the type 5px off the cover it
     was meant to line up with. */
  .work__grid > li:nth-child(n) .card__text {
    translate: none;
  }

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

  /* Smaller again, and it sits beside its dot rather than over the rail —
     the stack's own gutter already places it clear. */
  .card__coil { width: clamp(32px, 9vw, 44px); }

  /* Option C on narrow too: the block centres, so the text measure centres
     within the column rather than hugging the rail. */
  .card__text { width: min(var(--text-measure), 100%); margin-inline: auto; }

  .card__sub { max-width: none; }
}

/* ===== css/about.css ===== */
/* ==========================================================================
   ABOUT — the line's destination, and the site's only inversion.

   This is the one place --kumkumam is a field rather than an accent, and the
   one place the paper/ink relationship flips. That is what makes it read as
   an arrival: the page has been cream with a red line drawn through it, and
   the line ends by turning the ground itself red.

   Contact lives here rather than in a section of its own — reaching the end
   of the writing and reaching the way to get in touch should be one moment.
   ========================================================================== */

.about {
  position: relative;
  z-index: var(--z-content);
  background: var(--kumkumam);
  color: var(--paper);

  /* --about-rhythm lives here, not on __inner, because the section's own
     bottom padding is one of the gaps it has to keep equal — see below. */
  --about-rhythm: clamp(var(--sp-l), 7vh, var(--sp-xl));

  /* THE BOTTOM IS A RHYTHM STEP, NOT A SECTION MARGIN.
     The inverted footer sits flush against this section — same red field,
     zero top padding, by design — so this padding is not breathing room at
     the end of a block, it is the gap between the last contact link and the
     conch. It was the section pad (147.6px at 1280) against 68.9px above the
     contact list: measured optically, 152px below versus 44px above, and the
     conch read as detached from the block it closes.

     SAME MULTIPLIER AS THE GAP ABOVE, which is what actually keeps them
     equal: the mark's bottom margin is 1.2 rhythm, so a bottom padding of
     1.0 rhythm diverged from it as the rhythm grew with viewport height. Less
     the conch link's own 12px hit-area padding — 1.125rem covers both, and measured back
     the two gaps land within a pixel. Tied to the token so they stay equal at
     every viewport rather than at the width someone checked. The field does not lose its breathing room —
     it continues through the footer, which carries its own padding. */
  padding-block: clamp(var(--sp-2xl), 18vh, var(--sp-3xl))
                 calc(var(--about-rhythm) * 1.2 - 1.125rem);
  padding-inline: var(--gutter);

  /* Fills the viewport. Without this the section was shorter than the screen,
     so at maximum scroll its top could never pass under the header — the
     inverted header state was unreachable rather than broken. It also makes
     the destination behave like one: the field is the last thing, and it
     should own the screen when you arrive. */
  min-height: 100svh;
  display: grid;
  align-content: center;

  /* FULL WIDTH WITHOUT A BLEED. This used to be width: 100vw with
     margin-inline: calc(50% - 50vw), to pull it out of the page's container.
     But its parent, <main>, is already the full viewport width with no
     padding, so the bleed only added the scrollbar: 100vw includes it, and
     on any browser with a classic scrollbar the section overhung by exactly
     that width (8px each side of nothing; the page scrolled sideways). As a
     plain block it fills <main>, which is the whole width there is. */
}

/* Centred, matching the hero stack and the project stacks.

   --about-rhythm is one value for every gap in the block. The eyebrow, the
   lead, the note and the contact list were each carrying their own margin,
   so the spacing between them was three different numbers that only looked
   deliberate by accident. */
.about__inner {
  max-width: 54rem;
  margin-inline: auto;
  text-align: center;
}

/* Matches how "Selected work" heads the work section, in paper rather than
   kumkumam because the field is inverted here. */
.about__eyebrow {
  max-width: none;
  margin: 0 0 var(--about-rhythm);
  color: var(--paper);
  font-size: clamp(1.05rem, 2.1vw, 2rem);
  letter-spacing: 0.26em;
}

/* The paper grain is multiply, which cannot lighten, so it does nothing on
   this field (see base.css). The dark-ground screen layer is scoped to the
   contained frames in §7/§10 and is deliberately NOT applied here — this is
   kumkumam, not near-black, and screen over it would wash it pink. */

.about__lead {
  margin: 0;
  font-family: var(--font-display);
  font-weight: 400;
  font-size: clamp(1.45rem, 2.9vw, 2.6rem);
  line-height: 1.28;
  letter-spacing: -0.015em;
  text-wrap: pretty;
}

/* Two paragraphs in the one heading: what I did, then what I do now. A <p>
   can't sit inside an <h2>, so each is a block span, and the second stands
   off by a paragraph's gap, about half a line at the lead's own size. */
.about__lead-part { display: block; }
.about__lead-part + .about__lead-part { margin-block-start: 0.7em; }

.about__note {
  margin: var(--about-rhythm) auto 0;
  max-width: 46ch;
  font-size: clamp(1rem, 1.35vw, 1.2rem);
  line-height: 1.55;
  /* Paper at reduced strength would drop below AA on this field, so the
     secondary voice is set by size and measure instead of by dimming. */
  color: var(--paper);
}

/* --- The Malayalam mark ---------------------------------------------------
   Moved here out of the hero. It reads as the illustration of the paragraph
   above it rather than as a second name under the first, so it is sized to
   sit with that paragraph, not to compete with it: a shade larger than the
   note, well under the lead, and nowhere near the hero's 3.25rem.

   COLOUR IS EXPLICIT, NOT INHERITED. In the hero this was --kumkumam, and
   this field is kumkumam — carrying that value across would have painted the
   mark in its own ground. Paper matches the one inversion this section is.

   IT STANDS ALONE. A full rhythm above and a little more below, so it reads
   as its own beat between the paragraph and the contact block rather than as
   a tail on either. Margins collapse between siblings here, so the space
   below has to exceed the contact list's own margin-top to have any effect —
   1.2x does, an equal value would not.

   Set larger than the note it illustrates and larger than the lead: it is one
   glyph cluster, not a line of reading, so it carries scale without taking
   the section over. Still well under the hero's old 3.25rem. */
.about__mal {
  margin: var(--about-rhythm) auto calc(var(--about-rhythm) * 1.2);
  max-width: none;
  color: var(--paper);
  font-size: clamp(2.5rem, 4.6vw, 3.6rem);
  /* LEADING TRIMMED SO THE BOX HUGS THE GLYPHS.
     This mark is a single line, never wrapped, so leading buys nothing — and
     it costs: the half-leading below the glyphs scales with the font, which
     grows from 40px to 57.6px across the range, so the visual gap under the
     mark shrank as the viewport widened. That was the whole reason the space
     above the contact block and the space below it could not be equalised
     with one value. At line-height 1 the box tracks the glyphs and the gap is
     the margin, at every width. */
  line-height: 1;
}

/* THE NAME WRITES ITSELF (CLAUDE.md §15f). The mark is the word drawn as an
   SVG from Manjari's own outlines, sized and placed exactly as the text was:
   its viewBox is the text's line box (the advance width by 1em, baseline at
   1399 of 2048), so the glyphs sit where the text's did, and like the text
   they overhang that box a little (the ് to the right). At rest it is one
   path. js/name-write.js adds the pieces it writes with, and hides the word
   behind them only while they are there. */
.about__mal .mal-write {
  display: block;
  width: calc(6142em / 2048);
  height: 1em;
  margin: 0 auto;
  overflow: visible;
  fill: currentColor;
}
.mal-write.is-armed .mal-write__word { opacity: 0; }
.mal-write__pieces path { opacity: 0; }
.mal-write.is-writing .mal-write__pieces path {
  opacity: 1;
  /* Each piece fades in as the pen reaches it: --d is its moment, as a
     fraction of --t-draw. The short fade is the pen's soft leading edge. */
  transition: opacity calc(var(--t-quick) * 0.1) linear calc(var(--d) * var(--t-draw));
}

/* Scoped through .about__inner deliberately. base.css resets
   ul[role='list'] { margin: 0 }, which is specificity (0,1,1) and beats a
   lone class (0,1,0) whatever the file order — so the margin below silently
   did nothing and the contact block sat flush against the paragraph above
   it. Two classes (0,2,0) wins. */
.about__inner .about__contact {
  /* Stacked, not a row: three links of very different lengths in a row read
     as a fragment of a sentence rather than three separate ways to make
     contact. */
  display: grid;
  justify-items: center;
  gap: var(--sp-s);
  margin: var(--about-rhythm) 0 0;
  padding: 0;
  list-style: none;
  font-size: clamp(1rem, 1.25vw, 1.15rem);
}

.about__contact a {
  color: var(--paper);
  text-decoration-thickness: 1px;
  text-underline-offset: 0.24em;
  transition: opacity var(--t-quick) var(--ease),
              text-decoration-thickness var(--t-quick) var(--ease);
}

/* Hover cannot go to --kumkumam-lit here: it is a near-neighbour of the
   field and would nearly vanish. Opacity keeps it clearly paper.

   MEASURED: paper at 0.72 over kumkumam composites to rgb(220,183,173),
   which is 3.95:1 against the field — 3.85:1 on the pessimistic all-black
   grain bound — and this is 16px/400 text, so §12 wants 4.5. The dim itself
   was the whole hover state, and it was dimming below the floor to do it.

   0.85 measures 4.85 / 4.72, clear with margin rather than sitting on the
   threshold at the arithmetic minimum of 0.82. It is also a fainter signal,
   so the underline now carries the rest of the state: doubling its thickness
   is not a contrast question at all, on a link that is already underlined. */
.about__contact a:hover {
  opacity: 0.85;
  text-decoration-thickness: 2px;
}

.about__contact a:focus-visible {
  outline: 2px solid var(--paper);
  outline-offset: 3px;
}


/* --- The closing conch ----------------------------------------------------
   Paper on kumkumam, below the contact links: the exact inverse of the hero,
   where the same artwork sits in kumkumam on paper. The page opens with it
   and closes with it, and the only thing that changed in between is which
   way round the ground is.

   This is NOT the rejected terminus. That one wound a fresh coil as the line
   arrived — a second animated gesture at the boundary, which made the conch
   the subject twice over. This one does not animate at all: it is the
   resting outline, sitting still, after the line has already ended plainly.

   Sized off the same axes as the hero's, a size class down, because it is a
   sign-off rather than an opening statement. */

/* The anchor carries the spacing and the hit area; the SVG inside it is only
   the artwork. Splitting them means the target can be comfortably larger than
   the mark without the mark growing to match — the drawn conch is 64-104px
   wide, and a bare 64px-wide stroke is a thin thing to ask a thumb to find. */
.about__top {
  display: block;
  width: max-content;
  margin: var(--about-rhythm) auto 0;
  padding: var(--sp-xs);
  border-radius: 0;
  -webkit-tap-highlight-color: transparent;
}

.about__conch {
  display: block;
  width: clamp(64px, min(9vh, 8vw), 104px);
  aspect-ratio: 666 / 908;
  height: auto;
  max-width: none;
  fill: var(--paper);
  /* Paper at full strength would weigh as much as the lead paragraph. This is
     the one place a reduced strength is right — it is a mark, not a reading
     surface, so the AA floor in §12 does not apply to it. */
  opacity: 0.62;
  transition: opacity var(--t-quick) var(--ease),
              transform var(--t-slow) var(--ease);
}

/* Coming up to full paper is the whole hover state. It cannot go brighter
   than paper and it must not go to kumkumam-lit, which is a near-neighbour of
   this field and would make the mark disappear rather than respond. The lift
   is small on purpose: it is a footer control, not a gesture. */
.about__top:hover .about__conch,
.about__top:focus-visible .about__conch {
  opacity: 1;
  transform: translateY(-3px);
}

.about__top:focus-visible {
  outline: 2px solid var(--paper);
  outline-offset: 2px;
}

@media (prefers-reduced-motion: reduce) {
  .about__conch { transition: none; }
  .about__top:hover .about__conch,
  .about__top:focus-visible .about__conch { transform: none; }
}

/* --- Narrow ---------------------------------------------------------------
   The red field fills far more of the screen on a phone, so the type has to
   hold its own against it rather than floating in the middle of a wash. */

@media (max-width: 46rem) {
  .about {
    /* TWO VALUES, NOT ONE. The shorthand's single-value form resets both
       edges, so this quietly threw away the bottom step set above and the
       conch drifted back out to 98px against 52px at the top of the contact
       block. Narrow gets a smaller top pad; the bottom stays a rhythm step. */
    padding-block: clamp(var(--sp-xl), 12vh, var(--sp-2xl))
                   calc(var(--about-rhythm) * 1.2 - 1.125rem);
  }
  .about__note { max-width: none; }
  .about__contact { gap: var(--sp-s); }
}


/* --- Arrival --------------------------------------------------------------
   §14 phase 6. The block fades up as you reach it, one element at a time.

   THE HIDDEN STATE IS BEHIND .js-reveal, which only js/about-reveal.js adds.
   Without the script — blocked, failed, or absent — none of these rules match
   and the copy is simply there. A reveal that hides content by default and
   relies on JavaScript to show it again is one script error away from an
   empty section, and this one is the site's contact details.

   transform and opacity only: both composite, so a six-item stagger costs no
   layout work while the field itself is 100svh of solid colour. */

.about.js-reveal .about__reveal {
  opacity: 0;
  transform: translateY(0.7em);
}

.about.js-reveal .about__reveal.is-in {
  opacity: 1;
  transform: none;
  /* The step index comes from the script, so the stagger follows source order
     without a nth-child ladder that would silently go stale if the block
     gained a line. */
  transition: opacity var(--t-slow) var(--ease),
              transform var(--t-slow) var(--ease);
  transition-delay: calc(var(--reveal-step, 0) * var(--t-base) * 0.09);
}

/* Belt and braces: the script already refuses to arm under the preference,
   but if the class arrived by any other route the copy stays put rather than
   merely moving faster. */
@media (prefers-reduced-motion: reduce) {
  .about.js-reveal .about__reveal,
  .about.js-reveal .about__reveal.is-in {
    opacity: 1;
    transform: none;
    transition: none;
  }
}

/* ===== css/pookalam.css ===== */
/* ==========================================================================
   THE POOKALAM (CLAUDE.md §15e) — one component, used twice.

   A floral carpet from the site's curve vocabulary: leaf petals, a band of
   small conch spirals, lotus petals, teardrops and the conch at its heart, in
   kumkumam with paper-deep and paper details. Its five rings are defined once
   (#pk-r1 to #pk-r5 in the page's shared SVG defs) and each instance draws
   them with <use>, every ring its own SVG and so its own layer.

   1. The first-load intro: a kumkumam field over the hero, the rings spinning
      to a stop, then the field opening like temple doors.
   2. The head of the About field, where its rings turn into place on scroll
      (js/pookalam.js).
   Transform and opacity only.
   ========================================================================== */

.pookalam {
  position: relative;
  aspect-ratio: 1;
}

.pookalam__ring {
  position: absolute;
  inset: 0;
  width: 100%;
  height: 100%;
  overflow: visible;
  transform-origin: 50% 50%;
}


/* --- 2. The About field ----------------------------------------------------
   A row of its own above the type, in the flow, so it can never sit under
   any of it. */
.about .pookalam {
  width: clamp(11rem, 22vw, 18rem);
  margin: 0 auto var(--about-rhythm);
}

/* Layers only while it can move. */
.about .pookalam.is-live .pookalam__ring { will-change: transform, opacity; }


/* --- 1. The first-load intro -----------------------------------------------
   Prateek's decision, over §4's no-preloader rule. Drawn in the first paint:
   the inline script in the head puts .has-intro on <html> before anything
   renders, and only then is it shown. The rings spin to a stop together over
   --t-base; the halves start to swing open at 0.7 of it, as the rings settle
   their last few degrees, and open slowly, over --t-slow on the --ease-move
   spring: about 1.96s in all. The hero underneath is live throughout, and its
   own sequence is held until the doors start (--intro-hold, hero.css), so the
   conch starts drawing as they open. Any tap, click, key or scroll opens them
   at once (.pk-open). */
:root { --pk-open-at: calc(var(--t-base) * 0.7); }

.pk-intro { display: none; }

html.has-intro .pk-intro {
  display: block;
  position: fixed;
  inset: 0;
  z-index: calc(var(--z-cursor) - 1);
  /* The doors take a tap; the gap between them as they part does not. */
  pointer-events: none;
}

.pk-intro__door {
  position: absolute;
  top: 0;
  bottom: 0;
  width: 50%;
  overflow: hidden;
  background: var(--kumkumam);
  pointer-events: auto;
  will-change: transform;
  backface-visibility: hidden;
}

/* Each half shows its half of one pookalam, centred on the seam. */
.pk-intro__face {
  position: absolute;
  top: 0;
  bottom: 0;
  width: 200%;
  display: grid;
  place-items: center;
}
.pk-intro__door--l { left: 0; transform-origin: left center; box-shadow: 1px 0 0 var(--kumkumam); }
.pk-intro__door--l .pk-intro__face { left: 0; }
.pk-intro__door--r { right: 0; transform-origin: right center; }
.pk-intro__door--r .pk-intro__face { right: 0; }

.pookalam--intro { width: min(64vmin, 26rem); }

html.has-intro .pookalam--intro .pookalam__ring {
  will-change: transform;
  animation: pk-spin var(--t-base) var(--ease) both;
}
/* Alternating directions, the outer ring spinning furthest. */
.pookalam--intro .pookalam__ring--1 { --pk-spin: -540deg; }
.pookalam--intro .pookalam__ring--2 { --pk-spin: 450deg; }
.pookalam--intro .pookalam__ring--3 { --pk-spin: -360deg; }
.pookalam--intro .pookalam__ring--4 { --pk-spin: 300deg; }
.pookalam--intro .pookalam__ring--5 { --pk-spin: -240deg; }

html.has-intro .pk-intro__door--l { animation: pk-door-l var(--t-slow) var(--ease-move) var(--pk-open-at) both; }
html.has-intro .pk-intro__door--r { animation: pk-door-r var(--t-slow) var(--ease-move) var(--pk-open-at) both; }

/* THE LOGO'S REPLAY CLOSES THE DOORS FIRST (October 2026). On home, .pk-close:
   the doors swing in from the edges over --t-quick, the rings spin and stop
   once they're shut, and the doors reopen as on arrival, all in about 2.5s.
   They close on --ease, not the spring: the spring went about 3% past shut
   and back, which put the pookalam's two halves out of line at the seam.
   They count as shut at 90% of --t-quick (--pk-shut-at), within a pixel of
   closed. The opening swing waits its turn, and fills forwards only, so it
   doesn't hold the doors shut while they're still closing. On a project
   page, .pk-shut: the doors close over the page and stay shut, the
   pookalam straight, while it navigates home, where the first paint shows
   them just so. */
:root { --pk-shut-at: calc(var(--t-quick) * 0.9); }
html.has-intro.pk-close .pk-intro__door--l {
  animation: pk-door-shut-l var(--t-quick) var(--ease) both,
             pk-door-l var(--t-slow) var(--ease-move) calc(var(--pk-shut-at) + var(--pk-open-at)) forwards;
}
html.has-intro.pk-close .pk-intro__door--r {
  animation: pk-door-shut-r var(--t-quick) var(--ease) both,
             pk-door-r var(--t-slow) var(--ease-move) calc(var(--pk-shut-at) + var(--pk-open-at)) forwards;
}
html.has-intro.pk-close .pookalam--intro .pookalam__ring {
  animation: pk-spin var(--t-base) var(--ease) var(--pk-shut-at) both;
}
html.has-intro.pk-shut .pk-intro__door--l { animation: pk-door-shut-l var(--t-quick) var(--ease) both; }
html.has-intro.pk-shut .pk-intro__door--r { animation: pk-door-shut-r var(--t-quick) var(--ease) both; }
html.has-intro.pk-shut .pookalam--intro .pookalam__ring { animation: none; transform: none; }

/* Closing over a page, the pookalam is straight, its rings lined up as at
   rest (.pk-straight: the logo's replay, About, and home arriving from
   either). So a replay's spin is whole turns of each ring's own repeat
   (the teardrop ring repeats every 45°, the centre conch only every 360°),
   and starts and ends lined up; the other rings' turns already are. The
   first-visit intro keeps its own spin. */
html.pk-straight .pookalam--intro .pookalam__ring--4 { --pk-spin: 315deg; }
html.pk-straight .pookalam--intro .pookalam__ring--5 { --pk-spin: -360deg; }

/* ABOUT FROM A PROJECT PAGE (October 2026), .pk-about: the doors closed over
   the project page (morph.js, .pk-shut), and home's first paint shows them
   shut, already at About. No spin: a short beat (--pk-beat), then they
   reopen onto About, the pookalam straight throughout. */
:root { --pk-beat: calc(var(--t-base) * 0.2); }
html.has-intro.pk-about .pk-intro__door--l { animation: pk-door-l var(--t-slow) var(--ease-move) var(--pk-beat) both; }
html.has-intro.pk-about .pk-intro__door--r { animation: pk-door-r var(--t-slow) var(--ease-move) var(--pk-beat) both; }
html.has-intro.pk-about .pookalam--intro .pookalam__ring { animation: none; transform: none; }

@keyframes pk-door-shut-l { from { transform: translateX(-100%); } }
@keyframes pk-door-shut-r { from { transform: translateX(100%); } }

/* Opened early: the same swing, from now. Its own animation names, so it
   starts from closed rather than jumping into the timed one. */
html.has-intro.pk-open .pk-intro__door--l { animation: pk-door-l-now var(--t-slow) var(--ease-move) both; }
html.has-intro.pk-open .pk-intro__door--r { animation: pk-door-r-now var(--t-slow) var(--ease-move) both; }
html.has-intro.pk-open .pk-intro__door { pointer-events: none; }

@keyframes pk-spin { from { transform: rotate(var(--pk-spin)); } to { transform: none; } }

@keyframes pk-door-l {
  from { transform: perspective(1600px) translateX(0) rotateY(0deg); }
  to   { transform: perspective(1600px) translateX(-100%) rotateY(-14deg); }
}
@keyframes pk-door-r {
  from { transform: perspective(1600px) translateX(0) rotateY(0deg); }
  to   { transform: perspective(1600px) translateX(100%) rotateY(14deg); }
}
@keyframes pk-door-l-now {
  from { transform: perspective(1600px) translateX(0) rotateY(0deg); }
  to   { transform: perspective(1600px) translateX(-100%) rotateY(-14deg); }
}
@keyframes pk-door-r-now {
  from { transform: perspective(1600px) translateX(0) rotateY(0deg); }
  to   { transform: perspective(1600px) translateX(100%) rotateY(14deg); }
}

@media (prefers-reduced-motion: reduce) {
  html.has-intro .pk-intro { display: none; }
}

/* ===== css/masthead.css ===== */
/* ==========================================================================
   MASTHEAD — site-wide, minimal.

   Built once because project pages need navigation, and navigation that only
   exists on some pages is worse than navigation that is quietly consistent.

   Present from the top of the page. An earlier version slid in only after the
   hero had scrolled past, which left the first screen with no way to navigate
   at all — fine as an effect, wrong as a site.

   COLOUR IS STATED PER CONTROL, NOT PER ELEMENT TYPE. <summary> is not an
   <a>, so a rule written for links skips it and it falls back to the UA's
   default. Every rule below names all three — mark, link and summary — in
   both the resting and inverted states.
   ========================================================================== */

.masthead {
  position: fixed;
  inset-block-start: 0;
  inset-inline: 0;
  z-index: var(--z-nav);

  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: var(--sp-m);
  /* From the token, not a literal: --masthead-h is derived from this value so
     the hero can reserve exactly the height the bar occupies. Changing the
     padding here without changing the token would put the two out of step. */
  padding: var(--masthead-pad) var(--gutter);

  /* OPAQUE, NO BLUR (October 2026). It was 88% paper over a 10px
     backdrop blur, which the GPU re-blurs from the page under it on every
     frame of a scroll, and the progress line rides on it. */
  background: var(--paper);
  border-block-end: 1px solid var(--rule);

  transition: background-color var(--t-quick) var(--ease),
              border-color var(--t-quick) var(--ease),
              color var(--t-quick) var(--ease);
}


/* --- Scroll progress ------------------------------------------------------
   A kumkumam bar on the masthead's bottom edge that fills across the width of
   the page as the document scrolls. It sits ON the rule rather than under it,
   so the bar is not a second horizontal line — it is the rule, being drawn.

   masthead.js writes the fill's transform from the scroll offset, on every
   browser (no CSS scroll timeline: on an iPhone it glitched at every touch).
   Without the script the resting state is an empty track rather than a full
   one.

   Kept under prefers-reduced-motion. It is not motion for its own sake: it
   reports where you are, and it only ever moves because you moved the page. */

.masthead__progress {
  position: absolute;
  inset-inline: 0;
  /* Over the border, not above it. */
  inset-block-end: -1px;
  height: 3px;
  overflow: hidden;
  pointer-events: none;
}

/* TRANSFORM ONLY, ON ITS OWN LAYER. Full width, scaled from the left;
   masthead.js writes this element's transform and nothing else. */
.masthead__progress-fill {
  display: block;
  height: 100%;
  background: var(--kumkumam);
  transform-origin: left center;
  transform: scaleX(0);
  will-change: transform;
}

/* On the inverted field a kumkumam bar on a kumkumam ground has no edge, so
   the fill takes paper there and the track keeps the border's own tint. */
.masthead.is-over-invert .masthead__progress-fill { background: var(--paper); }


/* --- Mark ----------------------------------------------------------------- */

.masthead__mark {
  display: inline-flex;
  /* CENTRE, NOT BASELINE. With the conch in the box, baseline alignment sized
     the line box off the artwork and left the wordmark's optical centre 4.5px
     above WORK and ABOUT — measured, not guessed. The nav items are centred in
     the bar, so the name has to be centred in the mark to meet them. */
  align-items: center;
  gap: 0.55rem;
  color: var(--ink);
  text-decoration: none;
}

/* Sized off the wordmark's own cap height rather than a fixed px, so the two
   stay in proportion as the name scales. */
.masthead__conch {
  width: auto;
  height: 2.1em;
  aspect-ratio: 666 / 908;
  fill: var(--kumkumam);
  flex: none;
}

.masthead.is-over-invert .masthead__conch { fill: var(--paper); }

.masthead__mark-name {
  font-family: var(--font-display);
  font-size: clamp(1.15rem, 1.55vw, 1.5rem);
  letter-spacing: -0.01em;
}


/* --- Nav ------------------------------------------------------------------ */

.masthead__nav {
  display: flex;
  align-items: center;
  gap: clamp(var(--sp-s), 2.5vw, var(--sp-l));
}

.masthead__link,
.menu__summary {
  color: var(--kumkumam);
  font-size: var(--type-micro);
  letter-spacing: var(--ls-wide);
  text-transform: uppercase;
  text-decoration: none;
  padding-block: 0.35rem;
  border-block-end: 1px solid transparent;
  transition: color var(--t-quick) var(--ease),
              border-color var(--t-quick) var(--ease);
}

.masthead__link:hover,
.menu__summary:hover {
  color: var(--kumkumam-lit);
  border-block-end-color: var(--kumkumam-lit);
}

.masthead__mark:focus-visible,
.masthead__link:focus-visible,
.menu__summary:focus-visible {
  outline: 2px solid var(--kumkumam);
  outline-offset: 4px;
}


/* --- The Work menu -------------------------------------------------------
   Six projects would crowd the bar, so they live one level down. <details>
   gives open/close, keyboard operation and a correct expanded state with no
   script at all, and degrades to a labelled list of links if CSS fails. */

.menu { position: relative; }

.menu__summary {
  cursor: pointer;
  list-style: none;
  display: inline-flex;
  align-items: center;
  gap: 0.45rem;
}

.menu__summary::-webkit-details-marker { display: none; }

/* Caret drawn in CSS rather than set as a glyph, so it inherits colour and
   rotates with the open state. */
.menu__summary::after {
  content: '';
  width: 0.36em;
  height: 0.36em;
  border-right: 1px solid currentColor;
  border-bottom: 1px solid currentColor;
  transform: rotate(45deg) translateY(-0.1em);
  transition: transform var(--t-menu-out) var(--ease);
}

.menu[open]:not(.is-closing) .menu__summary::after {
  transform: rotate(-135deg) translateY(-0.1em);
  transition-duration: var(--t-menu-in);
}

/* OPEN AND CLOSE ARE ANIMATED (November 2026): the panel fades in and drops
   a few pixels into place, and closes in reverse, a little quicker. Transform
   and opacity only. masthead.js drives it: a reader's open starts from
   .is-from, and a close plays .is-closing before <details> really shuts, so a
   reopen mid-close just drops the class and reverses from where it is. An
   open by anything else (the menu morph's reverse) has no .is-from and shows
   at once, since an element that was display: none has nothing to
   transition from. */
.menu {
  --t-menu-in: calc(var(--t-base) * 0.25);
  --t-menu-out: calc(var(--t-base) * 0.18);
}

/* Absolutely positioned content escapes the hiding a browser applies to a
   closed <details>, so it has to be hidden explicitly — without this the
   panel rendered over the hero while the menu was shut. */
.menu:not([open]) .menu__list { display: none; }

.menu__list {
  position: absolute;
  inset-inline-end: 0;
  inset-block-start: calc(100% + 0.7rem);
  /* ABOVE THE PROGRESS BAR. Both are absolutely positioned inside the
     masthead with no z-index of their own, so paint order fell to DOM order
     and the bar — which comes later — drew its kumkumam rule straight across
     the top of the open panel. One local step is enough: .masthead is a
     stacking context, so this cannot escape the bar. */
  z-index: 1;
  min-width: 15rem;
  margin: 0;
  padding: var(--sp-xs) 0;
  list-style: none;
  background: var(--paper);
  border: 1px solid var(--rule);
  box-shadow: 0 12px 30px -18px rgba(36, 28, 24, 0.4);
  transition: opacity var(--t-menu-in) var(--ease), transform var(--t-menu-in) var(--ease);
}

.menu.is-from .menu__list {
  opacity: 0;
  transform: translateY(-6px);
  transition: none;
}

.menu.is-closing .menu__list {
  opacity: 0;
  transform: translateY(-6px);
  transition-duration: var(--t-menu-out);
  pointer-events: none;
}

.menu__list li { margin: 0; }

.menu__list a {
  display: block;
  padding: 0.5rem var(--sp-s);
  color: var(--ink);
  font-size: var(--type-micro);
  letter-spacing: 0.1em;
  text-decoration: none;
  white-space: nowrap;
}

.menu__list a:hover {
  background: var(--kumkumam);
  color: var(--paper);
}

.menu__list a:focus-visible {
  outline: 2px solid var(--kumkumam);
  outline-offset: -2px;
}

/* The panel used to end with an "All work" row, ruled off from the six
   projects. It has gone: the panel already IS all the work, so the row
   restated its own contents, and the summary above it is the same anchor. */


/* --- Over the inverted field ---------------------------------------------
   A cream stripe across the inversion would cut it in half, so the bar takes
   the field's colours while it is over it. The panel keeps paper ground —
   a kumkumam panel on a kumkumam field would have no edge. */

.masthead.is-over-invert {
  background: var(--kumkumam);
  border-block-end-color: color-mix(in srgb, var(--paper) 28%, var(--kumkumam));
}

.masthead.is-over-invert .masthead__mark,
.masthead.is-over-invert .masthead__link,
.masthead.is-over-invert .menu__summary {
  color: var(--paper);
}

.masthead.is-over-invert .masthead__link:hover,
.masthead.is-over-invert .menu__summary:hover {
  color: var(--paper);
  border-block-end-color: var(--paper);
}

.masthead.is-over-invert .masthead__mark:focus-visible,
.masthead.is-over-invert .masthead__link:focus-visible,
.masthead.is-over-invert .menu__summary:focus-visible {
  outline-color: var(--paper);
}


@media (max-width: 46rem) {
  .menu__list {
    min-width: min(17rem, calc(100vw - 2 * var(--gutter)));
  }
}

/* ON THE NARROWEST PHONES the panel hangs from the bar, not from Work
   (November 2026). Right-aligned to Work, its 17rem ran past the screen's
   left edge below about 370px (43px at 320), cutting off the first letters
   of every item. The bar is position: fixed, so with .menu static the panel
   is placed in the bar: its right edge on the gutter, under the bar. */
@media (max-width: 26.99rem) {
  .menu { position: static; }
  .menu__list { inset-inline-end: var(--gutter); }
}

/* --- Tools (November 2026) -----------------------------------------------
   A plain link after About (Work, About, Tools, Ask Kuri: Prateek's order,
   November 19 2026; it sat between Work and About, as in the tools mockup).
   The bar holds the wordmark, Work, About and Tools from 24rem (384px; it
   needs about 377). Below that, Tools is the first row of the Work menu,
   above Ask Kuri, and the bar keeps Work and About. */
.menu__tools { display: none; }
@media (max-width: 23.99rem) {
  .masthead__link--tools { display: none; }
  .menu__tools { display: block; }
  .menu__tools a { color: var(--kumkumam); }
  /* Ask Kuri's row, under it, carries the divider; without Kuri, Tools does. */
  .masthead:not(.has-kuri) .menu__tools { border-block-end: 1px solid var(--rule); margin-block-end: 0.35rem; }
}
.masthead__link[aria-current] { border-block-end-color: currentColor; }

@media (prefers-reduced-motion: reduce) {
  .masthead,
  .masthead__link,
  .menu__summary,
  .menu__summary::after,
  .menu__list { transition: none; }
}

/* ===== css/footer.css ===== */
/* ==========================================================================
   SITE FOOTER — shared by the homepage and every project page.

   Built because the project pages needed a consistent ending and because
   CLAUDE.md §9's footer byline had never actually been placed anywhere. One
   component now does both jobs, so the two cannot drift.

   WHAT IT DOES NOT CONTAIN: contact links. On the homepage they already sit
   in the About field directly above this, and repeating them one block later
   would read as a stutter rather than as a second chance. On a project page
   they are one click away through the About link in the masthead. The footer
   is the end of the page, not a second navigation.

   The back-to-top conch lives here rather than inside About, so there is
   exactly one of it on the homepage and the same one on every other page. It
   is the same mark, same valampiri flip, same paper-on-whatever treatment —
   only the ground changes, which is the point.
   ========================================================================== */

.site-footer {
  padding-block: clamp(var(--sp-xl), 10vh, var(--sp-2xl));
  padding-inline: var(--gutter);
  text-align: center;
}

/* On the homepage the footer follows the inverted About field, so it takes
   that field's colours and reads as its last line rather than as a cream
   strip cutting the arrival in half. */
/* Read off the footer that is actually on the page, rather than set per page
   in the markup. A page that switches footer variant later takes the right
   overscroll tail with it and cannot be forgotten. Browsers without :has()
   keep the --paper default, which is the behaviour that shipped before. */
:root:has(.site-footer--inverted) { --overscroll-tail: var(--kumkumam); }

/* No 100vw bleed: the footer is a child of <body>, which is already the full
   viewport width, so 100vw only overhung it by the scrollbar's width (see
   about.css). As a plain block it is exactly full width. */
.site-footer--inverted {
  background: var(--kumkumam);
  color: var(--paper);
  /* The field above already carries the top of this block; without pulling
     up, the two would show a seam where their paddings meet. */
  margin-block-start: 0;
  padding-block-start: 0;
}


/* --- Back to top ---------------------------------------------------------
   A real link with a real accessible name, not a scripted click target: it
   takes keyboard focus in order and works with no JavaScript. The SVG stays
   aria-hidden, because the name belongs to the anchor — an anchor whose only
   content is decorative artwork announces as an unlabelled link. */

.site-footer__top {
  display: block;
  width: max-content;
  margin-inline: auto;
  /* The anchor carries the hit area, the SVG only the artwork. A bare 64px
     stroke is a thin thing to ask a thumb to find. */
  padding: var(--sp-xs);
  -webkit-tap-highlight-color: transparent;
}

.site-footer__conch {
  display: block;
  width: clamp(64px, min(9vh, 8vw), 104px);
  aspect-ratio: 666 / 908;
  height: auto;
  max-width: none;
  /* Paper on the inverted ground, kumkumam on paper. Set per context below
     rather than here, so the same markup serves both. */
  opacity: 0.62;
  transition: opacity var(--t-quick) var(--ease),
              transform var(--t-slow) var(--ease);
}

.site-footer--inverted .site-footer__conch { fill: var(--paper); }
.site-footer:not(.site-footer--inverted) .site-footer__conch { fill: var(--kumkumam); }

/* Coming up to full strength is the whole hover state. It must not go to
   --kumkumam-lit on the inverted ground: that is a near-neighbour of the
   field and would make the mark disappear rather than respond. */
.site-footer__top:hover .site-footer__conch,
.site-footer__top:focus-visible .site-footer__conch {
  opacity: 1;
  transform: translateY(-3px);
}

.site-footer--inverted .site-footer__top:focus-visible {
  outline: 2px solid var(--paper);
  outline-offset: 2px;
}

.site-footer:not(.site-footer--inverted) .site-footer__top:focus-visible {
  outline: 2px solid var(--kumkumam);
  outline-offset: 2px;
}


/* --- Byline --------------------------------------------------------------
   §9, verbatim. Quiet: it is a signature, not a statement. */

.site-footer__byline {
  margin: var(--sp-l) auto 0;
  max-width: none;
  font-size: var(--type-small);
  letter-spacing: 0.06em;
  line-height: var(--lh-snug);
}

.site-footer--inverted .site-footer__byline { color: var(--paper); opacity: 0.82; }
.site-footer:not(.site-footer--inverted) .site-footer__byline { color: var(--ink-muted); }


@media (prefers-reduced-motion: reduce) {
  .site-footer__conch { transition: none; }
  .site-footer__top:hover .site-footer__conch,
  .site-footer__top:focus-visible .site-footer__conch { transform: none; }
}


/* --- The draw ------------------------------------------------------------
   The same masked reveal as the hero: conch-stroke swept along the spine by
   stroke-dashoffset, uncovering the tapered outline underneath. The taper is
   the artwork, not something CSS reconstructs.

   RESOLVED BY DEFAULT — offset 0, fully drawn. js/footer-conch.js adds
   .is-armed to wind it back and .is-drawing to release it, so every failure
   path (no script, no IntersectionObserver, reduced motion) lands on a
   finished conch rather than an empty frame.

   Stroke properties are set on the <use>, not the referenced path: they are
   inherited properties, so they reach the cloned geometry inside. Width 32
   clears the outline's measured 21-unit waist with margin, exactly as in the
   hero — a narrower mask clips the artwork at its widest point. */

.site-footer__mask {
  fill: none;
  stroke: #fff;                 /* mask luminance: white reveals */
  stroke-width: 32;
  stroke-linecap: round;
  stroke-linejoin: round;
  stroke-dasharray: 1000 1000;  /* pathLength is normalised to 1000 */
  stroke-dashoffset: 0;
}

.site-footer.is-armed .site-footer__mask { stroke-dashoffset: 1000; }

/* Faster than the hero's draw, deliberately. --t-draw is ~2.7s, which is
   right for the opening moment of the site but too slow for a mark you meet
   at the bottom of a page you are already leaving. --t-slow is ~1.3s. */
.site-footer.is-drawing .site-footer__mask {
  animation: footer-conch-draw var(--t-slow) linear forwards;
}

@keyframes footer-conch-draw {
  from { stroke-dashoffset: 1000; }
  to   { stroke-dashoffset: 0; }
}

/* Belt and braces: the script already refuses to arm under the preference,
   but if the class arrived by any other route the sequence is neutralised
   here rather than merely sped up. */
@media (prefers-reduced-motion: reduce) {
  .site-footer.is-armed .site-footer__mask,
  .site-footer.is-drawing .site-footer__mask {
    animation: none;
    stroke-dashoffset: 0;
  }
}

/* ===== css/cursor.css ===== */
/* ==========================================================================
   CUSTOM CURSOR — CLAUDE.md §5 (audited and rebuilt in Phase 5).

   The mark is conch-outline.svg's own tapered artwork (js/cursor.js builds
   it). At rest, the small spiral: the outline from the eye out to 0.6 of the
   spine. On structural UI it twirls one turn about the eye while the rest of
   the line comes in, piece by piece along the spine. Opacity and transform
   only: nothing is stroked, masked or resized.

   POINTER-EVENTS: NONE IS LOAD-BEARING. A full-viewport fixed layer that
   accepts pointer events swallows every click on the page. It would have
   silently re-broken click-to-zoom, the nav, and the video facades. It is
   declared on the host and never overridden.

   DESKTOP ONLY, gated in script on (hover: hover) and (pointer: fine) — the
   element is not created at all on touch, so there is nothing to interfere
   with a tap. The native cursor is only hidden once the custom one exists.
   ========================================================================== */

/* Hiding the native cursor is done by a class the script adds, so a page
   where the script never ran keeps its ordinary pointer rather than losing
   the cursor entirely. */
.has-conch-cursor,
.has-conch-cursor a,
.has-conch-cursor button,
.has-conch-cursor summary,
.has-conch-cursor .is-zoomable,
.has-conch-cursor label,
.has-conch-cursor .spine__handle { cursor: none; }

/* BODY TEXT KEEPS THE TEXT CURSOR, and the mark steps aside there (the
   script hides it over the same blocks). Not in the nav, the masthead or a
   card, which are structural throughout. */
.has-conch-cursor :is(p, li, figcaption, blockquote, dt, dd, td, th, .about__lead):not(nav *, .masthead *, .card__link *, a *, button *, summary *, label *) {
  cursor: text;
}
/* Inline links in case-study copy keep the native pointer: the mark never
   twirls on them (§5). */
.has-conch-cursor :is(.pj-body, .brand__note) a { cursor: pointer; }

/* WHERE THE MARK STANDS DOWN ([data-native-cursor]: the film players, the
   Metis wipe) the native cursor comes back. They used to inherit none from
   <html>, so over a player there was no cursor at all. Zero specificity, so
   a control's own cursor (the wipe's ew-resize) still wins. */
:where(.has-conch-cursor) :where([data-native-cursor], [data-native-cursor] *) { cursor: auto; }

.cursor {
  position: fixed;
  inset-block-start: 0;
  inset-inline-start: 0;
  z-index: var(--z-cursor);
  pointer-events: none;          /* see the note above — never change this */
  /* The box is the whole conch; the resting spiral is 0.77 of its width,
     about 26px here. */
  width: 34px;
  aspect-ratio: 626 / 867;
  color: var(--kumkumam);
  /* The script writes the follow here, with the eye on the pointer. */
  transform: translate3d(-100px, -100px, 0);
  will-change: transform;
  opacity: 0;
  transition: opacity var(--t-quick) var(--ease);
  /* Home: the long version. */
  --cur-in: var(--t-slow);
  --cur-out: var(--t-quick);
  --cur-fade: calc(var(--t-quick) * 0.1);
  --e0: 0;
}
.cursor.is-visible { opacity: 1; }
/* Over body text the I-beam shows instead. */
.cursor.is-visible.is-text { opacity: 0; }

.cursor__art {
  display: block;
  width: 100%;
  height: 100%;
  overflow: visible;
  fill: currentColor;
  /* The twirl turns about the eye, where the spine starts: the hotspot. */
  transform-origin: 42.92% 31.45%;
  transition: transform var(--cur-out) var(--ease);
}
.cursor.is-over .cursor__art {
  transform: rotate(-360deg);
  transition: transform var(--cur-in) var(--ease);
}

/* The line beyond the spiral, piece by piece. --d is a piece's place along
   it (0 to 1), --e0 how far the line had got when the hover changed, so it
   carries on, or winds back, from there. */
.cursor__ext path {
  opacity: 0;
  transition: opacity var(--cur-fade) linear calc((var(--e0) - var(--d)) * var(--cur-out));
}
.cursor.is-over .cursor__ext path {
  opacity: 1;
  transition: opacity var(--cur-fade) linear calc((var(--d) - var(--e0)) * var(--cur-in));
}

/* OVER RED AND DARK GROUNDS the mark goes cream. --kumkumam on the About
   field, the inverted footer, a hovered card's wash or the CTA button is
   kumkumam on kumkumam — 1:1, invisible. The case-study blocks are dark for a
   different reason and need the same treatment. The switch is immediate. */
.cursor.is-inverted { color: var(--paper); }

/* QUIETER ON PROJECT PAGES (§5: "shorter, quicker version of the same
   effect"). Smaller, and the line extends only to 0.82 of the spine (the
   script leaves out the rest), over --t-quick. */
.pj-cursor .cursor {
  width: 26px;
  --cur-in: var(--t-quick);
  --cur-out: calc(var(--t-quick) * 0.6);
}

/* REDUCED MOTION — the mark still tracks the pointer, which is what makes it
   a cursor, but nothing animates: no twirl, no extension (the script builds
   no pieces), no fade, no smoothing. The small spiral is what shows. */
@media (prefers-reduced-motion: reduce) {
  .cursor,
  .cursor__art { transition: none; }
  .cursor.is-over .cursor__art { transform: none; }
}

/* ===== css/kuri.css ===== */
/* ==========================================================================
   KURI + CITED SPOTS (CLAUDE.md §17)

   Loaded on every page. Two parts:
   1. .cite-mark: the outline a deep link's target gets on landing (js/cite.js),
      on every page, whether or not Kuri is on.
   2. Kuri's masthead control, About's line and the dialog. All of it stays
      hidden (the [hidden] attribute) until js/kuri.js turns it on.

   The site's own system: tokens, General Sans, Gambetta for the name, kumkumam
   for what's live, square corners. Nothing here borrows a case study's
   palette.
   ========================================================================== */

/* --- 1. The landing outline ---------------------------------------------- */

.cite-mark,
.cite-mark--still {
  outline: 2px solid var(--kumkumam);
  outline-offset: 10px;
}
.cite-mark { animation: cite-mark calc(var(--t-slow) * 2.4) var(--ease) both; }

@keyframes cite-mark {
  0%   { outline-color: color-mix(in srgb, var(--kumkumam) 0%, transparent); }
  22%  { outline-color: var(--kumkumam); }
  62%  { outline-color: var(--kumkumam); }
  100% { outline-color: color-mix(in srgb, var(--kumkumam) 0%, transparent); }
}

/* On the inverted About field the outline is paper, as everything is there. */
.about .cite-mark,
.about .cite-mark--still { outline-color: var(--paper); }
.about .cite-mark { animation-name: cite-mark-paper; }
@keyframes cite-mark-paper {
  0%   { outline-color: color-mix(in srgb, var(--paper) 0%, transparent); }
  22%  { outline-color: var(--paper); }
  62%  { outline-color: var(--paper); }
  100% { outline-color: color-mix(in srgb, var(--paper) 0%, transparent); }
}

@media (prefers-reduced-motion: reduce) {
  .cite-mark { animation: none; }
}

/* The quoted words themselves (js/cite.js, the CSS Custom Highlight API):
   a kumkumam underline on a faint kumkumam tint. Ink on the tint is about
   11.7:1. It fades in once the page is where it's going (--kuri-cite-a, a
   registered number the highlight's colors scale by); reduced motion: there
   at once. On the inverted About field, paper. */
@property --kuri-cite-a {
  syntax: '<number>';
  inherits: true;
  initial-value: 0;
}
html.kuri-cite-shown {
  --kuri-cite-a: 1;
  transition: --kuri-cite-a var(--t-slow) var(--ease);
}
::highlight(kuri-cite) {
  background-color: color-mix(in srgb, var(--kumkumam) calc(var(--kuri-cite-a) * 14%), transparent);
  text-decoration: underline 2px color-mix(in srgb, var(--kumkumam) calc(var(--kuri-cite-a) * 100%), transparent);
  text-underline-offset: 0.22em;
}
.about *::highlight(kuri-cite) {
  background-color: color-mix(in srgb, var(--paper) calc(var(--kuri-cite-a) * 18%), transparent);
  text-decoration-color: color-mix(in srgb, var(--paper) calc(var(--kuri-cite-a) * 100%), transparent);
}
@media (prefers-reduced-motion: reduce) {
  html.kuri-cite-shown { transition: none; }
}


/* --- 2. Ask Kuri in the masthead ----------------------------------------- */

.masthead__kuri {
  position: relative;
  background: none;
  border: 0;
  border-block-end: 1px solid transparent;
  font: inherit;
  font-size: var(--type-micro);
  cursor: pointer;
  border-radius: 0;
  white-space: nowrap;
}

/* WHERE IT SITS, by the bar's measured room (November 2026, Prateek's call:
   the wordmark always stays). With "Prateek Nair", Work, About and Tools,
   the bar needs about 486px for "Ask Kuri" and 446px for "Kuri" (measured
   when Tools joined the bar, November 18 2026; it was 465 and 427). So:
   30.5rem (488px) and up, "Ask Kuri"; from 28rem (448px), "Kuri" (the button
   keeps the name "Ask Kuri"); below that, Ask Kuri is in the Work menu, after
   Tools, and the glow and dot go on the menu's button. */
.masthead__kuri { display: none; }
.masthead.has-kuri .masthead__kuri { display: inline-block; }
@media (max-width: 30.49rem) {
  .masthead__kuri-ask { display: none; }
}
@media (max-width: 27.99rem) {
  .masthead.has-kuri .masthead__kuri { display: none; }
}

.menu__kuri { display: none; }
@media (max-width: 27.99rem) {
  .masthead.has-kuri .menu__kuri { display: block; border-block-end: 1px solid var(--rule); margin-block-end: 0.35rem; }
}
.menu__kuri-btn {
  display: block;
  width: 100%;
  text-align: start;
  padding: 0.5rem var(--sp-s);
  background: none;
  border: 0;
  border-radius: 0;
  font: inherit;
  font-size: var(--type-micro);
  letter-spacing: 0.1em;
  color: var(--kumkumam);
  cursor: pointer;
  white-space: nowrap;
}
.menu__kuri-btn:hover { background: var(--kumkumam); color: var(--paper); }
/* What Kuri is, for anyone who doesn't know the name (Prateek's call). */
.menu__kuri-note {
  margin-inline-start: 0.55em;
  color: color-mix(in srgb, var(--ink) 68%, var(--paper));
  letter-spacing: 0.06em;
}
.menu__kuri-btn:hover .menu__kuri-note { color: var(--paper); }
.menu__kuri-btn:focus-visible { outline: 2px solid var(--kumkumam); outline-offset: -2px; }

/* The dot: a small kumkumam mark beside the bar's Ask Kuri until Kuri is
   first opened, from 448px up. On phones there is no dot at all (Prateek's
   call): the red Ask Kuri row at the top of the Work menu, with its divider,
   is the highlight there, and Work keeps only the one-time glow. */
.masthead__kuri.kuri-dot { position: relative; }
.masthead__kuri.kuri-dot::before {
  content: "";
  position: absolute;
  inset-block-start: 0.15rem;
  inset-inline-end: -0.55rem;
  width: 0.375rem;
  height: 0.375rem;
  border-radius: 50%;
  background: var(--kumkumam);
}
.masthead.is-over-invert .masthead__kuri.kuri-dot::before { background: var(--paper); }

/* The glow: once, on a session's first page, then the dot. */
.kuri-glowing { animation: kuri-glow calc(var(--t-slow) * 2) var(--ease) both; }
@keyframes kuri-glow {
  0%   { text-shadow: 0 0 0 transparent; color: var(--kumkumam); }
  35%  { text-shadow: 0 0 0.9em color-mix(in srgb, var(--kumkumam-lit) 70%, transparent); color: var(--kumkumam-lit); }
  100% { text-shadow: 0 0 0 transparent; color: var(--kumkumam); }
}
.masthead.is-over-invert .kuri-glowing { animation-name: kuri-glow-paper; }
@keyframes kuri-glow-paper {
  0%, 100% { text-shadow: 0 0 0 transparent; }
  35%      { text-shadow: 0 0 0.9em color-mix(in srgb, var(--paper) 80%, transparent); }
}

/* About's last line: "Or ask Kuri. It knows the site." */
.about__kuri {
  margin-block-start: var(--sp-m);
  /* Centred under the contact links it follows (they're a centred stack;
     About's own copy is set left). Its box keeps the paragraphs' measure,
     so it's centred in the column too. */
  margin-inline: auto;
  text-align: center;
}
.about__kuri-open {
  background: none;
  border: 0;
  border-radius: 0;
  padding: 0;
  font: inherit;
  color: inherit;
  text-decoration: underline;
  text-decoration-thickness: 1px;
  text-underline-offset: 0.18em;
  cursor: pointer;
}
.about__kuri-open:focus-visible {
  outline: 2px solid var(--paper);
  outline-offset: 4px;
}

@media (prefers-reduced-motion: reduce) {
  .kuri-glowing { animation: none; }
}

/* The panel's own styles are in css/kuri-panel.css, loaded with js/kuri-panel.js
   the first time someone opens Kuri: nothing of the panel loads with a page. */
