diff --git a/apps/site/package.json b/apps/site/package.json
index eb0b627..8644fac 100644
--- a/apps/site/package.json
+++ b/apps/site/package.json
@@ -10,7 +10,7 @@
     "preview": "wrangler dev"
   },
   "dependencies": {
-    "@northguild/gmt": "^1.19.0",
+    "@northguild/gmt": "^1.20.0",
     "@northguild/theme": "workspace:*",
     "astro": "7.2.7"
   },
diff --git a/apps/site/src/components/Aurora.astro b/apps/site/src/components/Aurora.astro
index cae7ade..7f93999 100644
--- a/apps/site/src/components/Aurora.astro
+++ b/apps/site/src/components/Aurora.astro
@@ -5,6 +5,10 @@ import {
   compass,
   coords,
 } from "../scripts/aurora.sites";
+// The installed @northguild/gmt's version, read at build time so the footer
+// follows every upgrade. The package does not export its package.json, so
+// it is read by path; only the version string reaches the page.
+import { version as gmtVersion } from "../../node_modules/@northguild/gmt/package.json";
 ---
 
 <div class="aurora" aria-hidden="true">
@@ -63,6 +67,55 @@ import {
           Looking {compass(site.heading)} from {site.spot}.{" "}
           {coords(site.lat, site.lon)}, eye height {site.eye}&nbsp;m.
         </p>
+        <ul class="sky-times" aria-label="Sun and moon in this window">
+          <li data-body="sun">
+            <svg viewBox="0 0 24 24" aria-hidden="true">
+              <circle cx="12" cy="12" r="4.25" fill="currentColor"></circle>
+              <path
+                d="M12 2.5v3M12 18.5v3M2.5 12h3M18.5 12h3M5.3 5.3l2.1 2.1M16.6 16.6l2.1 2.1M5.3 18.7l2.1-2.1M16.6 7.4l2.1-2.1"
+                fill="none"
+                stroke="currentColor"
+                stroke-width="1.6"
+                stroke-linecap="round"></path>
+            </svg>
+            <span class="body">Sun</span>
+            <span class="when">Looking ahead…</span>
+          </li>
+          <li data-body="halo">
+            <svg viewBox="0 0 24 24" aria-hidden="true">
+              <circle cx="12" cy="13" r="2.6" fill="currentColor"></circle>
+              <circle
+                cx="12"
+                cy="13"
+                r="7.6"
+                fill="none"
+                stroke="currentColor"
+                stroke-width="1.3"
+                stroke-dasharray="3.2 1.6"
+                opacity="0.8"></circle>
+              <path
+                d="M12 1.5v7.2"
+                stroke="currentColor"
+                stroke-width="1.6"
+                stroke-linecap="round"></path>
+            </svg>
+            <span class="body">Solar halo / pillar</span>
+            <span class="when">Looking ahead…</span>
+          </li>
+          <li data-body="moon">
+            <svg viewBox="0 0 24 24" aria-hidden="true">
+              <circle class="dark" cx="12" cy="12" r="8"></circle>
+              <path class="lit" fill="currentColor"></path>
+            </svg>
+            <span class="body">Moon</span>
+            <span class="when">Looking ahead…</span>
+            <span class="phase"></span>
+          </li>
+          <li class="note">
+            When each shows in this window, in your time zone<span class="zone"
+            ></span>.
+          </li>
+        </ul>
         <p>
           It is always night here, but the stars, planets, moon and sun are
           where they really are right now, above the real {site.ground}. The
@@ -89,9 +142,13 @@ import {
       ))
     }
   </dl>
+  <p class="sky-footer">
+    Site runs on <a href="/gmt/">@northguild/gmt</a> v{gmtVersion}
+  </p>
 </div>
 
 <script>
+  import type { SiteTimes } from "../scripts/aurora.ahead";
   import type {
     AuroraMessage,
     SkyLabel,
@@ -161,6 +218,8 @@ import {
         if (typeof data === "object") {
           if ("pick" in data) {
             label(data.pick);
+          } else if ("times" in data) {
+            showTimes(data.times, data.zone);
           } else {
             site = data.site;
             show();
@@ -199,6 +258,54 @@ import {
     }
   }
 
+  // Sun and moon times: the worker works them out while the popover is open
+  // (and from a hover or focus on its button, for a head start).
+  const R = 8;
+  /** The moon's lit part for its age (0 new, π full), lit on the right while
+   * waxing, as seen from the north. */
+  const litPath = (age: number) => {
+    const waxing = age < Math.PI;
+    const crescent = Math.cos(age) > 0;
+    const rx = (R * Math.abs(Math.cos(age))).toFixed(2);
+    const limb = waxing ? 1 : 0;
+    const terminator = waxing === crescent ? 0 : 1;
+    return `M12 ${12 - R}A${R} ${R} 0 0 ${limb} 12 ${12 + R}A${rx} ${R} 0 0 ${terminator} 12 ${12 - R}Z`;
+  };
+  const showTimes = (all: SiteTimes[], zone: string) => {
+    for (const el of document.querySelectorAll(".sky-times .zone")) {
+      el.textContent = zone ? ` (${zone})` : "";
+    }
+    all.forEach((times, i) => {
+      const section = sections[i];
+      if (!section) return;
+      for (const body of ["sun", "halo", "moon"] as const) {
+        const row = section.querySelector(`[data-body="${body}"]`);
+        const when = row?.querySelector(".when");
+        if (!row || !when) continue;
+        when.textContent = times[body].when;
+        row.classList.toggle("now", times[body].now);
+      }
+      const moon = section.querySelector('[data-body="moon"]');
+      moon?.querySelector(".phase")?.replaceChildren(times.moon.phase);
+      moon?.querySelector(".lit")?.setAttribute("d", litPath(times.moon.age));
+    });
+  };
+  const popover = document.querySelector<HTMLElement>("#sky-info");
+  const want = (yes: boolean) => post?.({ type: "times", want: yes });
+  popover?.addEventListener("toggle", (event) =>
+    want((event as ToggleEvent).newState === "open"),
+  );
+  for (const type of ["pointerenter", "focus"]) {
+    info?.addEventListener(type, () => want(true));
+  }
+  // Leaving the button without opening the popover stops the search. Focus
+  // moving into the open popover keeps it.
+  for (const type of ["pointerleave", "blur"]) {
+    info?.addEventListener(type, () => {
+      if (!popover?.matches(":popover-open")) want(false);
+    });
+  }
+
   // Tooltips: over bare sky the page asks the worker what is drawn under the
   // pointer (at most once a frame) and names it.
   const tip = document.querySelector<HTMLElement>(".sky-tip");
@@ -561,4 +668,70 @@ import {
   .sky-info dd {
     margin: 0;
   }
+
+  /* Sun and moon: icon, name, then when; the moon's phase on a line below.
+     A body in view now is lit in cyan. */
+  .sky-times {
+    display: grid;
+    gap: 0.5rem;
+    margin: 0 0 0.6rem;
+    padding: 0.5rem 0;
+    list-style: none;
+    border-block: 1px solid var(--gmt-hairline);
+  }
+  /* The icon beside the name, and the times (and phase) under the name. */
+  .sky-times li {
+    display: grid;
+    grid-template-columns: 1.1rem 1fr;
+    column-gap: 0.5rem;
+    align-items: start;
+  }
+  .sky-times .when {
+    grid-column: 2;
+  }
+  .sky-times svg {
+    width: 1.1rem;
+    height: 1.1rem;
+    margin-top: 0.05rem;
+    color: var(--gmt-ice);
+  }
+  .sky-times .dark {
+    fill: color(from var(--gmt-ice) srgb r g b / 0.08);
+    stroke: color(from var(--gmt-ice) srgb r g b / 0.35);
+    stroke-width: 1;
+  }
+  .sky-times .body {
+    color: var(--gmt-ice);
+  }
+  .sky-times .phase {
+    grid-column: 2;
+  }
+  .sky-times .phase:empty {
+    display: none;
+  }
+  .sky-times li.now svg,
+  .sky-times li.now .when {
+    color: var(--gmt-cyan);
+  }
+  /* A quiet footer under the credits. */
+  .sky-info .sky-footer {
+    margin: 0.6rem 0 0;
+    padding-top: 0.5rem;
+    border-top: 1px solid var(--gmt-hairline);
+  }
+  .sky-footer a {
+    color: var(--gmt-ice);
+    text-decoration-color: var(--gmt-hairline);
+    text-underline-offset: 0.2em;
+  }
+  .sky-footer a:hover,
+  .sky-footer a:focus-visible {
+    color: var(--gmt-cyan);
+  }
+
+  .sky-times li.note {
+    display: block;
+    margin-top: 0.1rem;
+    opacity: 0.7;
+  }
 </style>
diff --git a/apps/site/src/components/Header.astro b/apps/site/src/components/Header.astro
index 57e11f8..4380700 100644
--- a/apps/site/src/components/Header.astro
+++ b/apps/site/src/components/Header.astro
@@ -33,7 +33,10 @@ const links = [
 </header>
 
 <style>
+  /* A light frost: what is behind (stars, constellation lines) shows through
+     softened instead of vanishing. */
   .site-header {
+    --gmt-blur: 4px;
     position: sticky;
     top: 0;
     z-index: 10;
diff --git a/apps/site/src/components/RepoCard.astro b/apps/site/src/components/RepoCard.astro
index 18cd304..704788c 100644
--- a/apps/site/src/components/RepoCard.astro
+++ b/apps/site/src/components/RepoCard.astro
@@ -22,6 +22,8 @@ const { name, description, docsHref, githubHref } = Astro.props;
      soft glow fades in around the card, on the theme's enter timing. Going
      back is quicker, so moving between cards never leaves a trail. */
   .repo-card {
+    /* A light frost, as on the header: the sky shows through softened. */
+    --gmt-blur: 4px;
     border: 1px solid var(--gmt-border);
     display: flex;
     flex-direction: column;
diff --git a/apps/site/src/scripts/aurora.ahead.ts b/apps/site/src/scripts/aurora.ahead.ts
new file mode 100644
index 0000000..4f45cc5
--- /dev/null
+++ b/apps/site/src/scripts/aurora.ahead.ts
@@ -0,0 +1,233 @@
+// When the sun and moon next show in this window, from each site: the worker
+// steps ahead through time and asks, at each step, whether the body is up,
+// clear of the skyline and inside the frame, skipping ahead while it is far. All clock reading, arithmetic
+// and formatting goes through @northguild/gmt, in the visitor's own time zone.
+
+import {
+  addUnix,
+  endOfUnix,
+  areUnixEqualBy,
+  formatCalendarUnix,
+  formatUnix,
+  roundUnix,
+  totalDuration,
+} from "@northguild/gmt";
+import type { Site } from "./aurora.sites";
+import { sunAndMoon, type Vec3 } from "./aurora.sky";
+
+/** One body's next spell in view, as text: `now` when it is in view already. */
+export type BodyTimes = { now: boolean; when: string };
+/** The moon also brings its phase at that time, and its age (0 new, π full)
+ * for the icon. */
+export type MoonTimes = BodyTimes & { phase: string; age: number };
+/** The sun, its halo or pillar (which can show while the disc is behind the
+ * mountains), and the moon. */
+export type SiteTimes = { sun: BodyTimes; halo: BodyTimes; moon: MoonTimes };
+
+/** What one site's view shows on a screen this size. Each test returns 0
+ * when the thing shows, otherwise a lower bound on the angle (radians) the
+ * sky must still turn through before it can, or a tiny positive number when
+ * it is close. */
+export type Seer = {
+  /** Any part of a disc (centre d, angular radius r) in frame and clear of
+   * the skyline, while its centre is above `above` (radians). */
+  disc: (d: Vec3, r: number, above: number) => number;
+  /** The sun's pillar where it is drawn at half strength or more (a sun
+   * below about 4°, the 2° above it; 1° of that at least), or a quarter of
+   * its 22° halo while its disc (radius r) shows too: in frame and clear of
+   * the skyline, while the sun is up (as the sky draws them). */
+  halo: (sun: Vec3, r: number) => number;
+};
+
+const LOCAL = { timeZone: "local" } as const;
+// The panel is English (the page is lang="en"), so its dates are too: the
+// visitor's first English locale, for their 12- or 24-hour clock, else
+// British English. Their time zone stays their own.
+const LOCALE =
+  (typeof navigator === "undefined" ? [] : navigator.languages).find((l) =>
+    l.toLowerCase().startsWith("en"),
+  ) ?? "en-GB";
+/** An ISO 8601 duration (a constant, so always valid) in milliseconds. */
+const ms = (iso: string) => totalDuration(iso, "milliseconds")!;
+const HOUR = ms("PT1H");
+// No point on the sky moves faster than 15° an hour as the earth turns; the
+// moon adds about half a degree. So a body this far from the frame cannot
+// reach it sooner than angle / RATE, and the search skips ahead that much.
+const RATE = (16 * Math.PI) / 180 / HOUR;
+// Near the frame, a step a minute, so even the briefest spell (the sun
+// peeking between peaks) is caught; each edge is then refined by halving.
+const STEP = ms("PT1M");
+const EDGE = ms("PT10S");
+// Steps per slice, so the sky keeps drawing while we look.
+const SLICE = 1500;
+// How high the sun must be seen to count: the sky fades the sun, its halo
+// and its pillar in as its seen height (y, lifted by refraction) goes from
+// -0.0047 to 0.0347 (sun() in aurora.shaders.ts), and they count from half
+// strength, y = 0.015, about 0.86° up. Lower, they are drawn too faintly.
+export const SUN_UP = Math.asin(0.015);
+
+/** The first moment in (a, b] that seen() holds, given it fails at a and
+ * holds at b. */
+function edge(seen: (ms: number) => boolean, a: number, b: number): number {
+  while (b - a > EDGE) {
+    const mid = Math.floor((a + b) / 2);
+    if (seen(mid)) b = mid;
+    else a = mid;
+  }
+  return b;
+}
+
+/** The next spell in view from `from`: [start, end], with start = from when
+ * already in view and end null when it lasts longer than `longest`; null
+ * when none starts before `until`. Yields between slices. */
+function* spell(
+  away: (ms: number) => number,
+  from: number,
+  until: number,
+  longest: number,
+): Generator<void, [number, number | null] | null> {
+  const seen = (ms: number) => away(ms) === 0;
+  let n = 0;
+  let t = from;
+  let far = away(t);
+  if (far > 0) {
+    for (;;) {
+      const next = t + Math.max(STEP, Math.ceil(far / RATE));
+      if (next > until) return null;
+      const then = away(next);
+      if (then === 0) {
+        t = edge(seen, t, next);
+        break;
+      }
+      [t, far] = [next, then];
+      if (++n % SLICE === 0) yield;
+    }
+  }
+  const start = t;
+  const gone = (ms: number) => !seen(ms);
+  const cap = start + longest;
+  while (t < cap) {
+    const next = t + STEP;
+    if (gone(next)) return [start, edge(gone, t, next)];
+    t = next;
+    if (++n % SLICE === 0) yield;
+  }
+  return [start, null];
+}
+
+const PRINCIPAL = ["New moon", "First quarter", "Full moon", "Last quarter"];
+const BETWEEN = [
+  "Waxing crescent",
+  "Waxing gibbous",
+  "Waning gibbous",
+  "Waning crescent",
+];
+
+/** Phase name and how much is lit, e.g. "Waxing gibbous, 78% lit". The
+ * principal phases hold within 7° of elongation, about half a day. */
+function phaseText(age: number, lit: number): string {
+  const deg = (age * 180) / Math.PI;
+  const quarter = Math.round(deg / 90);
+  const name =
+    Math.abs(deg - quarter * 90) < 7
+      ? PRINCIPAL[quarter % 4]!
+      : BETWEEN[Math.floor(deg / 90) % 4]!;
+  return `${name}, ${Math.round(lit * 100)}% lit`;
+}
+
+const capital = (text: string) =>
+  text.charAt(0).toLocaleUpperCase() + text.slice(1);
+
+/** "today at 21:40", "tomorrow at 02:10", "in 3 days at …", then a date. */
+const day = (ms: number, now: number) =>
+  formatCalendarUnix(ms, LOCALE, { ...LOCAL, reference: now });
+
+/** The time alone when it falls on the same local day as `ref`. */
+const until = (ms: number, ref: number, now: number) =>
+  areUnixEqualBy(ms, ref, "day", LOCAL)
+    ? formatUnix(ms, LOCALE, { ...LOCAL, timeStyle: "short" })
+    : day(ms, now);
+
+function describe(
+  found: [number, number | null] | null,
+  now: number,
+): BodyTimes {
+  if (!found) return { now: false, when: "Not in view in the coming year" };
+  const minute = (ms: number) =>
+    roundUnix(ms, { smallestUnit: "minute", ...LOCAL }) ?? ms;
+  const [start, end] = found;
+  if (start === now) {
+    return {
+      now: true,
+      when: end
+        ? `In view now, until ${until(minute(end), now, now)}`
+        : "In view now",
+    };
+  }
+  const from = minute(start);
+  return {
+    now: false,
+    when: end
+      ? `${capital(day(from, now))} – ${until(minute(end), from, now)}`
+      : capital(day(from, now)),
+  };
+}
+
+/** For each site, when the sun and moon are next in view; returns the times
+ * and the moment they next need working out again: when a spell starts or
+ * ends, just after local midnight (so "today" and "tomorrow" stay true), and
+ * at least hourly. Yields between slices of the search. */
+export function* lookAhead(
+  sites: Site[],
+  seers: Seer[],
+  now: number,
+): Generator<void, { times: SiteTimes[]; next: number }> {
+  // A year ahead on the calendar; on bad input, no search at all.
+  const year = addUnix(now, { years: 1 }, LOCAL) ?? now;
+  const longest = ms("P2D");
+  const midnight = (endOfUnix(now, "day", LOCAL) ?? now + HOUR) + 1;
+  let next = Math.min(now + HOUR, midnight);
+  const times: SiteTimes[] = [];
+  for (const [i, site] of sites.entries()) {
+    const see = seers[i]!;
+    const sun = yield* spell(
+      (ms) => {
+        const at = sunAndMoon(site, ms);
+        return see.disc(at.sun, at.sunRadius, SUN_UP);
+      },
+      now,
+      year,
+      longest,
+    );
+    const halo = yield* spell(
+      (ms) => {
+        const at = sunAndMoon(site, ms);
+        return see.halo(at.sun, at.sunRadius);
+      },
+      now,
+      year,
+      longest,
+    );
+    const moon = yield* spell(
+      (ms) => {
+        const at = sunAndMoon(site, ms);
+        return see.disc(at.moon, at.moonRadius, -Math.PI / 2);
+      },
+      now,
+      year,
+      longest,
+    );
+    for (const found of [sun, halo, moon]) {
+      for (const ms of found ?? []) {
+        if (ms !== null && ms > now && ms < next) next = ms;
+      }
+    }
+    const { age, lit } = sunAndMoon(site, moon?.[0] ?? now);
+    times.push({
+      sun: describe(sun, now),
+      halo: describe(halo, now),
+      moon: { ...describe(moon, now), phase: phaseText(age, lit), age },
+    });
+  }
+  return { times, next };
+}
diff --git a/apps/site/src/scripts/aurora.shaders.ts b/apps/site/src/scripts/aurora.shaders.ts
index e8c7b55..15ae63d 100644
--- a/apps/site/src/scripts/aurora.shaders.ts
+++ b/apps/site/src/scripts/aurora.shaders.ts
@@ -168,7 +168,7 @@ vec3 moon(vec3 rd) {
   float cm = dot(rd, uMoon.xyz);
   // Daylight washes the moon out: half as bright while the sun is up, so the
   // sun always outshines it.
-  float washed = 1.0 - 0.5 * smoothstep(-0.0145, 0.03, uSun.y);
+  float washed = 1.0 - 0.5 * smoothstep(-0.0047, 0.0347, uSun.y);
   // The same soft glow as the sun's, as strong as the moon is full and lit.
   float full = (0.5 - 0.5 * dot(uSun, uMoon.xyz)) * sunlit(-uMoon.xyz);
   float a = acos(clamp(cm, -1.0, 1.0));
@@ -204,7 +204,9 @@ vec3 moon(vec3 rd) {
 // Halo colours run in the theme's order where real ones run red to blue.
 const float HALO = 0.3840;  // 22° halo radius
 vec3 sun(vec3 rd) {
-  float up = smoothstep(-0.0145, 0.03, uSun.y);
+  // uSun is where the sun is seen (lifted by refraction): it shows from its
+  // upper limb on the horizon, its centre a semi-diameter (0.27°) below.
+  float up = smoothstep(-0.0047, 0.0347, uSun.y);
   if (up <= 0.0) return vec3(0.0);
   float cs = dot(rd, uSun);
   float a = acos(clamp(cs, -1.0, 1.0));
@@ -386,8 +388,21 @@ uniform float uPx, uT, uLimit, uFade;
 // 1 for planets, which hardly twinkle.
 uniform float uSteady;
 varying vec3 vCol;
+// Atmospheric refraction: the direction lifted as it is seen, same azimuth.
+// NOAA's formula, as lift() in aurora.sky.ts.
+vec3 lift(vec3 w) {
+  float e = degrees(asin(clamp(w.y, -1.0, 1.0)));
+  float h = length(w.xz);
+  if (e > 85.0 || h < 1e-6) return w;
+  float t = tan(radians(e));
+  float r = e > 5.0 ? 58.1 / t - 0.07 / (t * t * t) + 0.000086 / pow(t, 5.0)
+    : e > -0.575 ? 1735.0 + e * (-518.2 + e * (103.4 + e * (-12.79 + e * 0.711)))
+    : -20.774 / t;
+  float a = radians(e + r / 3600.0);
+  return vec3(w.xz.x * cos(a) / h, sin(a), w.xz.y * cos(a) / h);
+}
 void main() {
-  vec3 w = uStars * aDir;
+  vec3 w = lift(uStars * aDir);
   float alt = w.y;
   float m = aMag.x + 0.12 * (1.0 / (max(alt, 0.0) + 0.04) - 1.0);
   float b = pow(2.512, -m);
diff --git a/apps/site/src/scripts/aurora.sky.ts b/apps/site/src/scripts/aurora.sky.ts
index c6508d7..0937ea0 100644
--- a/apps/site/src/scripts/aurora.sky.ts
+++ b/apps/site/src/scripts/aurora.sky.ts
@@ -6,6 +6,8 @@
 // need). The planets use JPL's mean Keplerian elements (good to a few arcminutes over
 // 1800–2050) and Meeus ch. 41 for their brightness.
 
+import { convertUnixToUtc, getUnixNow, totalDuration } from "@northguild/gmt";
+import { taiMinusUtc } from "@northguild/gmt/timescale";
 import type { Site } from "./aurora.sites";
 
 export type Mat3 = [
@@ -24,11 +26,16 @@ export type Vec3 = [number, number, number];
 const RAD = Math.PI / 180;
 const ARCSEC = RAD / 3600;
 
-const julian = (ms: number) => ms / 86400000 + 2440587.5;
-// Terrestrial time runs ΔT ahead of the clock (UTC): 32.184 s plus 37 leap
-// seconds since 2017. The moon moves half an arcsecond a second, so the
-// orbit formulas need it.
-const DELTA_T = 69.184;
+// Julian day from epoch milliseconds: day 2440587.5 began at the epoch.
+const DAY = totalDuration("P1D", "milliseconds")!;
+const julian = (ms: number) => ms / DAY + 2440587.5;
+// Terrestrial time runs ahead of the clock (UTC) by 32.184 s plus the leap
+// seconds so far (TAI − UTC, from gmt's table; read once, as none is due
+// within the year we look ahead). The moon moves half an arcsecond a second,
+// so the orbit formulas need it. In days.
+const DELTA_T =
+  (32.184 + (taiMinusUtc(convertUnixToUtc(getUnixNow() ?? 0)) ?? 37)) /
+  totalDuration("P1D", "seconds")!;
 
 /** Row-major 3×3 product a·b. */
 function mul(a: Mat3, b: Mat3): Mat3 {
@@ -430,6 +437,34 @@ function uncovered(a: number, b: number, d: number): number {
   return 1 - lens / (Math.PI * a * a);
 }
 
+/** Atmospheric refraction (degrees) for a geometric altitude (degrees):
+ * how much the air lifts what is seen there. NOAA's solar calculator formula
+ * (after Saemundsson and Bennett), about 34′ at the horizon, 9′ at 5°, 0′ at
+ * the zenith; the same one baldurpan.com uses for the sun over Ísafjörður. */
+export function refraction(alt: number): number {
+  if (alt > 85) return 0;
+  const t = Math.tan(alt * RAD);
+  const arcsec =
+    alt > 5
+      ? 58.1 / t - 0.07 / t ** 3 + 0.000086 / t ** 5
+      : alt > -0.575
+        ? 1735 + alt * (-518.2 + alt * (103.4 + alt * (-12.79 + alt * 0.711)))
+        : -20.774 / t;
+  return arcsec / 3600;
+}
+
+/** A world direction as it is seen: lifted by refraction, same azimuth.
+ * Everything drawn in the sky goes through this (stars and planets in the
+ * star shader's copy); orbits and eclipses keep the true directions. */
+export function lift(d: Vec3): Vec3 {
+  const alt = Math.asin(Math.min(1, Math.max(-1, d[1]))) / RAD;
+  const h = Math.hypot(d[0], d[2]);
+  if (alt > 85 || h < 1e-9) return d;
+  const seen = (alt + refraction(alt)) * RAD;
+  const c = Math.cos(seen) / h;
+  return [d[0] * c, Math.sin(seen), d[2] * c];
+}
+
 const normalize = (v: Vec3): Vec3 => {
   const l = Math.hypot(v[0], v[1], v[2]);
   return [v[0] / l, v[1] / l, v[2] / l];
@@ -459,11 +494,13 @@ export type Sky = {
   planets: Float32Array;
 };
 
-export function sky(site: Site, ms: number): Sky {
+/** The clock and the world frame for a site at a moment: Julian day,
+ * Julian centuries of terrestrial time (for the orbits; sidereal time uses
+ * the clock), local sidereal time, latitude, the equatorial-to-world matrix
+ * and the obliquity. */
+function frame(site: Site, ms: number) {
   const jd = julian(ms);
-  // Julian centuries of terrestrial time for the orbits; sidereal time uses
-  // the clock.
-  const t = (jd + DELTA_T / 86400 - 2451545) / 36525;
+  const t = (jd + DELTA_T - 2451545) / 36525;
   const gmst =
     (280.46061837 + 360.98564736629 * (jd - 2451545) + 0.000387933 * t * t) *
     RAD;
@@ -471,18 +508,71 @@ export function sky(site: Site, ms: number): Sky {
   const lat = site.lat * RAD;
   const hor = horizon(lat, lst);
   const eps = (23.4392911 - 0.0130042 * t) * RAD;
+  return { t, lst, lat, hor, eps };
+}
 
-  // Topocentric moon: subtract the observer's position from the geocentric one.
-  const [ml, mb, dist] = moonEcliptic(t);
-  const geo = ecliptic(ml, mb, eps).map((c) => c * dist) as Vec3;
+/** Topocentric moon (km, equatorial of date): the geocentric position less
+ * the observer's. */
+function topocentric(geo: Vec3, lat: number, lst: number): Vec3 {
   const u = Math.atan(0.99664719 * Math.tan(lat));
   const rc = 6378.14 * Math.cos(u);
   const rs = 6378.14 * 0.99664719 * Math.sin(u);
-  const topo: Vec3 = [
+  return [
     geo[0] - rc * Math.cos(lst),
     geo[1] - rc * Math.sin(lst),
     geo[2] - rs,
   ];
+}
+
+/** The sun's distance (au), for t in Julian centuries. */
+function sunDistance(t: number): number {
+  const m = (357.52911 + 35999.05029 * t) * RAD;
+  return 1.00014 - 0.01671 * Math.cos(m) - 0.00014 * Math.cos(2 * m);
+}
+
+/** The sun's angular radius (radians) from its distance. */
+function sunRadiusAt(t: number): number {
+  return (959.63 / sunDistance(t)) * ARCSEC;
+}
+
+/** Just the sun and moon, for looking ahead: world directions (lifted by
+ * refraction, as drawn) and angular radii, the moon's age as its elongation
+ * east of the sun in ecliptic longitude (0 new, π full, radians in 0..2π),
+ * and the fraction of its disc lit. */
+export function sunAndMoon(
+  site: Site,
+  ms: number,
+): {
+  sun: Vec3;
+  sunRadius: number;
+  moon: Vec3;
+  moonRadius: number;
+  age: number;
+  lit: number;
+} {
+  const { t, lst, lat, hor, eps } = frame(site, ms);
+  const [ml, mb, dist] = moonEcliptic(t);
+  const sl = sunLongitude(t);
+  const geo = ecliptic(ml, mb, eps).map((c) => c * dist) as Vec3;
+  const topo = topocentric(geo, lat, lst);
+  const age = (((ml - sl) % (2 * Math.PI)) + 2 * Math.PI) % (2 * Math.PI);
+  return {
+    sun: lift(normalize(apply(hor, ecliptic(sl, 0, eps)))),
+    sunRadius: sunRadiusAt(t),
+    moon: lift(normalize(apply(hor, topo))),
+    moonRadius: Math.asin(1737.4 / Math.hypot(...topo)),
+    age,
+    lit: (1 - Math.cos(mb) * Math.cos(age)) / 2,
+  };
+}
+
+export function sky(site: Site, ms: number): Sky {
+  const { t, lst, lat, hor, eps } = frame(site, ms);
+
+  // Topocentric moon: subtract the observer's position from the geocentric one.
+  const [ml, mb, dist] = moonEcliptic(t);
+  const geo = ecliptic(ml, mb, eps).map((c) => c * dist) as Vec3;
+  const topo = topocentric(geo, lat, lst);
   const range = Math.hypot(...topo);
   const moon = normalize(apply(hor, topo));
   const sun = normalize(apply(hor, ecliptic(sunLongitude(t), 0, eps)));
@@ -492,9 +582,8 @@ export function sky(site: Site, ms: number): Sky {
   const moonRadius = Math.asin(1737.4 / range);
 
   // Solar eclipse: how much of the sun's disc the moon leaves showing.
-  const m = (357.52911 + 35999.05029 * t) * RAD;
-  const au = 1.00014 - 0.01671 * Math.cos(m) - 0.00014 * Math.cos(2 * m);
-  const sunRadius = (959.63 / au) * ARCSEC;
+  const au = sunDistance(t);
+  const sunRadius = sunRadiusAt(t);
   const sunVisible = uncovered(
     sunRadius,
     moonRadius,
@@ -522,12 +611,14 @@ export function sky(site: Site, ms: number): Sky {
   const lit = (1 - dot(sun, moon)) / 2;
   const alt = Math.asin(moon[1]) / RAD;
   const up = Math.min(1, Math.max(0, (alt + 2) / 17));
+  // Drawn where they are seen: lifted by refraction. The eclipse geometry
+  // above keeps the true directions.
   return {
     stars: mul(hor, precession(t)),
-    moon,
+    moon: lift(moon),
     moonRadius,
     moonNorth,
-    sun,
+    sun: lift(sun),
     sunRadius,
     sunVisible,
     shadow,
diff --git a/apps/site/src/scripts/aurora.worker.ts b/apps/site/src/scripts/aurora.worker.ts
index b427d14..6b6955c 100644
--- a/apps/site/src/scripts/aurora.worker.ts
+++ b/apps/site/src/scripts/aurora.worker.ts
@@ -24,11 +24,13 @@ import {
   skyFs,
 } from "./aurora.shaders";
 import { getSystemTimeZone, getUnixNow } from "@northguild/gmt";
+import { SUN_UP, lookAhead, type Seer, type SiteTimes } from "./aurora.ahead";
 import { MOON } from "./aurora.moon";
-import { SITES } from "./aurora.sites";
+import { SITES, type Site } from "./aurora.sites";
 import {
   PLANETS,
   apply,
+  lift,
   columns,
   sky,
   type Sky,
@@ -77,7 +79,10 @@ export type AuroraMessage =
   /** What is drawn near this point (CSS pixels), within reach pixels. */
   | { type: "pick"; x: number; y: number; reach: number }
   /** The page no longer shows the last pick; stop following it. */
-  | { type: "drop" };
+  | { type: "drop" }
+  /** Whether the page wants the sun and moon times (the popover is open or
+   * about to be). */
+  | { type: "times"; want: boolean };
 
 /** One unbroken run of a constellation line in CSS pixels, [x, y, x, y, …],
  * drawn from the end nearer the hovered star; step counts lines out from it. */
@@ -109,7 +114,9 @@ export type WorkerMessage =
   | "on"
   | "off"
   | { site: number }
-  | { pick: SkyLabel | null };
+  | { pick: SkyLabel | null }
+  /** When the sun and moon next show in this window, per site in SITES order. */
+  | { times: SiteTimes[]; zone: string };
 
 const scope = self as unknown as {
   onmessage: ((event: MessageEvent<AuroraMessage>) => void) | null;
@@ -225,6 +232,165 @@ function starData(buf: ArrayBuffer): Float32Array {
   return out;
 }
 
+/** Camera basis as columns (right, up, forward), heading from north, and
+ * the tangent of half the vertical field of view. On a portrait screen the
+ * page's cards cover the middle, so the view widens and tilts until the
+ * horizon sits about a third of the way down: the aurora then shows above
+ * the cards and the land or water below them. */
+function camera(
+  site: Site,
+  width: number,
+  height: number,
+): { cam: Float32Array; tanY: number } {
+  const aspect = (width || 1) / (height || 1);
+  const portrait = Math.min(1, Math.max(0, (1 - aspect) / 0.45));
+  const fov = (site.fov + 15 * portrait) * RAD;
+  const tanY = Math.tan(fov / 2);
+  const landscape =
+    -Math.tan(site.pitch * RAD) / Math.tan((site.fov / 2) * RAD);
+  const horizon = landscape + (0.3 - landscape) * portrait;
+  const pitch = Math.atan(-horizon * tanY);
+  const yaw = site.heading * RAD;
+  const fwd = [
+    Math.sin(yaw) * Math.cos(pitch),
+    Math.sin(pitch),
+    Math.cos(yaw) * Math.cos(pitch),
+  ] as const;
+  const right = [Math.cos(yaw), 0, -Math.sin(yaw)] as const;
+  const cam = new Float32Array([
+    ...right,
+    fwd[1] * right[2] - fwd[2] * right[1],
+    fwd[2] * right[0] - fwd[0] * right[2],
+    fwd[0] * right[1] - fwd[1] * right[0],
+    ...fwd,
+  ]);
+  return { cam, tanY };
+}
+
+/** A direction to CSS pixels on a width × height screen, or null behind the
+ * camera. */
+function project(
+  view: { cam: Float32Array; tanY: number },
+  width: number,
+  height: number,
+  d: Vec3,
+): [number, number] | null {
+  const { cam, tanY } = view;
+  const w = width || 1;
+  const h = height || 1;
+  const z = d[0] * cam[6]! + d[1] * cam[7]! + d[2] * cam[8]!;
+  if (z <= 0) return null;
+  const nx =
+    (d[0] * cam[0]! + d[1] * cam[1]! + d[2] * cam[2]!) / (z * tanY * (w / h));
+  const ny = (d[0] * cam[3]! + d[1] * cam[4]! + d[2] * cam[5]!) / (z * tanY);
+  return [((nx + 1) / 2) * w, ((1 - ny) / 2) * h];
+}
+
+/** Ridge elevation by azimuth (degrees), radians; what is below it is
+ * hidden. Straight between samples, as the ridge mesh is drawn. */
+function ridgeFor(site: Site): (az: number) => number {
+  const skyline = SKYLINES[site.id];
+  if (!skyline) return () => -Math.PI / 2;
+  const elev = new Int16Array(bytes(skyline.elev).buffer);
+  return (az) => {
+    const x = (az - skyline.from) / skyline.step;
+    const i = Math.floor(x);
+    const a = elev[i] ?? elev[i + 1] ?? -9000;
+    const b = elev[i + 1] ?? a;
+    return ((a + (b - a) * (x - i)) / 100) * RAD;
+  };
+}
+
+// The 22° halo's radius, and the sun's height (its y) above which the pillar
+// is drawn at less than half strength: sun() in aurora.shaders.ts scales it
+// by 1 - smoothstep(0.03, 0.11, y), which is 0.5 at y = 0.07 (about 4°).
+const HALO = 0.384;
+const PILLAR_TOP = 0.07;
+
+/** Points around a circle of angular radius r about d (its centre too when
+ * r is small enough to be a disc), as world directions. */
+function ring(d: Vec3, r: number, n: number, centre: boolean): Vec3[] {
+  // A basis across the line of sight: level, then up the sky.
+  let e1: Vec3 = [d[2], 0, -d[0]];
+  const l = Math.hypot(e1[0], e1[2]);
+  e1 = l > 1e-9 ? [e1[0] / l, 0, e1[2] / l] : [1, 0, 0];
+  const e2: Vec3 = [
+    d[1] * e1[2] - d[2] * e1[1],
+    d[2] * e1[0] - d[0] * e1[2],
+    d[0] * e1[1] - d[1] * e1[0],
+  ];
+  const [c, s] = [Math.cos(r), Math.sin(r)];
+  const out: Vec3[] = centre ? [d] : [];
+  for (let k = 0; k < n; k++) {
+    const t = (2 * Math.PI * k) / n;
+    const [u, v] = [Math.cos(t) * s, Math.sin(t) * s];
+    out.push([
+      d[0] * c + e1[0] * u + e2[0] * v,
+      d[1] * c + e1[1] * u + e2[1] * v,
+      d[2] * c + e1[2] * u + e2[2] * v,
+    ]);
+  }
+  return out;
+}
+
+/** What a site's view shows on a width × height screen (see Seer). A point
+ * shows when it is in frame and above the skyline the ridge mesh draws. */
+function seer(site: Site, width: number, height: number): Seer {
+  const [w, h] = [width || 1, height || 1];
+  const view = camera(site, w, h);
+  const ridge = ridgeFor(site);
+  const fwd = [view.cam[6]!, view.cam[7]!, view.cam[8]!];
+  // From the middle of the frame to its corner: nothing farther is in frame.
+  const reach = Math.atan(Math.hypot(view.tanY * (w / h), view.tanY));
+  const shows = (p: Vec3) => {
+    if (Math.asin(p[1]) < ridge(Math.atan2(p[0], p[2]) / RAD)) return false;
+    const xy = project(view, w, h, p);
+    return !!xy && xy[0] >= 0 && xy[0] <= w && xy[1] >= 0 && xy[1] <= h;
+  };
+  // How far beyond `edge` of the frame's middle d is, and below `above`.
+  const far = (d: Vec3, edge: number, above: number) => {
+    const cos = d[0] * fwd[0]! + d[1] * fwd[1]! + d[2] * fwd[2]!;
+    const off = Math.acos(Math.min(1, Math.max(-1, cos)));
+    return Math.max(off - reach - edge, above - Math.asin(d[1]));
+  };
+  return {
+    disc: (d, r, above) => {
+      const gap = far(d, r, above);
+      if (gap > 0) return gap;
+      // The centre and 16 points round the rim: a sliver counts.
+      return ring(d, r, 16, true).some(shows) ? 0 : 1e-6;
+    },
+    halo: (sun, r) => {
+      const gap = far(sun, HALO, SUN_UP);
+      if (gap > 0) return gap;
+      // The ring is drawn too faintly to see on its own (and not at all over
+      // the aurora), so it counts only beside the sun's own disc, and only
+      // when a quarter of it shows (18 of 72 points, 5° apart round it).
+      if (ring(sun, r, 16, true).some(shows)) {
+        let ringShows = 0;
+        for (const p of ring(sun, HALO, 72, false)) {
+          if (shows(p) && ++ringShows >= 18) return 0;
+        }
+      }
+      // The pillar, only where it is drawn at half strength or more, like
+      // the sun: a sun below about 4°, and the 2° just above it (the shader
+      // fades it by exp(-dAlt / 0.05), a half at 2°). At least 1° of that
+      // must show: 2 of 4 points, half a degree apart.
+      if (sun[1] >= PILLAR_TOP) return 1e-6;
+      const alt = Math.asin(sun[1]);
+      const az = Math.atan2(sun[0], sun[2]);
+      let pillarShows = 0;
+      for (let k = 1; k <= 4; k++) {
+        const up = alt + k * 0.5 * RAD;
+        const c = Math.cos(up);
+        const p: Vec3 = [Math.sin(az) * c, Math.sin(up), Math.cos(az) * c];
+        if (shows(p) && ++pillarShows >= 2) return 0;
+      }
+      return 1e-6;
+    },
+  };
+}
+
 function start(init: Extract<AuroraMessage, { type: "init" }>): void {
   const { canvas } = init;
   const gl = canvas.getContext("webgl", {
@@ -354,36 +520,9 @@ function start(init: Extract<AuroraMessage, { type: "init" }>): void {
   let tilt = [0, 0];
   // Ridge elevation by azimuth (degrees), radians; what is below it is hidden.
   let ridgeAt = (_az: number) => -Math.PI / 2;
-  let cam = new Float32Array(9);
+  let cam: Float32Array = new Float32Array(9);
   let tanY = 1;
-  // Camera basis as columns (right, up, forward), heading from north. On a
-  // portrait screen the page's cards cover the middle, so the view widens and
-  // tilts until the horizon sits about a third of the way down: the aurora then
-  // shows above the cards and the land or water below them.
-  const aim = () => {
-    const aspect = (width || 1) / (height || 1);
-    const portrait = Math.min(1, Math.max(0, (1 - aspect) / 0.45));
-    const fov = (site.fov + 15 * portrait) * RAD;
-    tanY = Math.tan(fov / 2);
-    const landscape =
-      -Math.tan(site.pitch * RAD) / Math.tan((site.fov / 2) * RAD);
-    const horizon = landscape + (0.3 - landscape) * portrait;
-    const pitch = Math.atan(-horizon * tanY);
-    const yaw = site.heading * RAD;
-    const fwd = [
-      Math.sin(yaw) * Math.cos(pitch),
-      Math.sin(pitch),
-      Math.cos(yaw) * Math.cos(pitch),
-    ] as const;
-    const right = [Math.cos(yaw), 0, -Math.sin(yaw)] as const;
-    cam = new Float32Array([
-      ...right,
-      fwd[1] * right[2] - fwd[2] * right[1],
-      fwd[2] * right[0] - fwd[0] * right[2],
-      fwd[0] * right[1] - fwd[1] * right[0],
-      ...fwd,
-    ]);
-  };
+  const aim = () => ({ cam, tanY } = camera(site, width, height));
   const place = (index: number) => {
     site = SITES[index] ?? SITES[0]!;
     // Field lines climb toward magnetic south at the site's dip.
@@ -393,13 +532,7 @@ function start(init: Extract<AuroraMessage, { type: "init" }>): void {
     aim();
     const skyline = SKYLINES[site.id];
     const mesh = skyline ? ridgeMesh(skyline) : new Float32Array(0);
-    if (skyline) {
-      const elev = new Int16Array(bytes(skyline.elev).buffer);
-      ridgeAt = (az) =>
-        ((elev[Math.round((az - skyline.from) / skyline.step)] ?? -9000) /
-          100) *
-        RAD;
-    }
+    ridgeAt = ridgeFor(site);
     gl.bindBuffer(gl.ARRAY_BUFFER, ridgeBuf);
     gl.bufferData(gl.ARRAY_BUFFER, mesh, gl.STATIC_DRAW);
     ridgeCount = mesh.length / 4;
@@ -445,25 +578,18 @@ function start(init: Extract<AuroraMessage, { type: "init" }>): void {
   let figures: Record<string, number[]> = {};
   const figureOf = new Map<number, string>();
   // A direction to CSS pixels, or null behind the camera.
-  const screen = (d: Vec3): [number, number] | null => {
-    const w = width || 1;
-    const h = height || 1;
-    const z = d[0] * cam[6]! + d[1] * cam[7]! + d[2] * cam[8]!;
-    if (z <= 0) return null;
-    const nx =
-      (d[0] * cam[0]! + d[1] * cam[1]! + d[2] * cam[2]!) / (z * tanY * (w / h));
-    const ny = (d[0] * cam[3]! + d[1] * cam[4]! + d[2] * cam[5]!) / (z * tanY);
-    return [((nx + 1) / 2) * w, ((1 - ny) / 2) * h];
-  };
+  const screen = (d: Vec3) => project({ cam, tanY }, width, height, d);
   // Up and clear of the skyline.
   const clear = (d: Vec3, above: number) => {
     const alt = Math.asin(d[1]);
     return alt >= above && alt >= ridgeAt(Math.atan2(d[0], d[2]) / RAD);
   };
-  const starAt = (i: number): Vec3 => {
+  // True direction, and where it is seen (lifted by refraction, as drawn).
+  const starTrue = (i: number): Vec3 => {
     const s = starDirs!;
     return apply(now.stars, [s[i * 5]!, s[i * 5 + 1]!, s[i * 5 + 2]!]);
   };
+  const starAt = (i: number): Vec3 => lift(starTrue(i));
   // A figure's lines, counted out from the hovered star or the figure's star
   // nearest it (parts it does not reach follow on), stopping short of each
   // star and cut wherever they pass below the horizon or behind the mountains.
@@ -505,7 +631,8 @@ function start(init: Extract<AuroraMessage, { type: "init" }>): void {
     for (let k = 0; k < pairs.length; k += 2) {
       let [a, b] = [pairs[k]!, pairs[k + 1]!];
       if (step.get(b)! < step.get(a)!) [a, b] = [b, a];
-      const [da, db] = [starAt(a), starAt(b)];
+      // Along the true great circle, each point then lifted as drawn.
+      const [da, db] = [starTrue(a), starTrue(b)];
       const cos = da[0] * db[0] + da[1] * db[1] + da[2] * db[2];
       const angle = Math.acos(Math.min(1, Math.max(-1, cos)));
       if (angle <= 2 * gap) continue;
@@ -520,11 +647,11 @@ function start(init: Extract<AuroraMessage, { type: "init" }>): void {
         const f = gap + ((angle - 2 * gap) * i) / n;
         const [ka, kb] = [Math.sin(angle - f), Math.sin(f)];
         const s = Math.sin(angle);
-        const d: Vec3 = [
+        const d = lift([
           (ka * da[0] + kb * db[0]) / s,
           (ka * da[1] + kb * db[1]) / s,
           (ka * da[2] + kb * db[2]) / s,
-        ];
+        ]);
         const xy = clear(d, 0) ? screen(d) : null;
         if (!xy) {
           end();
@@ -543,7 +670,7 @@ function start(init: Extract<AuroraMessage, { type: "init" }>): void {
   let held = NOTHING;
   const planetAt = (k: number): Vec3 => {
     const p = now.planets;
-    return apply(now.stars, [p[k * 5]!, p[k * 5 + 1]!, p[k * 5 + 2]!]);
+    return lift(apply(now.stars, [p[k * 5]!, p[k * 5 + 1]!, p[k * 5 + 2]!]));
   };
   const pick = (px: number, py: number, reach: number): SkyLabel | null => {
     const w = width || 1;
@@ -576,7 +703,8 @@ function start(init: Extract<AuroraMessage, { type: "init" }>): void {
     // Fainter near the horizon, as the star shader draws it.
     const seen = (mag: number, d: Vec3) =>
       mag + 0.12 * (1 / (Math.max(d[1], 0) + 0.04) - 1) < limit;
-    consider("Sun", "", now.sun, -0.83 * RAD, SUN);
+    // Seen from its upper limb on the horizon (now.sun is lifted by refraction).
+    consider("Sun", "", now.sun, -now.sunRadius, SUN);
     consider("Moon", "", now.moon, 0, LUNA);
     PLANETS.forEach((name, k) => {
       const d = planetAt(k);
@@ -620,6 +748,39 @@ function start(init: Extract<AuroraMessage, { type: "init" }>): void {
     if (!xy) held = NOTHING;
   };
 
+  // Sun and moon times, while the page wants them: worked out fresh from the
+  // clock a slice at a time between frames, and again when a spell starts or
+  // ends, after local midnight, at least hourly, when the window changes size
+  // and when the tab is shown again (background timers can run late).
+  let wantTimes = false;
+  let timesRun = 0;
+  let timesTimer = 0;
+  const times = () => {
+    clearTimeout(timesTimer);
+    const run = ++timesRun;
+    if (!wantTimes) return;
+    const [w, h] = [width || 1, height || 1];
+    const seers = SITES.map((s) => seer(s, w, h));
+    const job = lookAhead(SITES, seers, wall());
+    const slice = () => {
+      if (run !== timesRun) return;
+      const step = job.next();
+      if (!step.done) {
+        timesTimer = self.setTimeout(slice, 0);
+        return;
+      }
+      scope.postMessage({
+        times: step.value.times,
+        zone: getSystemTimeZone(),
+      });
+      timesTimer = self.setTimeout(
+        times,
+        Math.max(step.value.next - wall(), 0) + 1000,
+      );
+    };
+    slice();
+  };
+
   const quad = (program: WebGLProgram) => {
     const a = attrib(program, "aPos", tri, 2);
     gl.drawArrays(gl.TRIANGLES, 0, 3);
@@ -827,6 +988,7 @@ function start(init: Extract<AuroraMessage, { type: "init" }>): void {
       resize();
       draw();
       follow();
+      times();
     } else if (data.type === "still") {
       still = data.still;
       stop();
@@ -835,11 +997,18 @@ function start(init: Extract<AuroraMessage, { type: "init" }>): void {
     } else if (data.type === "hidden") {
       hidden = data.hidden;
       if (hidden) stop();
-      else run();
+      else {
+        run();
+        times();
+      }
     } else if (data.type === "pick") {
       scope.postMessage({ pick: pick(data.x, data.y, data.reach) });
     } else if (data.type === "drop") {
       held = NOTHING;
+    } else if (data.type === "times") {
+      if (data.want === wantTimes) return;
+      wantTimes = data.want;
+      times();
     }
   };
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 443f4a3..dbdc0d6 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -30,8 +30,8 @@ importers:
   apps/site:
     dependencies:
       '@northguild/gmt':
-        specifier: ^1.19.0
-        version: 1.19.0
+        specifier: ^1.20.0
+        version: 1.20.0
       '@northguild/theme':
         specifier: workspace:*
         version: link:../../packages/theme
@@ -1065,8 +1065,8 @@ packages:
     peerDependencies:
       oxlint: '>=1.0.0'
 
-  '@northguild/gmt@1.19.0':
-    resolution: {integrity: sha512-RWOyb9G4z57t1wF2j7TrHivHW/MHFQHI8Ub63tWUIwhzBhf968gh84wvvBOrzc5GI36GkZbVJxOPj6Rj+ymSDA==}
+  '@northguild/gmt@1.20.0':
+    resolution: {integrity: sha512-mrykNrPuYW7fxGronTxUYhK5UDfQ66DIIA/vMuwr3wW3jBlZb4WxwG/MF7isdMcadAZJ5rCWeV90AQKq3XuNXg==}
     engines: {node: '>=22.16.0'}
 
   '@oslojs/encoding@1.1.0':
@@ -3451,7 +3451,7 @@ snapshots:
     dependencies:
       oxlint: 1.89.0
 
-  '@northguild/gmt@1.19.0':
+  '@northguild/gmt@1.20.0':
     dependencies:
       '@js-temporal/polyfill': 0.5.1