@johnmorrisdotca/kyogijo-stadiums 0.54.0 → 0.56.0

package/dist/circuits.feed.js

@@ -0,0 +1,332 @@
+// A race from a feed: kyogijo's open race timeline (`kyogijo-race`, version 1), read strictly, and turned into the same race a simulation gives (`CircuitRace`), so that every moment, drawing, board and page of a
+// simulated race plays it unchanged. A feed says when each car completed each lap, and may say when it was in the pit lane, when it retired and where it was (location samples in the feed's own frame); the cars run
+// between those moments at the lap's own speeds (`paceProfile`), and location samples are laid on the circuit's own line by how far round the lap they are, so the dots stay on the road. Pure: no request is made here.
+import { nearestOn } from "./circuits.geo.js";
+import { circuitOf, circuitPlan } from "./circuits.js";
+import { lineLength } from "./circuits.geo.js";
+import { paceProfile } from "./circuits.pace.js";
+import { FEET_PER_METRE as FT } from "./geometry.js";
+/** The most a feed may hold: cars, and rows of each list. */
+export const FEED_LIMITS = Object.freeze({ cars: 40, rows: 200000, laps: 200 });
+const isNum = (v) => typeof v === "number" && Number.isFinite(v);
+const isText = (v) => typeof v === "string" && v.length > 0 && v.length <= 80;
+const COLOUR = /^#[0-9a-f]{6}$/i;
+/** The colours a feed's car takes when it gives none, in turn (the made-up teams' own). */
+const FALLBACK = ["#1d4ed8", "#0f766e", "#db2777", "#c026d3", "#65a30d", "#0ea5e9", "#b91c1c", "#94a3b8", "#ca8a04", "#7c3aed"];
+/**
+ * Read a feed strictly: anything that is not the open race timeline is refused with a sentence that says why, and anything a feed carries that the format does not name is left behind. Text is kept as text (never markup).
+ * @example
+ * ```ts
+ * import { readRaceFeed } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const read = readRaceFeed({ kind: "kyogijo-race", version: 1, cars: [{ id: "a" }], crossings: [{ car: "a", lap: 1, t: 101 }] });
+ * console.log(read.ok, readRaceFeed({ kind: "something" }).ok);
+ * // true false
+ * ```
+ */
+export function readRaceFeed(input) {
+    if (typeof input !== "object" || input === null || Array.isArray(input))
+        return { ok: false, error: "A race feed is a JSON object." };
+    const o = input;
+    if (o.kind !== "kyogijo-race")
+        return { ok: false, error: 'This is not a race feed: its "kind" is not "kyogijo-race".' };
+    if (o.version !== 1)
+        return { ok: false, error: "This race feed is of a version this package does not read (it reads version 1)." };
+    if (!Array.isArray(o.cars) || o.cars.length === 0)
+        return { ok: false, error: "The race feed has no cars." };
+    if (o.cars.length > FEED_LIMITS.cars)
+        return { ok: false, error: `The race feed has more than ${FEED_LIMITS.cars} cars.` };
+    const cars = [];
+    const ids = new Set();
+    for (const raw of o.cars) {
+        const c = (typeof raw === "object" && raw !== null ? raw : {});
+        const id = typeof c.id === "number" ? String(c.id) : c.id;
+        if (!isText(id) || ids.has(id))
+            return { ok: false, error: "Each car of the race feed needs an id of its own." };
+        ids.add(id);
+        cars.push({
+            id,
+            ...(isText(c.code) ? { code: c.code.slice(0, 4) } : {}),
+            ...(isText(c.name) ? { name: c.name } : {}),
+            ...(isText(c.team) ? { team: c.team } : {}),
+            ...(typeof c.colour === "string" && COLOUR.test(c.colour) ? { colour: c.colour } : {}),
+            ...(isNum(c.grid) && c.grid >= 1 ? { grid: Math.round(c.grid) } : {}),
+        });
+    }
+    const rows = (name, keep) => {
+        const list = o[name];
+        if (list === undefined)
+            return [];
+        if (!Array.isArray(list))
+            return `The race feed's "${name}" is not a list.`;
+        if (list.length > FEED_LIMITS.rows)
+            return `The race feed's "${name}" has more than ${FEED_LIMITS.rows} rows.`;
+        const out = [];
+        for (const r of list) {
+            if (typeof r !== "object" || r === null)
+                continue;
+            const row = r;
+            const car = typeof row.car === "number" ? String(row.car) : row.car;
+            if (typeof car !== "string" || !ids.has(car))
+                continue;
+            const kept = keep({ ...row, car });
+            if (kept !== undefined)
+                out.push(kept);
+        }
+        return out;
+    };
+    const crossings = rows("crossings", (r) => (isNum(r.lap) && r.lap >= 1 && r.lap <= FEED_LIMITS.laps && isNum(r.t) && r.t > 0 ? { car: r.car, lap: Math.round(r.lap), t: r.t } : undefined));
+    const pits = rows("pits", (r) => (isNum(r.in) && isNum(r.out) && r.out > r.in ? { car: r.car, in: r.in, out: r.out, ...(isNum(r.stop) && r.stop >= 0 ? { stop: r.stop } : {}) } : undefined));
+    const out = rows("out", (r) => (isNum(r.t) && r.t >= 0 ? { car: r.car, t: r.t } : undefined));
+    const positions = rows("positions", (r) => (isNum(r.t) && isNum(r.x) && isNum(r.y) ? { car: r.car, t: r.t, x: r.x, y: r.y } : undefined));
+    for (const list of [crossings, pits, out, positions])
+        if (typeof list === "string")
+            return { ok: false, error: list };
+    if (crossings.length === 0)
+        return { ok: false, error: "The race feed has no lap times: it needs at least one car's completed lap." };
+    return {
+        ok: true,
+        feed: {
+            kind: "kyogijo-race",
+            version: 1,
+            ...(isText(o.circuit) ? { circuit: o.circuit } : {}),
+            ...(isNum(o.laps) && o.laps >= 1 && o.laps <= FEED_LIMITS.laps ? { laps: Math.round(o.laps) } : {}),
+            ...(typeof o.title === "string" && o.title.length <= 200 ? { title: o.title } : {}),
+            cars,
+            crossings: crossings,
+            ...(pits.length > 0 ? { pits: pits } : {}),
+            ...(out.length > 0 ? { out: out } : {}),
+            ...(positions.length > 0 ? { positions: positions } : {}),
+            ...(o.live === true ? { live: true } : {}),
+        },
+    };
+}
+/** The colour of what is written on a colour: dark on a light one, white on a dark one. */
+const inkOn = (hex) => {
+    const n = Number.parseInt(hex.slice(1), 16);
+    const lum = 0.299 * ((n >> 16) & 255) + 0.587 * ((n >> 8) & 255) + 0.114 * (n & 255);
+    return lum > 150 ? "#10151b" : "#ffffff";
+};
+const mod = (a, n) => ((a % n) + n) % n;
+/** Where the location samples of a car lie round the lap, as shares of it from the timing line: the feed's own line is the path of the car with the most samples over its second lap. */
+function lapShares(feed, crossed) {
+    const out = new Map();
+    const positions = feed.positions ?? [];
+    if (positions.length === 0)
+        return out;
+    const byCar = new Map();
+    for (const p of positions) {
+        let list = byCar.get(p.car);
+        if (list === undefined)
+            byCar.set(p.car, (list = []));
+        list.push({ t: p.t, at: [p.x, p.y] });
+    }
+    for (const list of byCar.values())
+        list.sort((a, b) => a.t - b.t);
+    // The reference: a lap of one car, from one crossing to the next.
+    let ref = [];
+    let refStart;
+    for (const [car, list] of byCar) {
+        const cr = crossed.get(car) ?? [];
+        for (let k = 1; k < cr.length; k += 1) {
+            const lap = list.filter((s) => s.t >= cr[k - 1] && s.t <= cr[k]);
+            if (lap.length > ref.length) {
+                ref = lap.map((s) => s.at);
+                refStart = lap[0].at;
+            }
+        }
+    }
+    if (ref.length < 20 || refStart === undefined)
+        return out;
+    const total = lineLength(ref, true);
+    const zero = nearestOn(ref, refStart, true).along;
+    for (const [car, list] of byCar)
+        out.set(car, list.map((s) => ({ t: s.t, share: mod(nearestOn(ref, s.at, true).along - zero, total) / total })));
+    return out;
+}
+/**
+ * A feed as a race (`CircuitRace`): the same shape a simulation gives, so that `raceAt`, `drawRace`, `raceBoard` and `mountCircuitRace` play it. The circuit is the feed's, or the one named here (a page draws a feed on the
+ * circuit it shows). Between the moments a feed gives, the cars run at the lap's own speeds.
+ * @example
+ * ```ts
+ * import { raceAt, raceFromFeed } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const race = raceFromFeed({ kind: "kyogijo-race", version: 1, cars: [{ id: "a", code: "AAA" }, { id: "b", code: "BBB" }], crossings: [{ car: "a", lap: 1, t: 101 }, { car: "b", lap: 1, t: 102.5 }, { car: "a", lap: 2, t: 198 }, { car: "b", lap: 2, t: 200 }] }, "las-vegas");
+ * const end = raceAt(race, race.duration);
+ * console.log(race.laps, end.standings[0].car.driver.code, end.standings[1].gap);
+ * // 2 AAA 2
+ * ```
+ */
+export function raceFromFeed(feed, circuitId) {
+    const circuit = circuitOf(circuitId ?? feed.circuit ?? "las-vegas");
+    const plan = circuitPlan(circuit);
+    const pace = paceProfile(plan);
+    const L = pace.length;
+    const lineAlong = plan.finish.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);
+    let ahead = mod(plan.start.along / FT - lineAlong, L);
+    if (ahead > L / 2)
+        ahead -= L;
+    const order = [...feed.cars].map((c, i) => ({ c, i })).sort((a, b) => (a.c.grid ?? a.i + 1) - (b.c.grid ?? b.i + 1));
+    const cars = order.map(({ c, i }, place) => {
+        const colour = c.colour ?? FALLBACK[i % FALLBACK.length];
+        const team = { id: `feed-${c.team ?? c.id}`, name: { en: c.team ?? "", ja: c.team ?? "" }, colour, ink: inkOn(colour) };
+        const driver = { code: c.code ?? c.id.slice(0, 4).toUpperCase(), name: { en: c.name ?? c.code ?? c.id, ja: c.name ?? c.code ?? c.id }, team: team.id };
+        return { id: c.id, driver, team, grid: place + 1 };
+    });
+    const crossed = new Map(cars.map((c) => [c.id, []]));
+    for (const row of [...feed.crossings].sort((a, b) => a.lap - b.lap || a.t - b.t)) {
+        const list = crossed.get(row.car);
+        // Lap n is the n-th crossing: a lap the feed skipped is left as the feed has it, and a crossing that goes back in time is dropped.
+        if (list.length < row.lap && (list.length === 0 || row.t > list[list.length - 1]))
+            list.push(row.t);
+    }
+    const maxLaps = Math.max(...[...crossed.values()].map((l) => l.length));
+    const laps = feed.live === true ? Math.max(feed.laps ?? 0, maxLaps) : Math.min(feed.laps ?? maxLaps, Math.max(maxLaps, 1));
+    const outAt = new Map((feed.out ?? []).map((o) => [o.car, o.t]));
+    const lastSeen = Math.max(...feed.crossings.map((c) => c.t), ...(feed.out ?? []).map((o) => o.t), ...(feed.pits ?? []).map((p) => p.out));
+    // The flag: the first car to complete the race's laps, when the feed says the race has its end.
+    const leaderAt = [...crossed.values()].map((l) => l[laps - 1]).filter((t) => t !== undefined);
+    const flag = feed.live === true || leaderAt.length === 0 ? Number.NaN : Math.min(...leaderAt);
+    const duration = Math.ceil(lastSeen + (Number.isNaN(flag) ? 0 : 20));
+    const size = duration + 1;
+    const shares = lapShares(feed, crossed);
+    // The lap's own time to each place round it, from the timing line: the shape of the run between two moments.
+    const timeTo = (s) => {
+        const whole = Math.floor(s / L);
+        const along = mod(lineAlong + s, L);
+        const at = (x) => {
+            const i = Math.min(Math.floor(x / pace.step), pace.speed.length - 1);
+            const f = x / pace.step - i;
+            return pace.time[i] + f * (pace.time[i + 1] - pace.time[i]);
+        };
+        const fromLine = mod(at(along) - at(mod(lineAlong, L)), pace.lap);
+        return whole * pace.lap + fromLine;
+    };
+    /** The race distance between `a` (at `ta`) and `b` (at `tb`) at a time, at the lap's speeds. */
+    const between = (a, b, ta, tb, t) => {
+        if (tb <= ta || b <= a)
+            return a;
+        const target = timeTo(a) + ((t - ta) / (tb - ta)) * (timeTo(b) - timeTo(a));
+        let lo = a;
+        let hi = b;
+        for (let i = 0; i < 30; i += 1) {
+            const mid = (lo + hi) / 2;
+            if (timeTo(mid) < target)
+                lo = mid;
+            else
+                hi = mid;
+        }
+        return (lo + hi) / 2;
+    };
+    const distance = cars.map(() => new Float64Array(size));
+    const pit = cars.map(() => new Float32Array(size).fill(Number.NaN));
+    const stops = cars.map(() => []);
+    const finish = cars.map(() => undefined);
+    const out = cars.map(() => undefined);
+    cars.forEach((car, c) => {
+        const cr = crossed.get(car.id);
+        const start = ahead - 8 * (car.grid - 1);
+        // The moments of this car: the start, every crossing, every location sample, and the ends of the pit lane.
+        const points = [{ t: 0, s: start }, ...cr.map((t, k) => ({ t, s: (k + 1) * L }))];
+        const lapsAt = (t) => cr.filter((x) => x <= t).length;
+        for (const sample of shares.get(car.id) ?? []) {
+            const k = lapsAt(sample.t);
+            let s = k * L + sample.share * L;
+            // A sample just after a crossing whose share is still near the end of the lap belongs to the lap before.
+            if (sample.share > 0.9 && k > 0 && sample.t - cr[k - 1] < 10)
+                s -= L;
+            if (s > start)
+                points.push({ t: sample.t, s });
+        }
+        const pits = (feed.pits ?? []).filter((p) => p.car === car.id).sort((a, b) => a.in - b.in);
+        for (const p of pits) {
+            const k = lapsAt(p.in);
+            const sIn = k * L + mod(entry - lineAlong, L);
+            points.push({ t: p.in, s: sIn, pitTo: p.out }, { t: p.out, s: sIn + bypass });
+            stops[c].push({ lap: k + 1, in: p.in, out: p.out, stop: p.stop ?? 0 });
+        }
+        // A car still running when the feed ends goes on round at its last lap's pace, so that a race that is going on does not hold its dots on the line.
+        const retired0 = outAt.get(car.id);
+        const done = !Number.isNaN(flag) && cr.some((t) => t >= flag);
+        if (retired0 === undefined && !done && cr.length > 0) {
+            const lastLap = cr.length > 1 ? cr[cr.length - 1] - cr[cr.length - 2] : pace.lap;
+            points.push({ t: cr[cr.length - 1] + lastLap, s: (cr.length + 1) * L });
+        }
+        points.sort((a, b) => a.t - b.t);
+        // Distance never goes back.
+        for (let i = 1; i < points.length; i += 1)
+            if (points[i].s < points[i - 1].s)
+                points[i].s = points[i - 1].s;
+        const retired = outAt.get(car.id);
+        if (retired !== undefined)
+            out[c] = retired;
+        if (!Number.isNaN(flag))
+            finish[c] = cr.find((t) => t >= flag);
+        let j = 0;
+        for (let second = 0; second < size; second += 1) {
+            const t = second;
+            while (j + 1 < points.length && points[j + 1].t <= t)
+                j += 1;
+            const a = points[j];
+            const b = points[j + 1];
+            const pitWindow = a.pitTo !== undefined && t < a.pitTo;
+            if (pitWindow) {
+                const f = (t - a.t) / (a.pitTo - a.t);
+                pit[c][second] = f * pitLength;
+                distance[c][second] = a.s + f * bypass;
+            }
+            else if (b === undefined || (retired !== undefined && t >= retired)) {
+                distance[c][second] = second === 0 ? a.s : distance[c][second - 1];
+            }
+            else
+                distance[c][second] = between(a.s, b.s, a.t, b.t, t);
+        }
+    });
+    return Object.freeze({
+        circuit,
+        plan,
+        seed: 0,
+        laps,
+        cars: Object.freeze(cars),
+        lapLength: L,
+        lineAlong,
+        pitLane: { entry, exit, length: pitLength },
+        pace,
+        sample: 1,
+        flag: Number.isNaN(flag) ? duration + 1 : flag,
+        duration,
+        distance,
+        pit,
+        crossings: cars.map((car) => crossed.get(car.id)),
+        stops,
+        finish,
+        out,
+    });
+}
+/**
+ * A race as the open race timeline: what a simulated race is, written as a feed (the demo's sample feed is one). Lap times are rounded to thousandths.
+ * @example
+ * ```ts
+ * import { raceToFeed, simulateRace } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const feed = raceToFeed(simulateRace({ circuit: "las-vegas", laps: 3, cars: 4 }));
+ * console.log(feed.kind, feed.cars.length, feed.crossings.length);
+ * // kyogijo-race 4 12
+ * ```
+ */
+export function raceToFeed(race, title) {
+    const r3 = (n) => Math.round(n * 1000) / 1000;
+    const feed = {
+        kind: "kyogijo-race",
+        version: 1,
+        circuit: race.circuit.id,
+        laps: race.laps,
+        ...(title === undefined ? {} : { title }),
+        cars: race.cars.map((c) => ({ id: c.id, code: c.driver.code, name: c.driver.name.en, team: c.team.name.en, colour: c.team.colour, grid: c.grid })),
+        crossings: race.cars.flatMap((c, i) => race.crossings[i].map((t, k) => ({ car: c.id, lap: k + 1, t: r3(t) }))),
+    };
+    const pits = race.cars.flatMap((c, i) => race.stops[i].map((s) => ({ car: c.id, in: r3(s.in), out: r3(s.out), stop: r3(s.stop) })));
+    const out = race.cars.flatMap((c, i) => (race.out[i] === undefined ? [] : [{ car: c.id, t: r3(race.out[i]) }]));
+    return { ...feed, ...(pits.length > 0 ? { pits } : {}), ...(out.length > 0 ? { out } : {}) };
+}

package/dist/circuits.feed.openf1.d.ts

@@ -0,0 +1,61 @@
+import type { RaceFeed } from "./circuits.feed.ts";
+/** A lap row: who, which lap, when it started and how long it took. */
+export interface OpenF1Lap {
+    driver_number: number;
+    lap_number: number;
+    date_start?: string | null;
+    lap_duration?: number | null;
+}
+/** A pit row: who, on which lap, when it entered the pit lane and how long it was in it and standing. */
+export interface OpenF1Pit {
+    driver_number: number;
+    lap_number?: number;
+    date: string;
+    pit_duration?: number | null;
+    lane_duration?: number | null;
+    stop_duration?: number | null;
+}
+/** A driver row: the code, the name and the team as the source gives them. */
+export interface OpenF1Driver {
+    driver_number: number;
+    name_acronym?: string;
+    broadcast_name?: string;
+    last_name?: string;
+    team_name?: string;
+    team_colour?: string;
+}
+/** A location row: where a car was, in the source's own frame. */
+export interface OpenF1Location {
+    driver_number: number;
+    date: string;
+    x: number;
+    y: number;
+}
+/** What the adapter is given: the rows of each answer the user's source gave. Only `laps` is needed. */
+export interface OpenF1Rows {
+    laps: readonly OpenF1Lap[];
+    pit?: readonly OpenF1Pit[];
+    drivers?: readonly OpenF1Driver[];
+    location?: readonly OpenF1Location[];
+    /** The laps of the race, if known. */
+    totalLaps?: number;
+    /** True while the session is going on. */
+    live?: boolean;
+}
+/** Whether a list looks like OpenF1's lap rows: objects with a driver number and a lap number. */
+export declare const looksLikeOpenF1Laps: (input: unknown) => input is OpenF1Lap[];
+/**
+ * OpenF1-style rows as a race feed. The start is the earliest start of a first lap; a lap is completed at its start plus its duration (or, where the duration is missing, at the next lap's start). A pit stop runs from
+ * its row's time for its lane duration. Location rows, when given, become the feed's positions.
+ * @example
+ * ```ts
+ * import { openF1Feed } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const feed = openF1Feed({ laps: [
+ *   { driver_number: 7, lap_number: 1, date_start: "2030-01-01T20:00:00Z", lap_duration: 101 },
+ *   { driver_number: 7, lap_number: 2, date_start: "2030-01-01T20:01:41Z", lap_duration: 97.5 },
+ * ], drivers: [{ driver_number: 7, name_acronym: "ABC", team_name: "Made-up Team", team_colour: "3366CC" }] });
+ * console.log(feed.cars[0].code, feed.cars[0].colour, feed.crossings.map((c) => c.t).join(" "));
+ * // ABC #3366cc 101 198.5
+ * ```
+ */
+export declare function openF1Feed(rows: OpenF1Rows): RaceFeed;

package/dist/circuits.feed.openf1.js

@@ -0,0 +1,65 @@
+const ms = (date) => (typeof date === "string" ? Date.parse(date) : Number.NaN);
+const isNum = (v) => typeof v === "number" && Number.isFinite(v);
+/** Whether a list looks like OpenF1's lap rows: objects with a driver number and a lap number. */
+export const looksLikeOpenF1Laps = (input) => Array.isArray(input) && input.length > 0 && input.slice(0, 5).every((r) => typeof r === "object" && r !== null && isNum(r.driver_number) && isNum(r.lap_number));
+/**
+ * OpenF1-style rows as a race feed. The start is the earliest start of a first lap; a lap is completed at its start plus its duration (or, where the duration is missing, at the next lap's start). A pit stop runs from
+ * its row's time for its lane duration. Location rows, when given, become the feed's positions.
+ * @example
+ * ```ts
+ * import { openF1Feed } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const feed = openF1Feed({ laps: [
+ *   { driver_number: 7, lap_number: 1, date_start: "2030-01-01T20:00:00Z", lap_duration: 101 },
+ *   { driver_number: 7, lap_number: 2, date_start: "2030-01-01T20:01:41Z", lap_duration: 97.5 },
+ * ], drivers: [{ driver_number: 7, name_acronym: "ABC", team_name: "Made-up Team", team_colour: "3366CC" }] });
+ * console.log(feed.cars[0].code, feed.cars[0].colour, feed.crossings.map((c) => c.t).join(" "));
+ * // ABC #3366cc 101 198.5
+ * ```
+ */
+export function openF1Feed(rows) {
+    const laps = rows.laps.filter((l) => isNum(l.driver_number) && isNum(l.lap_number));
+    const firsts = laps.filter((l) => l.lap_number === 1).map((l) => ms(l.date_start)).filter(Number.isFinite);
+    const zero = firsts.length > 0 ? Math.min(...firsts) : Math.min(...laps.map((l) => ms(l.date_start)).filter(Number.isFinite));
+    const at = (date) => (ms(date) - zero) / 1000;
+    const numbers = [...new Set(laps.map((l) => l.driver_number))];
+    const drivers = new Map((rows.drivers ?? []).map((d) => [d.driver_number, d]));
+    const cars = numbers.map((n) => {
+        const d = drivers.get(n);
+        const colour = typeof d?.team_colour === "string" && /^[0-9a-f]{6}$/i.test(d.team_colour) ? `#${d.team_colour.toLowerCase()}` : undefined;
+        return {
+            id: String(n),
+            code: (d?.name_acronym ?? String(n)).slice(0, 4),
+            name: d?.last_name ?? d?.broadcast_name ?? String(n),
+            ...(d?.team_name === undefined ? {} : { team: d.team_name }),
+            ...(colour === undefined ? {} : { colour }),
+        };
+    });
+    const crossings = [];
+    for (const n of numbers) {
+        const mine = laps.filter((l) => l.driver_number === n).sort((a, b) => a.lap_number - b.lap_number);
+        mine.forEach((l, i) => {
+            const next = mine[i + 1];
+            const end = isNum(l.lap_duration) && Number.isFinite(at(l.date_start)) ? at(l.date_start) + l.lap_duration : next !== undefined && next.lap_number === l.lap_number + 1 ? at(next.date_start) : Number.NaN;
+            if (Number.isFinite(end) && end > 0)
+                crossings.push({ car: String(n), lap: l.lap_number, t: Math.round(end * 1000) / 1000 });
+        });
+    }
+    const pits = (rows.pit ?? [])
+        .filter((p) => isNum(p.driver_number) && Number.isFinite(at(p.date)))
+        .map((p) => {
+        const lane = [p.lane_duration, p.pit_duration].find(isNum) ?? 20;
+        return { car: String(p.driver_number), in: at(p.date), out: at(p.date) + lane, ...(isNum(p.stop_duration) ? { stop: p.stop_duration } : {}) };
+    })
+        .filter((p) => p.in >= 0);
+    const positions = (rows.location ?? []).filter((p) => isNum(p.driver_number) && isNum(p.x) && isNum(p.y) && Number.isFinite(at(p.date))).map((p) => ({ car: String(p.driver_number), t: at(p.date), x: p.x, y: p.y }));
+    return {
+        kind: "kyogijo-race",
+        version: 1,
+        ...(isNum(rows.totalLaps) ? { laps: rows.totalLaps } : {}),
+        cars,
+        crossings,
+        ...(pits.length > 0 ? { pits } : {}),
+        ...(positions.length > 0 ? { positions } : {}),
+        ...(rows.live === true ? { live: true } : {}),
+    };
+}

package/dist/circuits.pace.d.ts

@@ -0,0 +1,96 @@
+import type { Pt } from "./crowd.ts";
+import type { CircuitPlan } from "./circuits.ts";
+/** The figures of the model, in metres and seconds. */
+export declare const RACE_PACE: Readonly<{
+    /** The fastest the car goes on a straight: 94 m/s, about 338 km/h. */
+    top: 94;
+    /** Grip across the car: `grip + downforce × v²` metres a second squared at a speed `v`, about 2.4 g in a hairpin and 5 g in a fast bend. */
+    grip: 22;
+    downforce: 0.0036;
+    /** How hard it brakes, and how hard it pulls away at rest; the pull falls to nothing at `top`. */
+    brake: 34;
+    launch: 17;
+    /** The line is read every `step` metres, and a bend is measured over `reach` either side: a racing car does not follow the middle of the road, so a short kink of it is not a bend. */
+    step: 5;
+    reach: 32;
+    /** The speed limit of the pit lane: 80 km/h. */
+    pitLimit: number;
+}>;
+/** A lap's speeds: one each `step` metres round the line from its first point, the time at each, and the lap's time and length. */
+export interface PaceProfile {
+    /** Metres between two samples. */
+    step: number;
+    /** The length of the line, in metres. */
+    length: number;
+    /** The speed at each sample, metres a second, and the seconds from the line's first point to each (one more than the speeds: the last is the lap's time). */
+    speed: Float64Array;
+    time: Float64Array;
+    /** The time of a flying lap, in seconds. */
+    lap: number;
+}
+/** The cumulative length of a ring at each of its points (the first 0, one more than the points: the last is the whole length). */
+export declare function ringLengths(points: readonly Pt[]): Float64Array;
+/** The point of a ring `along` units round it from its first point (wrapped), from its lengths (`ringLengths`): found by halving, so a page can ask for twenty a frame. */
+export declare function ringPoint(points: readonly Pt[], lengths: Float64Array, along: number): Pt;
+/** The same for an open line: held to its ends. */
+export declare function linePoint(points: readonly Pt[], lengths: Float64Array, along: number): Pt;
+/** The fastest speed a bend of radius `r` metres allows: `v² = r × (grip + downforce × v²)`, and the top speed where the downforce holds it at any speed. */
+export declare function cornerSpeed(r: number, pace?: Readonly<{
+    /** The fastest the car goes on a straight: 94 m/s, about 338 km/h. */
+    top: 94;
+    /** Grip across the car: `grip + downforce × v²` metres a second squared at a speed `v`, about 2.4 g in a hairpin and 5 g in a fast bend. */
+    grip: 22;
+    downforce: 0.0036;
+    /** How hard it brakes, and how hard it pulls away at rest; the pull falls to nothing at `top`. */
+    brake: 34;
+    launch: 17;
+    /** The line is read every `step` metres, and a bend is measured over `reach` either side: a racing car does not follow the middle of the road, so a short kink of it is not a bend. */
+    step: 5;
+    reach: 32;
+    /** The speed limit of the pit lane: 80 km/h. */
+    pitLimit: number;
+}>): number;
+/** How hard the car can pull away at a speed: `launch` at rest, nothing at the top speed. */
+export declare const pullAt: (v: number, pace?: Readonly<{
+    /** The fastest the car goes on a straight: 94 m/s, about 338 km/h. */
+    top: 94;
+    /** Grip across the car: `grip + downforce × v²` metres a second squared at a speed `v`, about 2.4 g in a hairpin and 5 g in a fast bend. */
+    grip: 22;
+    downforce: 0.0036;
+    /** How hard it brakes, and how hard it pulls away at rest; the pull falls to nothing at `top`. */
+    brake: 34;
+    launch: 17;
+    /** The line is read every `step` metres, and a bend is measured over `reach` either side: a racing car does not follow the middle of the road, so a short kink of it is not a bend. */
+    step: 5;
+    reach: 32;
+    /** The speed limit of the pit lane: 80 km/h. */
+    pitLimit: number;
+}>) => number;
+/**
+ * A plan's speeds round its lap (`circuitPlan`), from its line alone: the bends' radii give each sample's fastest speed, and two passes round (twice, so that the lap closes on itself) hold it to the engine and the
+ * brakes. The same plan always gives the same profile.
+ * @example
+ * ```ts
+ * import { circuitById, circuitPlan, paceProfile } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const pace = paceProfile(circuitPlan(circuitById("las-vegas")!));
+ * console.log(pace.lap > 90 && pace.lap < 105, Math.max(...pace.speed) * 3.6 > 300);
+ * // true true
+ * ```
+ */
+export declare function paceProfile(plan: CircuitPlan, pace?: Readonly<{
+    /** The fastest the car goes on a straight: 94 m/s, about 338 km/h. */
+    top: 94;
+    /** Grip across the car: `grip + downforce × v²` metres a second squared at a speed `v`, about 2.4 g in a hairpin and 5 g in a fast bend. */
+    grip: 22;
+    downforce: 0.0036;
+    /** How hard it brakes, and how hard it pulls away at rest; the pull falls to nothing at `top`. */
+    brake: 34;
+    launch: 17;
+    /** The line is read every `step` metres, and a bend is measured over `reach` either side: a racing car does not follow the middle of the road, so a short kink of it is not a bend. */
+    step: 5;
+    reach: 32;
+    /** The speed limit of the pit lane: 80 km/h. */
+    pitLimit: number;
+}>): PaceProfile;
+/** The speed at `along` metres round the lap from the line's first point (wrapped), between the two samples either side. */
+export declare function speedAt(profile: PaceProfile, along: number): number;