Replace the startup iris with a kaleidoscope and enlarge the app icon

The splash now gathers a mirrored field of shards into the mark, idles with
circling shards while startup finishes, and flies through the mark's centre
as before. The app icon's mark fills ~77% of the tile (was ~45%); the icon
set is generated from the new app-icon.svg.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Elijah 2026-10-31 19:32:35 -07:00
parent faab5a7e69
commit 242a1cec1b
21 changed files with 210 additions and 230 deletions

View file

@ -2,11 +2,11 @@ import { useEffect, useRef } from 'react';
import { useSettings } from '../app/settings';
/**
* The cold-start brand sequence, the same as Kaleido for TV: a closed iris lit
* from behind twists open, light catches the facets and the wordmark slides out
* of the mark. Once startup is ready the camera flies through the aperture's
* dark centre, revealing the app drawn beneath (which settles from a slight
* zoom, `html.splash-arrival`).
* The cold-start brand sequence: a kaleidoscope. A mirrored field of shards
* turns and gathers into the mark's six facets; if startup is still going,
* small shards keep circling the mark. Once startup is ready the camera flies
* through the mark's open centre, revealing the app drawn beneath (which
* settles from a slight zoom, `html.splash-arrival`).
*/
type Point = { x: number; y: number };
@ -41,73 +41,85 @@ const Emphasized = bezier(0.2, 0, 0, 1);
const EmphasizedDecelerate = bezier(0.05, 0.7, 0.1, 1);
const Standard = bezier(0.4, 0, 0.2, 1);
const InOut = bezier(0.45, 0, 0.55, 1);
// A mechanical iris: the blades gather, snap open and overshoot slightly as they lock.
const IrisOpen = bezier(0.55, 0, 0.15, 1);
const IrisTwist = bezier(0.5, 0, 0.18, 1.1);
// Applied in log space: a brief pull back, then an accelerating flight.
const Flight = bezier(0.55, -0.06, 0.8, 0.36);
const phase = (time: number, start: number, end: number) => Math.min(1, Math.max(0, (time - start) / (end - start)));
const mix = (from: number, to: number, amount: number) => from + (to - from) * amount;
const rad = (deg: number) => (deg * Math.PI) / 180;
const PALETTE = ['#C3E8D3', '#71B9B0', '#3D7C7B', '#D0A977', '#E9D8AE', '#EEF2DD'];
// The brand mark's facets, centred on its 64-unit viewport, each with the
// outward normal of its hexagon edge for the iris motion.
const FACETS = (
[
[[33, 4, 55.5, 17, 42.5, 24.5, 33, 19], '#C3E8D3'],
[[56.5, 19, 56.5, 45, 43.5, 37.5, 43.5, 26.5], '#71B9B0'],
[[55.5, 47, 33, 60, 33, 45, 42.5, 39.5], '#3D7C7B'],
[[31, 60, 8.5, 47, 21.5, 39.5, 31, 45], '#D0A977'],
[[7.5, 45, 7.5, 19, 20.5, 26.5, 20.5, 37.5], '#E9D8AE'],
[[8.5, 17, 31, 4, 31, 19, 21.5, 24.5], '#EEF2DD'],
] as [number[], string][]
).map(([pts, color], i) => {
const angle = ((-60 + 60 * i) * Math.PI) / 180;
// angle of its hexagon edge's outward normal and its centroid.
const FACETS = [
[33, 4, 55.5, 17, 42.5, 24.5, 33, 19],
[56.5, 19, 56.5, 45, 43.5, 37.5, 43.5, 26.5],
[55.5, 47, 33, 60, 33, 45, 42.5, 39.5],
[31, 60, 8.5, 47, 21.5, 39.5, 31, 45],
[7.5, 45, 7.5, 19, 20.5, 26.5, 20.5, 37.5],
[8.5, 17, 31, 4, 31, 19, 21.5, 24.5],
].map((pts, i) => {
const points: Point[] = [];
for (let k = 0; k < pts.length; k += 2) points.push({ x: pts[k] - 32, y: pts[k + 1] - 32 });
return { points, color, normal: { x: Math.cos(angle), y: Math.sin(angle) } };
const centroid = { x: points.reduce((s, p) => s + p.x, 0) / 4, y: points.reduce((s, p) => s + p.y, 0) / 4 };
return { points, centroid, color: PALETTE[i], angle: rad(-60 + 60 * i) };
});
type Facet = (typeof FACETS)[number];
// Loose shards around each facet: angle offset from the facet's normal, starting
// radius (px), size, palette offset and how far they tumble on the way in.
const SHARDS = [
{ angle: 20, radius: 170, scale: 0.42, color: 2, spin: 1.2 },
{ angle: -20, radius: 170, scale: 0.42, color: 4, spin: -1.2 },
{ angle: 36, radius: 320, scale: 0.3, color: 3, spin: 2.1 },
{ angle: -36, radius: 320, scale: 0.3, color: 1, spin: -2.1 },
{ angle: 8, radius: 420, scale: 0.2, color: 5, spin: 3 },
{ angle: -8, radius: 420, scale: 0.2, color: 5, spin: -3 },
];
// The inner hexagon traced by the facets' inner edges: the aperture the exit flies through.
const INNER_RADIUS = 13.6;
const INNER_APOTHEM = 11.8;
const INTRO_BOX = 132;
// The settled lockup is the header brand scaled up, so it reads as the same mark.
const LOCK_SCALE = 2.75;
const LOCK_BOX = 29 * LOCK_SCALE;
const LOCK_GAP = 7 * LOCK_SCALE;
// Timeline (ms): held at GATHER_END until startup is ready (at most HOLD_MAX),
// complete at INTRO_END; the slow settle runs on to TIMELINE_END.
const GATHER_END = 260;
const INTRO_END = 2260;
const TIMELINE_END = 2900;
const HOLD_MAX = 700;
const MARK_BOX = 140;
// Timeline (ms): the mark has formed at INTRO_END; the sequence then idles until startup is ready.
const INTRO_END = 1700;
const EXIT_MS = 640;
// The mark is larger than the old lockup, so it zooms less to end the flight at the same size.
const FLIGHT_ZOOM = 30;
const INK = '#090a0c';
const WORDMARK = '#F1F1F1';
const SEA_GLASS = [113, 185, 176];
const LIGHT = [238, 242, 221];
const rgba = (c: number[], a: number) => `rgba(${c[0]}, ${c[1]}, ${c[2]}, ${Math.max(0, a)})`;
interface Iris {
inward: number;
theta: number;
grow: number;
}
function irisAt(time: number): Iris {
const p = phase(time, 140, 1180);
return { inward: INNER_APOTHEM * (1 - IrisOpen(p)), theta: ((-44 * (1 - IrisTwist(p))) * Math.PI) / 180, grow: mix(0.64, 1, Emphasized(p)) };
/** A facet turned `rot` about the mark centre, shrunk and spun about its own centroid, then offset. */
function facetPath(ctx: CanvasRenderingContext2D, f: Facet, o: Point, unit: number, rot: number, scale: number, spin: number, offset: Point) {
const cr = Math.cos(rot);
const sr = Math.sin(rot);
const cs = Math.cos(spin);
const ss = Math.sin(spin);
f.points.forEach((p, i) => {
const rx = p.x - f.centroid.x;
const ry = p.y - f.centroid.y;
const x = f.centroid.x + (rx * cs - ry * ss) * scale;
const y = f.centroid.y + (rx * ss + ry * cs) * scale;
const px = o.x + (x * cr - y * sr) * unit + offset.x;
const py = o.y + (x * sr + y * cr) * unit + offset.y;
if (i === 0) ctx.moveTo(px, py);
else ctx.lineTo(px, py);
});
ctx.closePath();
}
function facetPath(ctx: CanvasRenderingContext2D, facet: (typeof FACETS)[number], iris: Iris, unit: number, o: Point) {
const c = Math.cos(iris.theta);
const s = Math.sin(iris.theta);
const k = unit * iris.grow;
facet.points.forEach((p, i) => {
const x = p.x - facet.normal.x * iris.inward;
const y = p.y - facet.normal.y * iris.inward;
const px = o.x + (x * c - y * s) * k;
const py = o.y + (x * s + y * c) * k;
/** A loose facet shape with its centroid at `pos`. */
function shardPath(ctx: CanvasRenderingContext2D, f: Facet, pos: Point, size: number, angle: number) {
const c = Math.cos(angle);
const s = Math.sin(angle);
f.points.forEach((p, i) => {
const x = p.x - f.centroid.x;
const y = p.y - f.centroid.y;
const px = pos.x + (x * c - y * s) * size;
const py = pos.y + (x * s + y * c) * size;
if (i === 0) ctx.moveTo(px, py);
else ctx.lineTo(px, py);
});
@ -116,7 +128,7 @@ function facetPath(ctx: CanvasRenderingContext2D, facet: (typeof FACETS)[number]
function hexagon(ctx: CanvasRenderingContext2D, o: Point, radius: number) {
for (let i = 0; i < 6; i++) {
const a = ((-90 + 60 * i) * Math.PI) / 180;
const a = rad(-90 + 60 * i);
const x = o.x + Math.cos(a) * radius;
const y = o.y + Math.sin(a) * radius;
if (i === 0) ctx.moveTo(x, y);
@ -125,41 +137,17 @@ function hexagon(ctx: CanvasRenderingContext2D, o: Point, radius: number) {
ctx.closePath();
}
interface Letters {
font: string;
chars: string[];
x: number[];
width: number;
cap: number;
}
function draw(ctx: CanvasRenderingContext2D, w: number, h: number, time: number, q: number, letters: Letters) {
const center = { x: w / 2, y: h / 2 };
function draw(ctx: CanvasRenderingContext2D, w: number, h: number, time: number, q: number) {
const o = { x: w / 2, y: h / 2 };
ctx.clearRect(0, 0, w, h);
const lockup = Emphasized(phase(time, 1250, 2000));
const lockWidth = LOCK_BOX + LOCK_GAP + letters.width;
const box = mix(INTRO_BOX, LOCK_BOX, lockup);
// A slow push-in keeps the settled frame alive.
const drift = 1 + 0.025 * InOut(phase(time, 1900, 2900));
let cx = mix(center.x, center.x - lockWidth / 2 + LOCK_BOX / 2, lockup);
let cy = center.y;
let zoom = 1;
let textAlpha = 1;
let textShift = 0;
let hole = 0;
if (q > 0) {
zoom = Math.exp(Math.log(52) * Flight(q));
const recenter = Standard(Math.min(1, q / 0.75));
cx = mix(cx, center.x, recenter);
cy = mix(cy, center.y, recenter);
textAlpha = 1 - Standard(phase(q, 0, 0.4));
textShift = -14 * Standard(phase(q, 0, 0.4));
hole = InOut(phase(q, 0.12, 0.5));
}
const unit = (box / 64) * drift * zoom;
const o = { x: cx, y: cy };
const zoom = q > 0 ? Math.exp(Math.log(FLIGHT_ZOOM) * Flight(q)) : 1;
const unit = (MARK_BOX / 64) * zoom;
const gather = Emphasized(phase(time, 0, 1450));
// The whole field turns a little less than half a revolution as it gathers.
const field = rad(-150) * (1 - Emphasized(phase(time, 0, 1550)));
// The surface: ink everywhere, with the aperture's centre cut away on exit.
const hole = InOut(phase(q, 0.12, 0.5));
ctx.globalCompositeOperation = 'source-over';
ctx.globalAlpha = 1;
ctx.fillStyle = INK;
@ -175,161 +163,121 @@ function draw(ctx: CanvasRenderingContext2D, w: number, h: number, time: number,
ctx.globalAlpha = 1;
}
const iris = irisAt(time);
const lightUp = EmphasizedDecelerate(phase(time, 0, 620));
const light = lightUp * (1 - Standard(phase(time, 620, 1250)));
const ambient = 0.03 * InOut(phase(time, 300, 900)) * (1 - Standard(phase(time, 1500, 2300)));
// Light behind the blades: a soft bloom, a hot core, and rays leaking
// through the six gaps while the iris turns.
if (light > 0.001 || ambient > 0.001) {
// The kaleidoscope's mirror lines, turning with the field.
const lines = InOut(phase(time, 0, 450)) * (1 - Standard(phase(time, 1100, 1700)));
if (lines > 0) {
ctx.lineWidth = 1;
for (let s = 0; s < 6; s++) {
const a = field + rad(-90 + 60 * s);
const end = { x: o.x + Math.cos(a) * 640, y: o.y + Math.sin(a) * 640 };
const g = ctx.createLinearGradient(o.x, o.y, end.x, end.y);
g.addColorStop(0, rgba(LIGHT, 0.2 * lines));
g.addColorStop(1, rgba(LIGHT, 0));
ctx.strokeStyle = g;
ctx.beginPath();
ctx.moveTo(o.x, o.y);
ctx.lineTo(end.x, end.y);
ctx.stroke();
}
}
const bloom = 0.09 * InOut(phase(time, 200, 1000)) * (1 - Standard(phase(time, 1500, 2600)));
if (bloom > 0.001) {
ctx.globalCompositeOperation = 'lighter';
const bloom = 250;
let g = ctx.createRadialGradient(o.x, o.y, 0, o.x, o.y, bloom);
g.addColorStop(0, rgba(SEA_GLASS, 0.16 * light + ambient));
g.addColorStop(0.45, rgba(SEA_GLASS, 0.04 * light + ambient * 0.3));
const g = ctx.createRadialGradient(o.x, o.y, 0, o.x, o.y, 300);
g.addColorStop(0, rgba(SEA_GLASS, bloom));
g.addColorStop(0.45, rgba(SEA_GLASS, bloom * 0.3));
g.addColorStop(1, rgba(SEA_GLASS, 0));
ctx.fillStyle = g;
ctx.beginPath();
ctx.arc(o.x, o.y, bloom, 0, Math.PI * 2);
ctx.arc(o.x, o.y, 300, 0, Math.PI * 2);
ctx.fill();
if (light > 0.001) {
const core = ((26 * unit) / 2.0625) * mix(0.6, 1, light);
g = ctx.createRadialGradient(o.x, o.y, 0, o.x, o.y, core);
g.addColorStop(0, `rgba(255, 250, 236, ${0.95 * light})`);
g.addColorStop(0.35, `rgba(238, 242, 221, ${0.55 * light})`);
g.addColorStop(1, 'rgba(238, 242, 221, 0)');
ctx.fillStyle = g;
ctx.beginPath();
ctx.arc(o.x, o.y, core, 0, Math.PI * 2);
ctx.fill();
const rays = light * Math.min(1, IrisOpen(phase(time, 140, 1180)) * 2.5);
for (let i = 0; i < 6; i++) {
const angle = ((-90 + 60 * i) * Math.PI) / 180 + iris.theta;
const length = mix(40, 250, lightUp) * (0.75 + 0.25 * Math.sin(i * 2.1 + 1));
const end = { x: o.x + Math.cos(angle) * length, y: o.y + Math.sin(angle) * length };
g = ctx.createLinearGradient(o.x, o.y, end.x, end.y);
g.addColorStop(0, `rgba(255, 248, 230, ${0.42 * rays})`);
g.addColorStop(0.25, `rgba(214, 236, 226, ${0.12 * rays})`);
g.addColorStop(1, 'rgba(214, 236, 226, 0)');
ctx.fillStyle = g;
ctx.beginPath();
ctx.moveTo(o.x, o.y);
ctx.lineTo(o.x + Math.cos(angle - 0.014) * length, o.y + Math.sin(angle - 0.014) * length);
ctx.lineTo(o.x + Math.cos(angle + 0.014) * length, o.y + Math.sin(angle + 0.014) * length);
ctx.closePath();
ctx.fill();
}
}
ctx.globalCompositeOperation = 'source-over';
}
// Facets. Short echoes of earlier frames act as motion blur while the
// blades turn; they disappear beneath the facets once the iris is still.
const facetAlpha = (i: number) => EmphasizedDecelerate(phase(time, 40 + i * 34, 380 + i * 34));
if (time < 1400) {
for (const [delay, alpha] of [
[84, 0.07],
[56, 0.12],
[28, 0.2],
]) {
const echo = irisAt(time - delay);
FACETS.forEach((f, i) => {
ctx.globalAlpha = alpha * facetAlpha(i);
ctx.fillStyle = f.color;
ctx.beginPath();
facetPath(ctx, f, echo, unit, o);
ctx.fill();
});
}
}
FACETS.forEach((f, i) => {
ctx.globalAlpha = facetAlpha(i);
// Shards spiral inward, faster than the field turns, and vanish into the centre.
ctx.globalCompositeOperation = 'screen';
const inward = Emphasized(phase(time, 0, 1350));
FACETS.forEach((f, s) => {
SHARDS.forEach((d, j) => {
const appear = Standard(phase(time, j * 50 + s * 25, j * 50 + s * 25 + 420));
const vanish = Standard(phase(time, 750 + j * 45, 1350 + j * 45));
if (appear <= 0 || vanish >= 1) return;
const a = f.angle + rad(d.angle) + field * 1.5;
const r = d.radius * (1 - 0.88 * inward);
ctx.globalAlpha = appear * (1 - vanish) * 0.9;
ctx.fillStyle = PALETTE[(s + d.color) % 6];
ctx.beginPath();
shardPath(ctx, f, { x: o.x + Math.cos(a) * r, y: o.y + Math.sin(a) * r }, unit * d.scale * (1 - 0.6 * vanish), field * 2 + d.spin * (1 - gather));
ctx.fill();
});
});
ctx.globalAlpha = 1;
ctx.globalCompositeOperation = 'source-over';
// The six facets ride in from the field and lock into the mark.
FACETS.forEach((f, s) => {
const r = 240 * (1 - gather);
const a = f.angle + field;
ctx.globalAlpha = Standard(phase(time, s * 25, s * 25 + 420));
ctx.fillStyle = f.color;
ctx.beginPath();
facetPath(ctx, f, iris, unit, o);
facetPath(ctx, f, o, unit, field, mix(0.55, 1, gather), rad(-60) * (1 - gather), { x: Math.cos(a) * r, y: Math.sin(a) * r });
ctx.fill();
});
ctx.globalAlpha = 1;
const sheen = phase(time, 980, 1560);
if (light > 0.01 || (sheen > 0 && sheen < 1)) {
ctx.save();
// A ring pulses out as the facets lock.
const pulse = phase(time, 1380, 2050);
if (pulse > 0 && pulse < 1) {
ctx.strokeStyle = rgba(SEA_GLASS, 0.45 * (1 - pulse));
ctx.lineWidth = 1.5;
ctx.beginPath();
FACETS.forEach((f) => facetPath(ctx, f, iris, unit, o));
ctx.clip();
// Backlight tints the blades while the core is hot, so they read as glass.
if (light > 0.01) {
const radius = (36 * unit) / 2.0625;
const g = ctx.createRadialGradient(o.x, o.y, 0, o.x, o.y, radius);
g.addColorStop(0, `rgba(255, 252, 240, ${0.26 * light})`);
g.addColorStop(1, 'rgba(255, 252, 240, 0)');
ctx.fillStyle = g;
ctx.fillRect(o.x - radius, o.y - radius, radius * 2, radius * 2);
}
// One diagonal band of light crosses the settled mark.
if (sheen > 0 && sheen < 1) {
const reach = 34 * unit;
const a = (36 * Math.PI) / 180;
const d = { x: Math.cos(a), y: Math.sin(a) };
const pos = mix(-1.25, 1.25, InOut(sheen)) * reach;
const width = 10 * unit;
const peak = 0.42 * Math.sin(Math.min(1, sheen * 1.1) * Math.PI);
const g = ctx.createLinearGradient(o.x + d.x * (pos - width), o.y + d.y * (pos - width), o.x + d.x * (pos + width), o.y + d.y * (pos + width));
g.addColorStop(0, 'rgba(255, 255, 255, 0)');
g.addColorStop(0.5, `rgba(255, 255, 255, ${peak})`);
g.addColorStop(1, 'rgba(255, 255, 255, 0)');
ctx.fillStyle = g;
ctx.fillRect(o.x - reach, o.y - reach, reach * 2, reach * 2);
}
ctx.restore();
hexagon(ctx, o, (30 + 24 * EmphasizedDecelerate(pulse)) * unit);
ctx.stroke();
}
// The wordmark slides out from behind the mark as it moves into the lockup.
if (time >= 1400 && textAlpha > 0) {
const scale = (box / LOCK_BOX) * drift;
const textLeft = cx - (box * drift) / 2 + (LOCK_BOX + LOCK_GAP) * scale;
const slide = EmphasizedDecelerate(phase(time, 1400, 2050));
const baseline = cy + (letters.cap / 2) * scale;
// Still starting: small shards keep circling the mark.
const idle = Standard(phase(time, 2300, 2900)) * (1 - phase(q, 0, 0.25));
if (idle > 0) {
ctx.globalCompositeOperation = 'screen';
ctx.globalAlpha = 0.4 * idle;
for (let s = 0; s < 6; s++) {
for (const side of [-1, 1]) {
const a = rad(-60 + 60 * s) + side * rad(11) + (time - 2300) * 0.00032;
ctx.fillStyle = PALETTE[(s + (side > 0 ? 2 : 4)) % 6];
ctx.beginPath();
shardPath(ctx, FACETS[s], { x: o.x + Math.cos(a) * 50 * unit, y: o.y + Math.sin(a) * 50 * unit }, unit * 0.16, a * 2);
ctx.fill();
}
}
ctx.globalAlpha = 1;
ctx.globalCompositeOperation = 'source-over';
}
// A band of light crosses the settled mark, then again every few seconds while it waits.
const sheen = time < 1500 ? 0 : ((time - 1500) % 3600) / 900;
if (q === 0 && sheen > 0 && sheen < 1) {
ctx.save();
ctx.beginPath();
const clipLeft = cx + 24.5 * unit + 2 * scale;
ctx.rect(clipLeft, 0, w - clipLeft, h);
FACETS.forEach((f) => facetPath(ctx, f, o, unit, 0, 1, 0, { x: 0, y: 0 }));
ctx.clip();
ctx.font = letters.font;
ctx.fillStyle = WORDMARK;
ctx.textBaseline = 'alphabetic';
letters.chars.forEach((ch, i) => {
const start = 1460 + i * 45;
const reveal = Standard(phase(time, start, start + 320));
if (reveal <= 0) return;
ctx.save();
ctx.globalAlpha = reveal * textAlpha;
ctx.translate(textLeft + (letters.x[i] - (1 - slide) * letters.width * 0.42) * scale + textShift, baseline);
ctx.scale(scale, scale);
ctx.fillText(ch, 0, 0);
ctx.restore();
});
const reach = 40 * unit;
const a = rad(36);
const d = { x: Math.cos(a), y: Math.sin(a) };
const pos = mix(-1.25, 1.25, InOut(sheen)) * reach;
const width = 10 * unit;
const peak = 0.42 * Math.sin(Math.min(1, sheen * 1.1) * Math.PI);
const g = ctx.createLinearGradient(o.x + d.x * (pos - width), o.y + d.y * (pos - width), o.x + d.x * (pos + width), o.y + d.y * (pos + width));
g.addColorStop(0, 'rgba(255, 255, 255, 0)');
g.addColorStop(0.5, `rgba(255, 255, 255, ${peak})`);
g.addColorStop(1, 'rgba(255, 255, 255, 0)');
ctx.fillStyle = g;
ctx.fillRect(o.x - reach, o.y - reach, reach * 2, reach * 2);
ctx.restore();
}
}
async function measureLetters(): Promise<Letters> {
const size = 19 * LOCK_SCALE;
const font = `700 ${size}px 'Inter Variable', 'Segoe UI', sans-serif`;
await document.fonts?.load(font).catch(() => {});
const ctx = document.createElement('canvas').getContext('2d')!;
ctx.font = font;
const tracking = 1.4 * LOCK_SCALE;
const chars = 'KALEIDO'.split('');
const x: number[] = [];
let at = 0;
for (const ch of chars) {
x.push(at);
at += ctx.measureText(ch).width + tracking;
}
return { font, chars, x, width: at - tracking, cap: size * 0.711 };
}
export function Splash({ ready, onDone }: { ready: boolean; onDone: () => void }) {
const reduced = useSettings((s) => s.reducedMotion);
const canvas = useRef<HTMLCanvasElement>(null);
@ -349,7 +297,6 @@ export function Splash({ ready, onDone }: { ready: boolean; onDone: () => void }
const ctx = el.getContext('2d')!;
let raf = 0;
let stopped = false;
let letters: Letters | null = null;
const size = () => {
const dpr = window.devicePixelRatio || 1;
el.width = Math.round(window.innerWidth * dpr);
@ -359,37 +306,29 @@ export function Splash({ ready, onDone }: { ready: boolean; onDone: () => void }
size();
window.addEventListener('resize', size);
// Timeline time advances with the clock, except while held at GATHER_END.
let last = 0;
let time = 0;
let held = 0;
let exitStart = 0;
const frame = (now: number) => {
if (stopped) return;
const dt = last ? Math.min(64, now - last) : 0;
// Clamp long frames so a stall doesn't skip the gather.
time += last ? Math.min(64, now - last) : 0;
last = now;
if (time < GATHER_END) time = Math.min(GATHER_END, time + dt);
else if (time === GATHER_END && !readyRef.current && held < HOLD_MAX) held += dt;
else time = Math.min(TIMELINE_END, time + dt);
if (!exitStart && time >= INTRO_END && readyRef.current) {
exitStart = now;
document.documentElement.classList.add('splash-arrival');
}
const q = exitStart ? Math.min(1, (now - exitStart) / EXIT_MS) : 0;
if (letters) draw(ctx, window.innerWidth, window.innerHeight, time, q, letters);
draw(ctx, window.innerWidth, window.innerHeight, time, q);
if (q >= 1) {
done.current();
return;
}
raf = requestAnimationFrame(frame);
};
// Draw the first (dark) frame at once; start the clock once the wordmark's font is ready.
ctx.fillStyle = INK;
ctx.fillRect(0, 0, window.innerWidth, window.innerHeight);
measureLetters().then((l) => {
letters = l;
if (!stopped) raf = requestAnimationFrame(frame);
});
// Draw the first (dark) frame at once so the app never shows through.
draw(ctx, window.innerWidth, window.innerHeight, 0, 0);
raf = requestAnimationFrame(frame);
return () => {
stopped = true;
cancelAnimationFrame(raf);