@johnmorrisdotca/kyogijo-stadiums 0.54.0 → 0.55.0

package/dist/circuits.race.field.d.ts

@@ -0,0 +1,26 @@
+/** A made-up team: its name in both languages, and its colour and the colour of what is written on it. */
+export interface RaceTeam {
+    id: string;
+    name: {
+        en: string;
+        ja: string;
+    };
+    colour: string;
+    ink: string;
+}
+/** A made-up driver: a three-letter code, as a timing board shows one, the name in both languages, and the team. */
+export interface RaceDriver {
+    code: string;
+    name: {
+        en: string;
+        ja: string;
+    };
+    team: string;
+}
+/** The teams, from the quickest car to the slowest (`RACE_FIELD` gives the cars of the first `n / 2`). */
+export declare const RACE_TEAMS: readonly RaceTeam[];
+/** The drivers, two to a team in the order of `RACE_TEAMS`. */
+export declare const RACE_DRIVERS: readonly RaceDriver[];
+/** The most cars a race can have, and the fewest. */
+export declare const RACE_CARS_MAX: number;
+export declare const RACE_CARS_MIN = 2;

package/dist/circuits.race.field.js

@@ -0,0 +1,41 @@
+// The made-up field of a simulated race: ten teams of two cars, every name, code and colour invented here. None is a real driver's, team's or series' (no real name, three-letter code or car number is used: a car is
+// told by its team's colour and the position it holds, written on it), and nothing of a real race's result is in it.
+/** The teams, from the quickest car to the slowest (`RACE_FIELD` gives the cars of the first `n / 2`). */
+export const RACE_TEAMS = Object.freeze([
+    { id: "kestrel", name: { en: "Kestrel Racing", ja: "ケストレル・レーシング" }, colour: "#1d4ed8", ink: "#ffffff" },
+    { id: "altair", name: { en: "Altair GP", ja: "アルタイルGP" }, colour: "#0f766e", ink: "#ffffff" },
+    { id: "basalt", name: { en: "Basalt Motorsport", ja: "バサルト・モータースポーツ" }, colour: "#db2777", ink: "#ffffff" },
+    { id: "marlin", name: { en: "Marlin Speed", ja: "マーリン・スピード" }, colour: "#c026d3", ink: "#ffffff" },
+    { id: "juniper", name: { en: "Juniper Racing Team", ja: "ジュニパー・レーシングチーム" }, colour: "#65a30d", ink: "#10151b" },
+    { id: "petrel", name: { en: "Petrel Engineering", ja: "ペトレル・エンジニアリング" }, colour: "#0ea5e9", ink: "#10151b" },
+    { id: "hanabi", name: { en: "Hanabi Racing", ja: "花火レーシング" }, colour: "#b91c1c", ink: "#ffffff" },
+    { id: "northwind", name: { en: "Northwind Motorsport", ja: "ノースウィンド・モータースポーツ" }, colour: "#94a3b8", ink: "#10151b" },
+    { id: "orrery", name: { en: "Orrery Racing", ja: "オーラリー・レーシング" }, colour: "#ca8a04", ink: "#10151b" },
+    { id: "lumen", name: { en: "Lumen Works", ja: "ルーメン・ワークス" }, colour: "#7c3aed", ink: "#ffffff" },
+].map((t) => Object.freeze(t)));
+/** The drivers, two to a team in the order of `RACE_TEAMS`. */
+export const RACE_DRIVERS = Object.freeze([
+    { code: "HLV", name: { en: "Halvorsen", ja: "ハルボルセン" }, team: "kestrel" },
+    { code: "OKF", name: { en: "Okafor", ja: "オカフォー" }, team: "kestrel" },
+    { code: "ISK", name: { en: "Ishikura", ja: "石倉" }, team: "altair" },
+    { code: "RTO", name: { en: "Rautio", ja: "ラウティオ" }, team: "altair" },
+    { code: "BRN", name: { en: "Brennan", ja: "ブレナン" }, team: "basalt" },
+    { code: "DLX", name: { en: "Delacroix", ja: "ドラクロワ" }, team: "basalt" },
+    { code: "LQV", name: { en: "Lindqvist", ja: "リンドクビスト" }, team: "marlin" },
+    { code: "CSN", name: { en: "Castellano", ja: "カステラーノ" }, team: "marlin" },
+    { code: "TKD", name: { en: "Takeda", ja: "武田" }, team: "juniper" },
+    { code: "NVK", name: { en: "Novak", ja: "ノバク" }, team: "juniper" },
+    { code: "ACB", name: { en: "Achterberg", ja: "アハテルベルグ" }, team: "petrel" },
+    { code: "KWL", name: { en: "Kowal", ja: "コワル" }, team: "petrel" },
+    { code: "ARD", name: { en: "Arcadi", ja: "アルカディ" }, team: "hanabi" },
+    { code: "ADB", name: { en: "Adebayo", ja: "アデバヨ" }, team: "hanabi" },
+    { code: "QTR", name: { en: "Quintero", ja: "キンテロ" }, team: "northwind" },
+    { code: "VRG", name: { en: "Varga", ja: "バルガ" }, team: "northwind" },
+    { code: "KUR", name: { en: "Kaur", ja: "カウル" }, team: "orrery" },
+    { code: "FNW", name: { en: "Fenwick", ja: "フェンウィック" }, team: "orrery" },
+    { code: "ESP", name: { en: "Esposito", ja: "エスポジト" }, team: "lumen" },
+    { code: "MRU", name: { en: "Moreau", ja: "モロー" }, team: "lumen" },
+].map((d) => Object.freeze({ ...d, name: Object.freeze(d.name) })));
+/** The most cars a race can have, and the fewest. */
+export const RACE_CARS_MAX = RACE_DRIVERS.length;
+export const RACE_CARS_MIN = 2;

package/dist/circuits.race.js

@@ -0,0 +1,292 @@
+// A simulated race on a circuit: about twenty made-up cars from the grid to the chequered flag over a full race distance, with gaps, overtakes, pit stops and now and then a car that retires, all from one seed. It is a
+// model and says so: each car runs the lap's speeds (`circuits.pace.ts`) a little slower or faster by its car, its fuel, its tyres and the lap, is held up behind a slower car until a straight lets it by, and stops in
+// the pit lane on the laps its strategy picks. The race is worked out once, a tenth of a second at a time, and kept as each car's distance at every second: `circuits.race.moment.ts` reads any moment of it. Pure: the
+// same options always give the same race. No real driver, team, result or time is in it.
+import { circuitOf, circuitPlan } from "./circuits.js";
+import { lineLength, nearestOn } from "./circuits.geo.js";
+import { RACE_PACE, paceProfile, pullAt, speedAt } from "./circuits.pace.js";
+import { RACE_CARS_MAX, RACE_CARS_MIN, RACE_DRIVERS, RACE_TEAMS } from "./circuits.race.field.js";
+import { FEET_PER_METRE as FT } from "./geometry.js";
+/** The distance of a race: the fewest laps that make more than 305 km, as a Grand Prix's is set. */
+export const RACE_DISTANCE = 305000;
+/** The laps of a full race distance on a circuit: 50 at Las Vegas. */
+export const raceLaps = (circuit) => Math.ceil(RACE_DISTANCE / circuit.length.value);
+/** A small generator of numbers in [0, 1) from a seed (mulberry32: whole-number arithmetic only, the same in every engine). */
+function seeded(seed) {
+    let a = (Math.trunc(seed) ^ 0x5bd1e995) >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** The model's own figures: a car's pace in shares of a lap, and the gaps it keeps. */
+const MODEL = Object.freeze({
+    /** A team is this much slower than the one before it, and its cars differ by up to this much. */
+    teamStep: 0.0025,
+    mateSpread: 0.0016,
+    /** A full tank costs this share of a lap, falling to nothing at the flag; a tyre this much more each lap it is used, and faster past `wear` laps. */
+    fuel: 0.024,
+    tyre: 0.00055,
+    wear: 24,
+    wornTyre: 0.0016,
+    /** A lap's own spread, and the chance of a lap with a mistake in it. */
+    lapNoise: 0.0042,
+    slip: 0.012,
+    slipCost: 0.016,
+    /** The tow on a straight within a second of the car in front, and the dirty air in a bend behind it. */
+    tow: 1.03,
+    dirty: 0.994,
+    /** The gap a car keeps behind one it cannot pass: metres, and metres for each metre a second. */
+    gap: 10,
+    gapPerSpeed: 0.42,
+    /** A straight is where the lap's speed is above this share of the top: a car can pass there. */
+    straight: 0.86,
+    /** The chance a car retires. */
+    retire: 0.05,
+    /** Seconds in a step of the model. */
+    dt: 0.2,
+});
+const mod = (a, n) => ((a % n) + n) % n;
+function plansOf(count, laps, random) {
+    return Array.from({ length: count }, (_, i) => {
+        const team = Math.floor(i / 2);
+        const twoStops = random() < 0.65;
+        const pits = twoStops ? [Math.round(laps * (0.26 + random() * 0.1)), Math.round(laps * (0.58 + random() * 0.1))] : [Math.round(laps * (0.42 + random() * 0.16))];
+        const stopFor = pits.map(() => 2.2 + random() * 0.9 + (random() < 0.06 ? 2 + random() * 5 : 0));
+        const noise = Array.from({ length: laps + 3 }, () => (random() - 0.5) * MODEL.lapNoise + (random() < MODEL.slip ? MODEL.slipCost : 0));
+        const outLap = random() < MODEL.retire ? 2 + Math.floor(random() * Math.max(1, laps - 4)) : 0;
+        return {
+            deficit: team * MODEL.teamStep + random() * MODEL.mateSpread,
+            reaction: 0.15 + random() * 0.25,
+            pits: laps < 4 ? [] : pits.map((p) => Math.min(laps - 1, Math.max(1, p))),
+            stopFor,
+            box: 0.3 + team * 0.045,
+            noise,
+            outLap: laps < 6 ? 0 : outLap,
+            outAt: random(),
+        };
+    });
+}
+const CACHE = new Map();
+/**
+ * A race on a circuit, worked out from a seed: made-up cars from the grid to the flag over a full race distance (50 laps of Las Vegas, about an hour and a half), with the gaps, overtakes, pit stops and retirements
+ * the model gives. The same options always give the same race; the last few asked for are kept.
+ * @example
+ * ```ts
+ * import { simulateRace } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const race = simulateRace({ circuit: "las-vegas", laps: 5, cars: 6, seed: 7 });
+ * console.log(race.laps, race.cars.length, race.flag > 5 * 90 && race.flag < 5 * 110);
+ * // 5 6 true
+ * ```
+ */
+export function simulateRace(options) {
+    const circuit = circuitOf(options.circuit);
+    const seed = Number.isFinite(options.seed) ? Math.trunc(options.seed) : 1;
+    const laps = Number.isFinite(options.laps) ? Math.min(200, Math.max(1, Math.trunc(options.laps))) : raceLaps(circuit);
+    const count = Number.isFinite(options.cars) ? Math.min(RACE_CARS_MAX, Math.max(RACE_CARS_MIN, Math.trunc(options.cars))) : RACE_CARS_MAX;
+    const key = `${circuit.id}|${seed}|${laps}|${count}`;
+    const kept = CACHE.get(key);
+    if (kept !== undefined)
+        return kept;
+    const race = run(circuit, seed, laps, count);
+    CACHE.set(key, race);
+    if (CACHE.size > 4)
+        CACHE.delete(CACHE.keys().next().value);
+    return race;
+}
+function run(circuit, seed, laps, count) {
+    const plan = circuitPlan(circuit);
+    const pace = paceProfile(plan);
+    const L = pace.length;
+    const lineAlong = plan.finish.along / FT;
+    const startAlong = plan.start.along / FT;
+    const entry = nearestOn(plan.lap, plan.pitLane[0], true).along / FT;
+    const exit = nearestOn(plan.lap, plan.pitLane[plan.pitLane.length - 1], true).along / FT;
+    const pitLength = lineLength(plan.pitLane, false) / FT;
+    const bypass = mod(exit - entry, L);
+    const hasPits = pitLength > 20 && bypass > 20;
+    const random = seeded(seed);
+    const plans = plansOf(count, laps, random);
+    // The grid: the order a lap of qualifying gives, each slot eight metres behind the one before it, the first on the start line.
+    const order = plans.map((p, i) => ({ i, q: p.deficit + random() * 0.003 })).sort((a, b) => a.q - b.q).map((x) => x.i);
+    const gridOf = new Array(count);
+    order.forEach((car, place) => (gridOf[car] = place));
+    // A lap is done at each multiple of the lap's length; the start line lies `ahead` metres past the timing line (a first lap a little short or long, as a grid makes it).
+    let ahead = mod(startAlong - lineAlong, L);
+    if (ahead > L / 2)
+        ahead -= L;
+    const cars = plans.map((_, i) => {
+        const driver = RACE_DRIVERS[i];
+        return { id: driver.code.toLowerCase(), driver, team: RACE_TEAMS.find((t) => t.id === driver.team), grid: gridOf[i] + 1 };
+    });
+    const dt = MODEL.dt;
+    const sample = 1;
+    const every = Math.round(sample / dt);
+    const cap = laps * pace.lap * 1.7 + 600;
+    const size = Math.ceil(cap / sample) + 2;
+    const distance = cars.map(() => new Float64Array(size));
+    const pit = cars.map(() => new Float32Array(size).fill(Number.NaN));
+    const crossings = cars.map(() => []);
+    const stops = cars.map(() => []);
+    const finish = cars.map(() => undefined);
+    const out = cars.map(() => undefined);
+    const s = cars.map((_, i) => ahead - 8 * gridOf[i]);
+    const v = cars.map(() => 0);
+    const mode = cars.map(() => "track");
+    const p = cars.map(() => 0);
+    const held = cars.map(() => 0);
+    const entered = cars.map(() => 0);
+    const pitIn = cars.map(() => 0);
+    const stopped = cars.map(() => false);
+    const age = cars.map(() => 0);
+    let flag = Number.NaN;
+    let quiet = Number.NaN;
+    const record = (j) => {
+        for (let c = 0; c < count; c += 1) {
+            distance[c][j] = s[c];
+            pit[c][j] = mode[c] === "pit" ? p[c] : Number.NaN;
+        }
+    };
+    record(0);
+    let steps = 0;
+    let t = 0;
+    while (t < cap) {
+        steps += 1;
+        t = steps * dt;
+        for (let c = 0; c < count; c += 1) {
+            const plan = plans[c];
+            const before = s[c];
+            const along = lineAlong + s[c];
+            if (mode[c] === "out")
+                continue;
+            if (mode[c] === "stopping") {
+                v[c] = Math.max(0, v[c] - 9 * dt);
+                s[c] += v[c] * dt;
+                if (v[c] === 0)
+                    mode[c] = "out";
+                continue;
+            }
+            if (mode[c] === "pit") {
+                if (!stopped[c] && p[c] >= plan.box * pitLength) {
+                    if (held[c] === 0)
+                        held[c] = plan.stopFor[stops[c].length];
+                    held[c] = Math.max(0, held[c] - dt);
+                    v[c] = 0;
+                    if (held[c] === 0)
+                        stopped[c] = true;
+                    else
+                        continue;
+                }
+                v[c] = v[c] > RACE_PACE.pitLimit ? Math.max(RACE_PACE.pitLimit, v[c] - RACE_PACE.brake * dt) : Math.min(RACE_PACE.pitLimit, v[c] + pullAt(v[c]) * dt);
+                p[c] += v[c] * dt;
+                s[c] = entered[c] + (Math.min(p[c], pitLength) / pitLength) * bypass;
+                if (p[c] >= pitLength) {
+                    mode[c] = "track";
+                    stops[c].push({ lap: Math.floor(entered[c] / L) + 1, in: pitIn[c], out: t, stop: plan.stopFor[stops[c].length] });
+                    age[c] = 0;
+                }
+            }
+            else if (t >= plan.reaction) {
+                const done = Math.max(0, Math.floor(s[c] / L));
+                const cool = mode[c] === "done";
+                let target = speedAt(pace, along);
+                if (cool)
+                    target *= 0.55;
+                else {
+                    const tyre = MODEL.tyre * age[c] + Math.max(0, age[c] - MODEL.wear) * MODEL.wornTyre;
+                    const fuel = MODEL.fuel * (1 - Math.min(done, laps) / laps);
+                    target /= 1 + plan.deficit + fuel + tyre + plan.noise[Math.min(done, plan.noise.length - 1)];
+                    // The car in front on the track: the tow and the dirty air behind it, and the gap kept when it cannot be passed here.
+                    let gap = Infinity;
+                    let other = -1;
+                    for (let o = 0; o < count; o += 1) {
+                        if (o === c || mode[o] === "pit" || mode[o] === "out" || mode[o] === "stopping")
+                            continue;
+                        const d = mod(s[o] - s[c], L);
+                        if (d > 0 && d < gap)
+                            [gap, other] = [d, o];
+                    }
+                    if (other >= 0) {
+                        const base = speedAt(pace, along);
+                        const seconds = gap / Math.max(v[c], 10);
+                        const straight = base > MODEL.straight * RACE_PACE.top;
+                        if (seconds < 1 && straight)
+                            target *= MODEL.tow;
+                        else if (seconds < 1.2 && base < 0.6 * RACE_PACE.top)
+                            target *= MODEL.dirty;
+                        // A car a lap or more behind lets the leaders by anywhere; one that is racing is passed on a straight, by a car that is quicker there.
+                        const lapping = s[c] - s[other] > L / 2;
+                        const keep = MODEL.gap + MODEL.gapPerSpeed * v[c];
+                        if (!lapping && mode[other] !== "done" && gap < keep && !(straight && target > v[other] * 1.02))
+                            target = Math.min(target, v[other] + (gap - MODEL.gap) / 1.5);
+                    }
+                }
+                target = Math.max(target, 0);
+                v[c] = target < v[c] ? Math.max(target, v[c] - RACE_PACE.brake * dt) : Math.min(target, v[c] + pullAt(v[c]) * dt);
+                s[c] += v[c] * dt;
+                // The pit lane: taken on a lap the strategy picks, where it leaves the lap.
+                const nextStop = plans[c].pits[stops[c].length];
+                const passedEntry = Math.floor((before - (entry - lineAlong)) / L) < Math.floor((s[c] - (entry - lineAlong)) / L);
+                if (!cool && hasPits && passedEntry && nextStop !== undefined && Math.floor(s[c] / L) + 1 >= nextStop) {
+                    const at = before + mod(entry - lineAlong - before, L);
+                    mode[c] = "pit";
+                    entered[c] = at;
+                    p[c] = s[c] - at;
+                    stopped[c] = false;
+                    held[c] = 0;
+                    pitIn[c] = t;
+                }
+                // A retirement: on its lap, at its place round it, the car slows to a stop beside the track.
+                if (!cool && plan.outLap > 0 && done + 1 === plan.outLap && mod(s[c], L) >= plan.outAt * L && out[c] === undefined && mode[c] === "track") {
+                    mode[c] = "stopping";
+                    out[c] = t;
+                }
+            }
+            // The timing line: a lap done, the flag, and the finish.
+            const k = Math.floor(s[c] / L);
+            if (k >= 1 && k > Math.floor(before / L) && mode[c] !== "done") {
+                const at = t - (dt * (s[c] - k * L)) / Math.max(s[c] - before, 1e-9);
+                crossings[c].push(at);
+                if (mode[c] === "track")
+                    age[c] += 1;
+                if (Number.isNaN(flag) && k >= laps)
+                    flag = at;
+                if (!Number.isNaN(flag) && at >= flag) {
+                    finish[c] = at;
+                    if (mode[c] === "track")
+                        mode[c] = "done";
+                }
+            }
+        }
+        if (steps % every === 0)
+            record(steps / every);
+        if (Number.isNaN(quiet) && mode.every((m, c) => m === "done" || m === "out" || (finish[c] !== undefined && m !== "pit")))
+            quiet = t;
+        if (!Number.isNaN(quiet) && t >= quiet + 20)
+            break;
+    }
+    const last = Math.floor(t / sample);
+    return Object.freeze({
+        circuit,
+        plan,
+        seed,
+        laps,
+        cars: Object.freeze(cars),
+        lapLength: L,
+        lineAlong,
+        pitLane: { entry, exit, length: pitLength },
+        pace,
+        sample,
+        flag: Number.isNaN(flag) ? last * sample : flag,
+        duration: last * sample,
+        distance: distance.map((d) => d.slice(0, last + 1)),
+        pit: pit.map((d) => d.slice(0, last + 1)),
+        crossings,
+        stops,
+        finish,
+        out,
+    });
+}

package/dist/circuits.race.moment.d.ts

@@ -0,0 +1,68 @@
+import type { Pt } from "./crowd.ts";
+import type { CircuitRace, RaceCar } from "./circuits.race.ts";
+/** What a car is doing. */
+export type RaceStatus = "grid" | "running" | "pit" | "out" | "finished";
+/** One line of the timing board. */
+export interface RaceStanding {
+    car: RaceCar;
+    /** Its place in the race's `cars`. */
+    index: number;
+    /** 1 for the leader. */
+    position: number;
+    status: RaceStatus;
+    /** Laps done. */
+    laps: number;
+    /** Seconds behind the leader (undefined for the leader, and for a car a lap or more down), and laps down. */
+    gap?: number;
+    lapsDown: number;
+    /** The same to the car in front. */
+    interval?: number;
+    intervalLaps: number;
+    /** The last lap's time and the car's best, in seconds. */
+    last?: number;
+    best?: number;
+    /** Pit stops made. */
+    stops: number;
+    /** Where it is on the drawing, in its frame (feet), and its race distance in metres. */
+    at: Pt;
+    distance: number;
+}
+/** A moment of the race. */
+export interface RaceMoment {
+    /** Seconds since the start. */
+    t: number;
+    /** The lap the leader is on (1 to `laps`), and the laps of the race. */
+    lap: number;
+    laps: number;
+    /** Whether the chequered flag has fallen, and whether the race is over (every car home). */
+    flag: boolean;
+    over: boolean;
+    /** The standings, leader first. */
+    standings: RaceStanding[];
+    /** The fastest lap so far: the car's place in `cars`, the lap and its time. */
+    fastest?: {
+        index: number;
+        lap: number;
+        time: number;
+    };
+}
+/** A car's race distance at a time (metres from the timing line), and its distance along the pit lane, or NaN on the track. */
+export declare function carAt(race: CircuitRace, index: number, t: number): {
+    distance: number;
+    pit: number;
+};
+/** Where a car is on the drawing at a time, in the drawing's frame (feet): on the lap, or in the pit lane. */
+export declare function racePoint(race: CircuitRace, index: number, t: number): Pt;
+/**
+ * A moment of a race: each car's place on the drawing and its line of the timing board (position, laps, the gap to the leader and to the car in front, the last and best laps, the stops), the lap the leader is on and
+ * the fastest lap so far.
+ * @example
+ * ```ts
+ * import { raceAt, simulateRace } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const race = simulateRace({ circuit: "las-vegas", laps: 3, cars: 4 });
+ * const now = raceAt(race, 150);
+ * console.log(now.lap, now.standings.length, now.standings[0].position, now.flag);
+ * // 2 4 1 false
+ * ```
+ */
+export declare function raceAt(race: CircuitRace, time: number): RaceMoment;

package/dist/circuits.race.moment.js

@@ -0,0 +1,147 @@
+import { linePoint, ringLengths, ringPoint } from "./circuits.pace.js";
+import { FEET_PER_METRE as FT } from "./geometry.js";
+/** The lengths of the lap and the pit lane on the drawing, worked out once for a race. */
+const LENGTHS = new WeakMap();
+const lengthsOf = (race) => {
+    let kept = LENGTHS.get(race);
+    if (kept === undefined) {
+        kept = { lap: ringLengths(race.plan.lap), pit: ringLengths(race.plan.pitLane) };
+        LENGTHS.set(race, kept);
+    }
+    return kept;
+};
+/** A sample's index and the share of the way to the next, at a time. */
+const slot = (race, t) => {
+    const last = race.distance[0].length - 1;
+    const x = Math.min(Math.max(t / race.sample, 0), last);
+    const j = Math.min(Math.floor(x), Math.max(0, last - 1));
+    return [j, x - j];
+};
+/** A car's race distance at a time (metres from the timing line), and its distance along the pit lane, or NaN on the track. */
+export function carAt(race, index, t) {
+    const [j, f] = slot(race, t);
+    const d = race.distance[index];
+    const p = race.pit[index];
+    const k = Math.min(j + 1, d.length - 1);
+    const a = p[j];
+    const b = p[k];
+    const pit = Number.isNaN(a) && Number.isNaN(b) ? Number.NaN : Number.isNaN(a) ? (f >= 0.5 ? b : Number.NaN) : Number.isNaN(b) ? (f < 0.5 ? a : Number.NaN) : a + f * (b - a);
+    return { distance: d[j] + f * (d[k] - d[j]), pit };
+}
+/** Where a car is on the drawing at a time, in the drawing's frame (feet): on the lap, or in the pit lane. */
+export function racePoint(race, index, t) {
+    const { distance, pit } = carAt(race, index, t);
+    const lengths = lengthsOf(race);
+    if (!Number.isNaN(pit))
+        return linePoint(race.plan.pitLane, lengths.pit, pit * FT);
+    return ringPoint(race.plan.lap, lengths.lap, (race.lineAlong + distance) * FT);
+}
+/** How many of a sorted list are at or before `t`. */
+const countTo = (list, t) => {
+    let lo = 0;
+    let hi = list.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (list[mid] <= t)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+};
+/** The time a car's race distance first reached `distance`, from its samples (they never go back), or undefined if it never did. */
+function timeAt(race, index, distance) {
+    const d = race.distance[index];
+    if (d[d.length - 1] < distance)
+        return undefined;
+    if (d[0] >= distance)
+        return 0;
+    let lo = 0;
+    let hi = d.length - 1;
+    while (hi - lo > 1) {
+        const mid = (lo + hi) >> 1;
+        if (d[mid] < distance)
+            lo = mid;
+        else
+            hi = mid;
+    }
+    const span = d[hi] - d[lo];
+    return (lo + (span > 0 ? (distance - d[lo]) / span : 0)) * race.sample;
+}
+/** The gap from one car to another ahead of it at a time: seconds, or whole laps when it is a lap or more behind. */
+function gapTo(race, ahead, behind, t) {
+    const L = race.lapLength;
+    if (ahead.finished !== undefined && behind.finished !== undefined) {
+        const laps = race.crossings[ahead.index].length - race.crossings[behind.index].length;
+        return laps > 0 ? { laps } : { seconds: behind.finished - ahead.finished, laps: 0 };
+    }
+    const laps = Math.floor((ahead.distance - behind.distance) / L);
+    if (laps >= 1)
+        return { laps };
+    const when = timeAt(race, ahead.index, behind.distance);
+    return { seconds: when === undefined ? undefined : Math.max(0, (behind.finished ?? t) - when), laps: 0 };
+}
+/**
+ * A moment of a race: each car's place on the drawing and its line of the timing board (position, laps, the gap to the leader and to the car in front, the last and best laps, the stops), the lap the leader is on and
+ * the fastest lap so far.
+ * @example
+ * ```ts
+ * import { raceAt, simulateRace } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const race = simulateRace({ circuit: "las-vegas", laps: 3, cars: 4 });
+ * const now = raceAt(race, 150);
+ * console.log(now.lap, now.standings.length, now.standings[0].position, now.flag);
+ * // 2 4 1 false
+ * ```
+ */
+export function raceAt(race, time) {
+    const t = Math.min(Math.max(Number.isFinite(time) ? time : 0, 0), race.duration);
+    const lines = race.cars.map((car, index) => {
+        const { distance, pit } = carAt(race, index, t);
+        const laps = countTo(race.crossings[index], t);
+        const finished = race.finish[index] !== undefined && race.finish[index] <= t ? race.finish[index] : undefined;
+        const outAt = race.out[index];
+        const status = finished !== undefined ? "finished" : outAt !== undefined && outAt <= t ? "out" : !Number.isNaN(pit) ? "pit" : t <= 0 ? "grid" : "running";
+        // A car that has finished ranks by the laps it did and when it did them; one that retired ranks after every car still in the race.
+        const rank = status === "finished" ? laps * race.lapLength + 1e-3 * (race.duration - finished) : status === "out" ? distance - 1e9 : distance;
+        return { car, index, distance, laps, finished, status, rank, at: racePoint(race, index, t) };
+    });
+    lines.sort((a, b) => b.rank - a.rank || a.index - b.index);
+    const leader = lines[0];
+    let fastest;
+    const standings = lines.map((line, i) => {
+        const crossed = race.crossings[line.index];
+        let best;
+        for (let k = 0; k < line.laps; k += 1) {
+            const lapTime = crossed[k] - (k === 0 ? 0 : crossed[k - 1]);
+            // The first lap starts from the grid: it is not a flying lap.
+            if (k === 0)
+                continue;
+            if (best === undefined || lapTime < best)
+                best = lapTime;
+            if (fastest === undefined || lapTime < fastest.time)
+                fastest = { index: line.index, lap: k + 1, time: lapTime };
+        }
+        // On the grid, and for the leader and a car that retired, there is no gap to give.
+        const none = i === 0 || line.status === "out" || line.status === "grid";
+        const toLeader = none ? { laps: 0 } : gapTo(race, leader, line, t);
+        const toNext = none ? { laps: 0 } : gapTo(race, lines[i - 1], line, t);
+        return {
+            car: line.car,
+            index: line.index,
+            position: i + 1,
+            status: line.status,
+            laps: line.laps,
+            ...(toLeader.seconds === undefined ? {} : { gap: toLeader.seconds }),
+            lapsDown: toLeader.laps,
+            ...(toNext.seconds === undefined ? {} : { interval: toNext.seconds }),
+            intervalLaps: toNext.laps,
+            ...(line.laps === 0 ? {} : { last: crossed[line.laps - 1] - (line.laps === 1 ? 0 : crossed[line.laps - 2]) }),
+            ...(best === undefined ? {} : { best }),
+            stops: race.stops[line.index].filter((s) => s.in <= t).length,
+            at: line.at,
+            distance: line.distance,
+        };
+    });
+    const lap = Math.min(race.laps, Math.max(1, (leader?.laps ?? 0) + 1));
+    return { t, lap, laps: race.laps, flag: t >= race.flag, over: t >= race.duration, standings, ...(fastest === undefined ? {} : { fastest }) };
+}

package/dist/circuits.race.words.d.ts

@@ -0,0 +1,49 @@
+import type { Language } from "./types.ts";
+/** What a race's pictures, controls and board say. */
+export interface RaceWords {
+    /** The line that says what this is: a model, not a real race. */
+    simulated: string;
+    /** The race clock: the lap the leader is on, and the line under it once the flag has fallen. */
+    lap: string;
+    finalLap: string;
+    flag: string;
+    grid: string;
+    /** The time since the start, for a screen reader. */
+    elapsed: string;
+    /** The controls. */
+    group: string;
+    play: string;
+    pause: string;
+    nextLap: string;
+    speed: string;
+    speedValue: string;
+    position: string;
+    positionValue: string;
+    /** The board: its caption, its heads, and what a line says. */
+    board: {
+        caption: string;
+        position: string;
+        driver: string;
+        team: string;
+        gap: string;
+        interval: string;
+        last: string;
+        best: string;
+        stops: string;
+        leader: string;
+        lapDown: string;
+        lapsDown: string;
+        pit: string;
+        out: string;
+        finished: string;
+        fastest: string;
+    };
+    /** A car on the drawing, for a screen reader. */
+    car: string;
+    /** What is said aloud as the race goes. */
+    leads: string;
+    wins: string;
+    /** The drawing's description, added to the circuit's. */
+    description: string;
+}
+export declare const RACE_WORDS: Readonly<Record<Language, RaceWords>>;