/* The orrery: the initiatives circle the great sigil.
   An alchemical orrery. The emblem is the sun: colour bands round a dial
   that ticks, the pyramid with its eye at the centre; the sigils of EMBERS,
   NOT NOT PHILO and INTERSECT and the events star ride its orbits, all
   anticlockwise and slower the farther out, like planets. The clockwork
   (ring, bands, dial) turns against itself like meshed gears. Scrolling
   travels out to each body in turn: the body grows, its world blooms around
   it, its words arrive. Falling into a world is a cross-document view
   transition from the body you tapped.
   Loaded after nts.css, the world kits and pages.css, and before
   apertures.css, which turns each world window and the handovers into
   apertures (it switches off the bloom and the plumb line below).
   Nothing here redefines a --pal-*, --code-* or --w-* token.
   Angles, periods and directions: --a is where a body starts, --p how long
   one orbit takes, --d normal (clockwise) or reverse (anticlockwise, which
   every orbit uses); each body turns with its orbit in the emblem. They,
   the riders and the world faces are generated from site.json's
   `initiatives` (tools/sync.mjs).
   Every orbit is a zero-size pivot, with the body riding it at the radius,
   turning round it and turned back upright: a rotated box of any size would
   push its corners into the page's scrollable overflow. */

:root {
  /* nts:orbits */
  --a-embers: 205deg; --p-embers: 120s; --d-embers: reverse;
  --a-philo: 330deg; --p-philo: 170s; --d-philo: reverse;
  --a-intersect: 80deg; --p-intersect: 230s; --d-intersect: reverse;
  --a-star: 15deg; --p-star: 300s; --d-star: reverse;
  /* /nts:orbits */
  --bead: max(44px, 11cqi);
  /* the world pages' trace ring: it sits --ring-inset inside the entity, which is at most --ring-cap
     across (the entity column's --entity-w, and 92svh of a short screen), and the hero's top padding on a
     phone is --hero-top. The home's outer orbit is sized to it on a phone. */
  --ring-inset: 2.6rem; --entity-w: 30rem; --ring-cap: min(var(--entity-w), 92svh); --hero-top: 1.5rem;
  --orbit-share: .9545; /* the outer orbit's diameter (192.8) of the emblem's box (202) */
}

/* ---------- the opener: the orrery ---------- */
.threshold { display: grid; gap: clamp(1rem, 3vw, 2rem); padding: 0 0 clamp(2.5rem, 6vw, 4rem); align-items: center; }
/* On a phone the sky runs to the screen's edges and clips there, so a body
   riding past the emblem's box is cut by the screen, never by the box. The
   emblem is sized so its outer orbit (the outermost one, 96.4 of 101 out from the
   middle: --orbit-share of the box across) is the trace ring of the world
   pages (see "the trace"): the entity column or less, capped as the ring's
   caps are, less --ring-inset. The sky's top padding puts its centre on the
   ring's: the ring is centred in the square entity, which starts --hero-top
   under the header, and stays at the entity's middle when 92svh shrinks the
   ring. The padding's % is of the column; the width's is of the screen. */
.sky { display: grid; justify-items: center; margin-inline: calc(-1 * var(--gutter)); overflow-x: clip;
  padding-top: calc(var(--hero-top) + min(100%, var(--entity-w)) / 2 - (min(100%, var(--ring-cap)) - var(--ring-inset)) / (2 * var(--orbit-share))); }
.orrery {
  position: relative; aspect-ratio: 1; container-type: inline-size;
  width: calc((min(100% - 2 * var(--gutter), var(--ring-cap)) - var(--ring-inset)) / var(--orbit-share));
  touch-action: pan-y;
}
@media (min-width: 600px) { .sky { margin-inline: 0; padding-top: 0; overflow-x: visible; } .orrery { width: min(100%, 34rem); margin-inline: auto; } }

/* ---------- the emblem ---------- */
/* The emblem sits on the page's beige: a black dial, no plate, no grid.
   Every colour below is a palette token (nts.css, section 1); --e-* name
   what each one does here: --e-run is the marks' ink on the dial, --e-stop
   the ink on the beige the dial fades to. */
.threshold {
  position: relative; isolation: isolate; color: var(--e-text);
  --e-text: var(--pal-ink); --e-muted: var(--pal-muted); --e-hint: var(--pal-voice);
  --e-dial: var(--pal-ink); --e-run: var(--pal-bone); --e-stop: var(--pal-ink);
  --e-dot: var(--pal-ink); --e-orbit: var(--pal-ink); --e-halo: var(--pal-ink);
  /* the sunburst is fainter on the black */
  --e-geo-op: .32; --e-star-op: .87;
}
.threshold :focus-visible { outline-color: var(--e-text); }

/* the layers, back to front: the star drawn on stop, the dotted ring, the
   dial, the keylines and bands, the sunburst, the ticking marks and the
   north, the pyramids, the eye's button and beams, the beads, the orbits
   with their stars. Each is a whole SVG or box (the compositor turns it). */
.orrery {
  isolation: isolate;
  --swap: 1.6s; --swap-ease: cubic-bezier(.45, 0, .55, 1); --mark: .1s; --mid: .8s; --early: .7s;
}
.orrery :is(.e-ly, .e-star, .e-tick, .e-bm, .e-orbit) { position: absolute; inset: 0; width: 100%; height: 100%; overflow: visible; pointer-events: none; }
.orrery .pivot { z-index: 1; }
.orrery .k-run { color: var(--e-run); }
.orrery .k-stop { color: var(--e-stop); }
.orrery .k-dial { color: var(--e-dial); }
.orrery .k-dot { color: var(--e-dot); }
.orrery .k-orbit { color: var(--e-orbit); }
.orrery .k-halo { color: var(--e-halo); }
.orrery .e-rays { opacity: var(--e-geo-op); }
/* the strokes' widths (nts.css, "lines", in eu): set once on a layer and
   inherited by its paths, so the generated paths carry none */
.orrery .e-north { stroke-width: var(--line-keyline); }
.orrery .e-ring { stroke-width: var(--line-ring); }
.orrery .e-geo { stroke-width: var(--line-rays); }
.orrery .e-tet { stroke-width: var(--line-seam); }
.orrery .e-tet .edge { stroke-width: var(--line-outline-edge); }
.orrery :is(.e-tet .rim, .eye, .st svg) { stroke-width: var(--line-outline); }
.orrery .st .halo { stroke-width: var(--line-halo); }
.orrery :is(.e-o66, .e-o96) > svg { stroke-width: var(--line-orbit); }
.orrery .e-o78 > svg { stroke-width: var(--line-orbit-dash); }
.orrery .e-o84 > svg { stroke-width: var(--line-orbit-dot); }

/* the eye is the stop button: a clear disc over the pyramid and the
   sunburst. On hover or keyboard focus the eye lights to bone and beams;
   on a touch screen, with no hover, one quiet beam every 9 s. */
.orrery .e-stop { position: absolute; left: 37.87%; top: 37.87%; width: 24.26%; height: 24.26%; margin: 0; padding: 0; border: 0; border-radius: 50%; background: transparent; cursor: pointer; z-index: 2; -webkit-tap-highlight-color: transparent; touch-action: manipulation; }
.orrery .e-stop:focus-visible { outline: 2px solid var(--e-text); outline-offset: 3px; }
.orrery .eye { fill: var(--code-events); transition: fill .3s; }
.orrery:has(.e-stop:focus-visible) .eye { fill: var(--pal-bone); }
@media (hover: hover) { .orrery:has(.e-stop:hover) .eye { fill: var(--pal-bone); } }
/* the beam: a ring that grows from the pyramid's incircle out past its
   outline and fades (scale and opacity only), in the ink of what is behind
   it: one copy on the dial's ink, one on the beige's, handing over with the
   pyramid */
.orrery .e-beam { position: absolute; left: 50%; top: 50%; width: 22.77cqi; height: 22.77cqi; margin: -11.385cqi 0 0 -11.385cqi; opacity: 0; transform: scale(.35); }
.orrery .e-beam svg { display: block; width: 100%; height: 100%; overflow: visible; }
/* eu to the beam's 20-unit box (px is a user unit); the box is drawn at 22.77cqi = 22.77 * 2.02 eu */
.orrery .e-beam circle { stroke-width: calc(var(--line-beam) * 20px / (22.77 * 2.02)); }

/* the stars: code dots on the orbits, decorative marks (no pages yet to
   open): not focusable, hidden from assistive tech; the halo shows on a
   pointer's hover only */
.orrery .e-pv { position: absolute; left: 50%; top: 50%; width: 0; height: 0; }
.orrery .st { position: absolute; left: -4.703cqi; width: 9.406cqi; height: 9.406cqi; margin: 0; padding: 0; border: 0; background: none; pointer-events: auto; -webkit-tap-highlight-color: transparent; }
.orrery .st svg { display: block; width: 100%; height: 100%; max-width: none; overflow: visible; }
.orrery .st .hit { pointer-events: all; }
.orrery .st .halo { opacity: 0; transition: opacity .2s; }
@media (hover: hover) { .orrery .st:hover .halo { opacity: 1; } }
.orrery .e-pulse { position: absolute; left: 50%; top: 50%; width: 2.574cqi; height: 2.574cqi; margin: -1.287cqi 0 0 -1.287cqi; border-radius: 50%; border: calc(var(--line-pulse) * 100cqi / 202) solid var(--e-halo); opacity: .55; pointer-events: none; }

/* stopping: one swap, the same both ways, inside --swap (1.6 s). The dial
   fades out, and the marks and the sunburst with it, so the beige shows
   through the centre; the north stays. The pyramid and the beam come in two
   copies, one inked for the dial and one for the beige, and hand over at
   the midpoint in .1 s (the one on top comes in over [.7, .8] before the
   one below goes over [.8, .9]; resuming mirrors it), so the pyramid never
   thins. The pyramid flips over its eye with the glide; the star at the
   back draws itself in from .3 s and undraws in reverse. */
.orrery :is(.e-dial, .e-fade) { transition: opacity var(--swap) var(--swap-ease); }
.orrery :is(.e-bm, .e-tet) { transition-property: transform, opacity; transition-duration: 1.6s, var(--mark); transition-timing-function: var(--ease-turn), linear; transition-delay: 0s, var(--mid); }
.orrery :is(.e-bm.run, .e-tet.run, .e-tet.up) { transition-delay: 0s, var(--early); }
.is-stopped .orrery :is(.e-bm.stop, .e-tet.stop, .e-tet.down) { transition-delay: 0s, var(--early); }
.is-stopped .orrery :is(.e-bm.run, .e-tet.run, .e-tet.up) { transition-delay: 0s, var(--mid); }
.orrery :is(.e-bm.stop, .e-tet.stop, .e-tet.down) { opacity: 0; }
.is-stopped .orrery :is(.e-dial, .e-fade, .e-bm.run, .e-tet.run) { opacity: 0; }
.is-stopped .orrery :is(.e-bm.stop, .e-tet.stop) { opacity: 1; }
.orrery .e-tet.down { display: none; }
.is-stopped .orrery .e-tet { transform: rotate(180deg); }
.is-stopped .orrery .e-pulse { animation: none; opacity: 0; }
/* the star: seven edges, each a box laid along its line; each draws in
   with a window sliding along it (.win, overflow hidden) while the drawing
   slides back (.pen), so the line stays put and is rasterised once. Each
   edge's slice of the pen's curve is inline (--il, --id; --ol, --od). */
.orrery .e-star { overflow: clip; opacity: 0; transition: opacity .2s ease 1.1s; }
.orrery .he { position: absolute; opacity: var(--e-star-op); }
.orrery .he :is(.win, .pen) { position: absolute; inset: 0; }
.orrery .he .win { overflow: hidden; transform: translateX(-100%); transition: transform var(--od) linear var(--ol); }
.orrery .he .pen { transform: translateX(100%); transition: transform var(--od) linear var(--ol); }
.orrery .he svg { display: block; width: 100%; height: 100%; max-width: none; }
/* the chalk's three passes, by the class the generator gives each; an edge's box is in eu */
.orrery .he .chalk { stroke-width: var(--line-chalk); }
.orrery .he .chalk-mid { stroke-width: var(--line-chalk-mid); }
.orrery .he .chalk-fine { stroke-width: var(--line-chalk-fine); }
.is-stopped .orrery .e-star { opacity: 1; transition: opacity .2s ease .3s; }
.is-stopped .orrery .he :is(.win, .pen) { transform: none; transition: transform var(--id) linear var(--il); }

/* motion: the clockwork (ring, bands, dial) gears against itself; the planet
   orbits all turn anticlockwise, slower outward. The dial ticks
   counter-clockwise like a seconds hand: `rotate` steps -6deg a second
   (steps(60) over a minute) while `transform` eases each second's last
   .24 s from 0 to -6deg with a small overshoot, so the sum moves in 60
   short eased steps and is back on its north each minute. */
@media (prefers-reduced-motion: no-preference) {
  .orrery .e-ring { animation: turn 70s linear infinite; }
  .orrery .e-bands { animation: turn 95s linear infinite reverse; }
  .orrery .e-o66 { animation: turn 120s linear infinite reverse; }
  .orrery .e-o78 { animation: turn 170s linear infinite reverse; }
  .orrery .e-o84 { animation: turn 230s linear infinite reverse; }
  .orrery .e-o96 { animation: turn 300s linear infinite reverse; }
  .orrery .e-tick { animation: e-tick 1s linear infinite, e-minute 60s steps(60, end) infinite; }
  .orrery .e-pulse { animation: e-pulse 4.8s ease-out infinite; }
  .orrery .e-stop:focus-visible ~ .e-bm .e-beam { animation: e-beam 2.4s cubic-bezier(.2, .7, .2, 1) infinite; }
  @media (hover: hover) { .orrery .e-stop:hover ~ .e-bm .e-beam { animation: e-beam 2.4s cubic-bezier(.2, .7, .2, 1) infinite; } }
  @media (hover: none) { .orrery .e-beam { animation: e-beam-rare 9s cubic-bezier(.2, .7, .2, 1) 2.5s infinite; } }
}
@keyframes e-tick { 0%, 76% { transform: none; animation-timing-function: cubic-bezier(.18, 1.7, .4, 1); } 100% { transform: rotate(-6deg); } }
@keyframes e-minute { to { rotate: -360deg; } }
@keyframes e-pulse { 0% { transform: scale(1); opacity: .7; } 45%, 100% { transform: scale(2.8); opacity: 0; } }
@keyframes e-beam { 0% { transform: scale(.35); opacity: 0; } 18% { opacity: 1; } 80%, 100% { transform: scale(1); opacity: 0; } }
@keyframes e-beam-rare { 0% { transform: scale(.35); opacity: 0; } 3.6% { opacity: .9; } 16%, 100% { transform: scale(1); opacity: 0; } }
/* stopped: no animation; orrery.js pins each part where it stands, then
   the glide eases it to the stop pose (by the shorter way) */
.orrery.is-still :is(.e-ly, .e-tick, .e-orbit, .pivot > *) { animation-name: none !important; }
.orrery.is-gliding :is(.e-ring, .e-bands, .e-orbit, .e-tick, .e-pv, .pivot > *) { transition: transform 1.6s var(--ease-turn); }
/* reduced motion: nothing turns, glides, flips or draws. The dial still
   fades over --swap (a fade is not motion, so it beats the global .01ms) and
   the marks still hand over; the pyramid hands over to a copy drawn upside
   down; the star fades in whole; the eye holds a still ring. */
@media (prefers-reduced-motion: reduce) {
  .orrery :is(.e-dial, .e-fade) { transition-duration: var(--swap) !important; }
  .orrery .e-star, .is-stopped .orrery .e-star { transition: opacity var(--swap) var(--swap-ease) !important; }
  .orrery :is(.e-bm, .e-tet) { transition-duration: 0s, var(--mark) !important; }
  .orrery .he :is(.win, .pen) { transform: none !important; transition: none !important; }
  .orrery.is-gliding :is(.e-ring, .e-bands, .e-orbit, .e-tick, .e-pv, .pivot > *) { transition: none !important; }
  .is-stopped .orrery .e-tet { transform: none; }
  .orrery .e-tet.down { display: block; }
  .orrery .e-tet.stop:not(.down) { display: none; }
  .is-stopped .orrery .e-tet.up { opacity: 0; }
  .is-stopped .orrery .e-tet.down { opacity: 1; }
  .orrery .e-stop:focus-visible ~ .e-bm .e-beam { opacity: .9; transform: scale(.7); }
  @media (hover: hover) { .orrery .e-stop:hover ~ .e-bm .e-beam { opacity: .9; transform: scale(.7); } }
  @media (hover: none) { .orrery .e-beam { opacity: .7; transform: scale(.7); } }
}
/* the pivot: a zero-size point holding an orbit's angle (--a), radius (--r)
   and period (--p). What rides it has one transform, rotate(θ)
   translateY(-r) rotate(-θ): it sits at --r in the direction θ and stays
   upright, and one animation takes θ from --a round a full turn. The pose
   is built on the pivot and inherited (--pose, --pose-end), because the
   animated rider must declare no custom property of its own: Chromium
   re-resolves every animated element that does, selector matching and all,
   on every frame while a ::selection rule reads a var() (nts.css has them).
   Only transform animates, so the compositor runs the orbit. */
.pivot {
  position: absolute; left: 50%; top: 50%; width: 0; height: 0; pointer-events: none;
  --pose: rotate(var(--a, 20deg)) translateY(calc(-1 * var(--r, 50cqi))) rotate(calc(-1 * var(--a, 20deg)));
  --pose-end: rotate(calc(var(--a, 20deg) + 1turn)) translateY(calc(-1 * var(--r, 50cqi))) rotate(calc(-1 * var(--a, 20deg) - 1turn));
}
.pivot > * { position: absolute; left: 0; top: 0; transform: var(--pose); animation: orbit var(--p, 80s) linear infinite; animation-direction: var(--d, normal); }
@keyframes orbit { from { transform: var(--pose); } to { transform: var(--pose-end); } }
/* The bead: one build wherever a world is worn as a round body (the orrery's,
   the events' small orrery, the rings of the bands). WHO it is comes from
   fixed tokens, never from --w-*, which a page's bleed swaps: a face
   reading those turns beige in the bleed's light state. WHERE it sits is
   --ground, set where the bead is placed; the moat is a spread of it. The
   face owns its edge: a ring in the sigil's colour drawn inside the face as
   a gradient (a second inset shadow reaching the edge leaves a fringe
   outside it). Each place sets only the size. Under the pointer or the
   keyboard the link lifts and the seal turns full sigil colour and doubles
   its weight, a layer that fades in (opacity only); no ring is drawn at the
   face's edge. The rings that open NTS's own bands (nts, events) are the
   bead of the band they open: its ground the face, its marks the sigil and
   seal. */
/* nts:faces */
.bead-face[data-of="embers"] { --of-base: var(--embers-night); --of-sigil: var(--embers-fire); }
.bead-face[data-of="philo"] { --of-base: var(--philo-ground); --of-sigil: var(--philo-red); }
.bead-face[data-of="intersect"] { --of-base: var(--intersect-black); --of-sigil: var(--intersect-phosphor); }
/* /nts:faces */
.bead-face[data-of="nts"] { --of-base: var(--ecl-bg); --of-sigil: var(--ecl-fg); }
.bead-face[data-of="events"] { --of-base: var(--ecl-bg); --of-sigil: var(--code-events); }
/* a ring on a seam is the band it opens: its face is the band's ground. The
   EMBERS summon ring is the exception: its band is the sigil's own colour, so
   it keeps its world's face. */
.ecl:not(.world, .embers-summon) > .ecl-ring.bead-face { --of-base: var(--ecl-bg); }
main { --ground: var(--w-bg); }
.bead-face {
  --moat: 3px;
  border-radius: 50%; display: grid; place-items: center; color: var(--of-sigil);
  /* the edge ring: --line-bead-ring wide, its outer edge 3.25px inside the face, .5px ramps */
  background: radial-gradient(circle closest-side,
    var(--of-base) calc(100% - 3.75px - var(--line-bead-ring)),
    color-mix(in srgb, var(--of-sigil) 72%, var(--of-base)) calc(100% - 3.25px - var(--line-bead-ring)) calc(100% - 3.25px),
    var(--of-base) calc(100% - 2.75px));
  box-shadow: 0 0 0 var(--moat) var(--ground);
}
.bead-face .nts-sigil { width: 58%; height: 58%; aspect-ratio: 1; color: inherit; }
.bead-face::after {
  content: ""; position: absolute; inset: 0; border-radius: 50%; pointer-events: none;
  box-shadow: 0 7px 12px -5px var(--w-cast);
  /* the seal: --line-bead-seal wide, its outer edge 2.75px inside the face, .25px ramps */
  background: radial-gradient(circle closest-side,
    transparent calc(100% - 3px - var(--line-bead-seal)),
    var(--of-sigil) calc(100% - 2.75px - var(--line-bead-seal)) calc(100% - 2.75px),
    transparent calc(100% - 2.5px));
  opacity: 0; transition: opacity var(--dur-lift) var(--ease-lift);
}
a:is(:hover, :focus-visible) > .bead-face::after, a.bead-face:is(:hover, :focus-visible)::after { opacity: 1; }
a.bead-face:focus-visible { outline: 2px solid var(--pal-ink); outline-offset: 5px; }
/* each body rides its orbit in the emblem: the registry's r, of the emblem's 202 */
/* nts:riders */
.orrery .o-embers { --r: 32.67cqi; --a: var(--a-embers); --p: var(--p-embers); --d: var(--d-embers); }
.orrery .o-philo { --r: 38.81cqi; --a: var(--a-philo); --p: var(--p-philo); --d: var(--d-philo); }
.orrery .o-intersect { --r: 41.58cqi; --a: var(--a-intersect); --p: var(--p-intersect); --d: var(--d-intersect); }
.orrery .o-star { --r: 47.72cqi; --a: var(--a-star); --p: var(--p-star); --d: var(--d-star); }
/* /nts:riders */
.bead {
  width: var(--bead); height: var(--bead);
  margin: calc(var(--bead) / -2) 0 0 calc(var(--bead) / -2);
  display: grid; place-items: center; pointer-events: auto; text-decoration: none;
  -webkit-tap-highlight-color: transparent;
}
.bead .face { position: relative; width: 100%; aspect-ratio: 1; height: auto; border-radius: 50%; transition: transform var(--dur-lift) var(--ease-lift); }
.bead:hover .face, .bead:focus-visible .face { transform: translateY(var(--lift-y)); }
.bead:active .face { transform: scale(.97); }
.bead:active .face::after { opacity: 0; }
/* the focus ring is the face's, so it rises with the face and stays round it */
.bead:focus-visible { outline: none; }
.bead:focus-visible .face { outline: 2px solid var(--pal-ink); outline-offset: 5px; }
.bead[data-body="star"] .face { display: grid; place-items: center; }
/* solid ochre with an ink keyline as thick as the line of the round beads' sigils:
   --line-sigil of a 64-unit glyph at 58% of the bead, here on a 14-unit glyph at 66% */
.bead[data-body="star"] .nts-sigil { width: 66%; height: auto; aspect-ratio: 1; }
.bead[data-body="star"] .nts-sigil path { fill: var(--code-events); stroke: var(--pal-ink); stroke-width: var(--line-star-bead); stroke-linejoin: round; }

/* the hint that a bead opens: now and then a thin ring grows off it and
   fades, the eye's beam in small (scale and opacity only), with a pointer
   and on a touch screen. One bead at a time: an 18 s cycle, each bead 4.5 s
   after the last, a quarter second past each half of the eye's touch beam
   (every 9 s from 2.5 s), so neither meets another. The ring is the bead's
   ::after, so it rides the orbit, outside the face that falling into a world
   names orb. Its box is the ring at full size, scaled down to start, so it
   is drawn sharp at its widest; it starts at a round bead's face edge, and at
   the star's own glyph size. Under reduced motion there is no ring. */
@media (prefers-reduced-motion: no-preference) {
  .orrery .bead::after {
    content: ""; position: absolute; z-index: -1; inset: -35%; border-radius: 50%; border: var(--line-bead-hint) solid var(--e-halo);
    opacity: 0; transform: scale(.59); pointer-events: none;
    animation: bead-pulse 18s cubic-bezier(.2, .7, .2, 1) 4.75s infinite;
  }
  .orrery .bead[data-body="star"]::after { inset: -2.7%; }
  .orrery .o-philo .bead::after { animation-delay: 9.25s; }
  .orrery .o-intersect .bead::after { animation-delay: 13.75s; }
  .orrery .o-star .bead::after { animation-delay: 18.25s; }
  /* while the machine is stopped nothing pulses; pausing, not removing, keeps
     each ring's place in the stagger for when it runs again */
  .is-stopped .orrery .bead::after, .orrery.is-still .bead::after { animation-play-state: paused; }
}
@keyframes bead-pulse { 0% { transform: scale(.59); opacity: 0; } 1.8% { opacity: .6; } 8%, 100% { transform: scale(1); opacity: 0; } }

/* the name, under the sky on phones, beside it from 900px */
.intro { display: grid; justify-items: center; text-align: center; gap: clamp(.7rem, 2vh, 1.1rem); }
.intro h1 { font-size: clamp(2.6rem, 11.5vw, 5.5rem); line-height: .92; max-width: 9ch; }
.intro .incant { max-width: 24ch; margin: 0; }
.intro .label { margin: 0; color: var(--e-muted); }
@media (min-width: 900px) {
  .threshold { grid-template-columns: minmax(0, 1fr) minmax(0, 1.1fr); min-height: calc(100svh - var(--bar-h)); column-gap: clamp(2rem, 5vw, 5rem); padding-block: 1.5rem 3rem; }
  .sky { order: 2; }
  .orrery { width: min(100%, 40rem, 84vh); }
  .intro { justify-items: start; text-align: left; }
  .intro h1 { max-width: 8ch; }
  .turn { text-align: left; }
}
/* ---------- a short landscape screen: the desktop arrangement ---------- */
/* A phone held sideways, at any width, takes the desktop arrangement on
   every page: the words beside the figure, which is sized from the height.
   The figure is the --stage square, --stage-pad under the header and clear
   of the screen's foot, so the whole orbit and the title share the first
   screen. The home's sky and every world's entity are that square, on the
   right of the same columns and at the top of their row (so the centre
   does not move with the words' height): the home's outer orbit stays the
   worlds' trace ring, same diameter and centre. CSS has no named media
   query, so the whole mode is this one block; every page loads this file
   after the world kits and pages.css, so it wins over their rules at the
   same weight. 480px is above every phone held sideways (430 at most); a
   short desktop window (500 high) keeps the desktop layout and its 92svh
   caps. */
@media (orientation: landscape) and (max-height: 480px) {
  :root { --stage-pad: 1rem; --stage: min(var(--entity-w), 100svh - var(--bar-h) - 2 * var(--stage-pad)); }
  :is(.threshold, .hero) { grid-template-columns: minmax(0, 1fr) var(--stage); align-items: center; min-height: 0; column-gap: clamp(1.5rem, 5vw, 3rem); padding-top: var(--stage-pad); }
  :is(.sky, .hero .entity) { order: 2; align-self: start; }
  /* the home: the emblem centred in the square, its outer orbit the ring */
  .sky { height: var(--stage); align-content: center; margin-inline: 0; padding-top: 0; overflow-x: visible; }
  .orrery { width: calc((var(--stage) - var(--ring-inset)) / var(--orbit-share)); margin-inline: auto; }
  .intro { justify-items: start; text-align: left; }
  .intro h1 { max-width: 8ch; font-size: min(clamp(2.6rem, 11.5vw, 5.5rem), 13svh); }
  .turn { text-align: left; }
  /* the worlds: the entity is the square; EMBERS' stage is no shorter than
     it, PHILO's caption hangs inside the square, a line under the cubes
     (philo.css has the rule), and its ring plate is centred on the square
     (philo.css has the plate's formulas) */
  .hero .entity { width: var(--stage); }
  .hearth-stage { max-height: none; }
  .philo-hero .entity { margin-bottom: 0; }
  .philo-rings { --pt: var(--stage-pad); --ew: var(--stage); --cx: calc(100% - var(--pad) - var(--stage) / 2); --cy: calc(var(--pt) + var(--stage) / 2); }
  /* EVENTS: the entity is the square beside the words, the small orrery
     keeps its phone size inside it at every width (the class more outweighs
     the 900px rule below), and the title is capped by the height to fit
     its column */
  .events-hero .entity > .mini-orrery { width: min(64%, 13rem); }
  .events-hero h1 { font-size: min(clamp(3rem, 14vw, 7rem), 20svh); }
}

/* ---------- the journey: handovers and worlds ---------- */
/* The handover between two sections: a short dotted plumb line in the
   page's ink, centred, the orbit's own dash; apertures.css makes it the
   plain gap where the next ring sits. Markup: <div class="handover" aria-hidden="true"></div>. */
.handover { display: block; height: clamp(3.5rem, 10vw, 6rem); background: repeating-linear-gradient(to bottom, var(--pal-ink) 0 3px, transparent 3px 11px) 50% 0 / 1px calc(100% - 1rem) no-repeat; opacity: .45; }

.world { position: relative; isolation: isolate; overflow: clip; color: var(--w-fg); padding: clamp(2.5rem, 7vw, 5rem) 0 clamp(3rem, 8vw, 6rem); --bloom-at: 50% 30%; }
.world::before { content: ""; position: absolute; inset: 0; z-index: -1; background: var(--w-bg); clip-path: circle(150% at var(--bloom-at)); }
.world ::selection { background: var(--w-selection); color: var(--w-selection-fg); }
.world-grid { display: grid; gap: clamp(1.75rem, 5vw, 3rem); justify-items: center; }
.orb-stage { width: min(100% - 5rem, 22rem); }
/* the orb: the world's live figure in a circle, its orbit dashed round it,
   and the way into the world (tapped, it grows into the world's hero: the
   view transition named orb). Its depth goes into it, never off the
   ground: it does not rise or cast. The orb's box is the window, the size
   it always had, and at rest the figure in it is exactly as on a plain
   disc: no transform and no clip but the disc's own round edge, so a live
   figure costs nothing more to composite. Around the window lies a ring of
   bare ground, --lid (in cqi of the window) wide, then --orbit-gap more
   to the orbit. Under the
   pointer, the keyboard or a press the portal opens (below). Every part of
   the opening is painted once and only moved or faded (transform,
   opacity): the window (the fragment, with the figure in it) and its limb
   (.orb::after). Opening is slow and eased out, closing quicker: the
   transition is the one of the state arrived at. */
:root { --portal-in: 640ms; --portal-out: 380ms; --ease-portal: cubic-bezier(.16, 1, .3, 1); }
.orb { --lid: 3.5; --orbit-gap: 2.7; display: block; position: relative; aspect-ratio: 1; border-radius: 50%; color: inherit; text-decoration: none; container-type: inline-size; -webkit-tap-highlight-color: transparent; }
.orb > [data-nts-fragment] { border-radius: 50%; --frag-bg: var(--w-bg-2); box-shadow: inset 0 0 0 1px var(--w-line); }
.orb::before { content: ""; position: absolute; inset: calc((var(--lid) + var(--orbit-gap)) * -1cqi); border-radius: 50%; border: 1px dashed var(--w-line-strong); pointer-events: none; }
.orb > [data-nts-fragment], .orb::after {
  transition: transform var(--portal-out) var(--ease-portal), opacity var(--portal-out) var(--ease-portal);
}
.orb::after { transition-timing-function: var(--ease-portal), cubic-bezier(.5, 0, .9, .4); }
.orb:is(:hover, :focus-visible, :active) > [data-nts-fragment], .orb:is(:hover, :focus-visible, :active)::after {
  transition-duration: var(--portal-in);
}
/* the focus ring follows the window, which grows as it opens */
.orb:focus-visible { outline: none; }
.orb:focus-visible > [data-nts-fragment] { outline: 2px solid var(--w-accent-text); outline-offset: 4px; }
/* the opening, an iris: the window is an aperture, the same opening as the
   world windows' own as they scroll in. At rest its limb (a hairline of
   --w-accent on .orb::after) rims the window, half a pixel past its edge
   and a pixel over it, covering the disc's own edge line and the figure's
   antialiased edge, so the rim is one clean line; the ring beyond is bare
   ground: the lid. Opened, the window widens over the
   ring (the fragment scales by the ring, the figure coming nearer with
   it), and the limb draws back over the ring until it meets the orbit,
   fading as it arrives (its opacity eases in while its scale eases out),
   so no circle is left inside the orbit but the open disc's own edge.
   The orbit's gap (--orbit-gap) is in cqi of the window, like the ring, so
   the limb's scale lands on it at every width. Reduced
   motion: the limb only fades. */
.orb::after { content: ""; position: absolute; inset: -.5px; border-radius: 50%; border: 1.5px solid color-mix(in srgb, var(--w-accent) 65%, var(--w-bg)); pointer-events: none; }
.orb:is(:hover, :focus-visible, :active) > [data-nts-fragment] { transform: scale(calc(1 + var(--lid) / 50)); }
.orb:is(:hover, :focus-visible, :active)::after { transform: scale(calc(1 + (var(--lid) + var(--orbit-gap)) / 50)); opacity: 0; }
@media (prefers-reduced-motion: reduce) {
  .orb:is(:hover, :focus-visible, :active) > [data-nts-fragment], .orb:is(:hover, :focus-visible, :active)::after { transform: none; }
}
.world .prose { width: 100%; }
.world .prose h2 { margin-bottom: .8rem; }
.world[data-world="embers"] h2 { font-family: var(--font-flyer); font-variation-settings: "wdth" 125; font-weight: 700; text-transform: uppercase; letter-spacing: .02em; text-shadow: var(--embers-glow); }
.world[data-world="philo"] h2 .philo-key { --philo-off: .045em; }
.world[data-world="intersect"] { font-family: var(--font-intersect); font-size: 1.15rem; }
.world[data-world="intersect"] .go { font-family: var(--font-mono); letter-spacing: .1em; }
@media (min-width: 900px) { .handover { height: 4.5rem; } .tuesdays.sect { padding-bottom: calc(var(--section) * .55); } }
@media (min-width: 760px) {
  .world-grid { grid-template-columns: minmax(0, 22rem) minmax(0, 1fr); align-items: center; column-gap: clamp(2.5rem, 6vw, 5rem); }
  .world { --bloom-at: 22% 50%; }
  .orb-stage { width: 100%; }
}

/* scrolling travels: as a world comes into view its
   ground blooms out from the body, and its words arrive; the body itself
   stays at full size. Scroll-driven, so it never takes the scroll away. Only with scripts (html.js), so a
   page rendered without a scroll position, with scripts off or on paper,
   has every world simply there. */
@supports (animation-timeline: view()) {
  .js .world::before { animation: bloom linear both; animation-timeline: view(); animation-range: entry 0% entry 70%; }
  .js .world .prose { animation: arrive linear both; animation-timeline: view(); animation-range: entry 0% entry 85%; }
}
@media print { .world::before, .world .prose, .pivot, .pivot > * { animation: none !important; } .world::before { clip-path: none; } }
@keyframes bloom { from { clip-path: circle(0% at var(--bloom-at)); } to { clip-path: circle(150% at var(--bloom-at)); } }
@keyframes arrive { from { opacity: 0; transform: translateY(16px); } 55% { opacity: 1; } to { opacity: 1; transform: none; } }

/* ---------- the trace of the orbit on the world pages ---------- */
/* dashed ring inside the entity's box, under the figure: -2 stays inside the hero's stacking context */
.hero .entity { position: relative; --ring: calc(min(100%, 92svh) - var(--ring-inset)); }
.trace { z-index: -2; position: absolute; left: 50%; top: 50%; width: var(--ring); aspect-ratio: 1; translate: -50% -50%; pointer-events: none; }
.trace .trace-ring { position: absolute; inset: 0; border-radius: 50%; border: 1px dashed var(--w-line-strong); }
.events-hero { padding-bottom: 0; }
.events-hero .entity { display: grid; place-items: center; }
.events-hero .mini-orrery { position: relative; width: min(64%, 13rem); aspect-ratio: 1; display: grid; place-items: center; margin: 1.5rem auto 2.5rem; container-type: inline-size; }
/* the sun: a black sun with a bone sigil */
.events-hero .mini-orrery .sun-disc { position: absolute; left: 32%; top: 32%; width: 36%; height: 36%; border-radius: 50%; background: var(--pal-ink); }
.events-hero .mini-orrery > .nts-sigil { position: relative; width: 24%; height: 24%; color: var(--pal-bone); }
.events-hero .mini-ring { position: absolute; inset: calc(50% - var(--r)); border-radius: 50%; border: 1px dashed var(--w-line); }
.events-hero .mini-orrery .pivot > a { pointer-events: auto; }
.events-hero .mini-orrery .trace-bead { width: 2.75rem; height: 2.75rem; margin: -1.375rem 0 0 -1.375rem; transition: translate var(--dur-lift) var(--ease-lift); }
/* the lift uses the individual `translate` property: the orbit animation owns `transform`, and `translate` composes with it, so it works moving or still */
.events-hero .mini-orrery a.trace-bead:hover, .events-hero .mini-orrery a.trace-bead:focus-visible { translate: 0 var(--lift-y); }
.events-hero .o1, .events-hero .ring-1 { --r: 26cqi; --a: var(--a-embers); --p: var(--p-embers); }
.events-hero .o2, .events-hero .ring-2 { --r: 38cqi; --a: var(--a-philo); --p: var(--p-philo); }
.events-hero .o3, .events-hero .ring-3 { --r: 50cqi; --a: var(--a-intersect); --p: var(--p-intersect); }
@media (min-width: 900px) { .events-hero .mini-orrery { width: min(100%, 18rem); } }

/* ---------- falling in: cross-document view transitions ---------- */
@view-transition { navigation: auto; }
.nts-header { view-transition-name: nts-header; }
.nts-mark { view-transition-name: nts-mark; }
/* The old root snapshot stays fully opaque and the new one fades in on it:
   a fading pair is see-through in the middle, and Safari paints a dark
   backdrop behind it that washes the whole screen grey. Root, header and the
   current page's bar share one timing, 520ms on the site's ease-out; T10 in
   tests/transitions/nav-mark.spec.mjs keeps them in step. */
::view-transition-old(root) { animation: none; }
::view-transition-new(root) { animation: vt-in 520ms var(--ease-out) both; }
::view-transition-group(orb) { animation-duration: 640ms; animation-timing-function: var(--ease-out); }
::view-transition-old(orb), ::view-transition-new(orb) { animation-duration: 640ms; animation-timing-function: var(--ease-out); height: 100%; object-fit: contain; }
/* The header stays put and crosses with the root. Its bar is see-through, so
   the old image must leave as the new one comes, or it shows through it and
   cuts at the end; the group's `animation: none` would hand its 0s down to
   the pair, so the pair's timing is set on the images, and the pair
   crossfades (the UA's plus-lighter fade). The current page's bar
   (nts-mark) travels on the same timing, stretched by nts-head.js, or fades
   to or from a page with no current link. */
::view-transition-group(nts-header) { animation: none; }
::view-transition-old(nts-header), ::view-transition-new(nts-header) { animation-duration: 520ms; animation-timing-function: var(--ease-out); animation-fill-mode: both; }
::view-transition-group(nts-mark) { animation-duration: 520ms; animation-timing-function: var(--ease-out); }
/* the images fill the group: at their default auto height a bar stretched
   across two links would scale up, thick and blurred */
::view-transition-old(nts-mark), ::view-transition-new(nts-mark) { height: 100%; }
@keyframes vt-in { from { opacity: 0; } }

/* ---------- reduced motion: the sky stands still, every world is there ---------- */
@media (prefers-reduced-motion: reduce) {
  .pivot, .pivot > * { animation: none !important; }
  .world::before, .world .prose { animation: none !important; }
  .world::before { clip-path: none; }
  .bead:hover .face, .bead:focus-visible .face { transform: none; }
  .events-hero .mini-orrery a.trace-bead:hover, .events-hero .mini-orrery a.trace-bead:focus-visible { translate: none; }
  ::view-transition-group(*), ::view-transition-old(*), ::view-transition-new(*) { animation: none !important; }
}
