@johnmorrisdotca/kyogijo-stadiums 0.61.0 → 0.63.0

package/dist/replay.board.js

@@ -1,6 +1,7 @@
 // What a scoreboard shows of a replayed game at a time: the score, the period and the game clock, worked out from the same timeline the replay plays (its goals and its periods). Pure: a timeline and a time
 // give the same board every time, so a seek, a step and a period's button all land on the right figures at once, and a replay that goes back finds the score as it was. The 3D view draws it on the scoreboard
 // hung over the surface (`turn.replay.ts`); a page that draws its own board reads it the same way.
+import { deadSeconds, stoppageAt } from "./replay.deadtime.js";
 import { replayEvents, replayInfo } from "./replay.js";
 const isNum = (value) => typeof value === "number" && Number.isFinite(value);
 const two = (n) => String(n).padStart(2, "0");
@@ -19,9 +20,106 @@ export function replayPeriods(timeline) {
     return [...given].sort((a, b) => a.start - b.start).map((p, i) => ({ ...p, number: isNum(p.number) ? p.number : i + 1 }));
 }
 /**
- * The scoreboard of a replay at a time `t`, in seconds on the timeline's clock. The score is the goals at or before it; the period is the last one that has begun (the first, before any has);
- * the clock runs through the period from its full length to nothing, or from nothing up when the timeline counts `up`. A period with a `length` of its own runs its clock through that many
- * seconds however long it lasts on the timeline, so a game re-timed to minutes can read like the real one.
+ * The game clock at a time `t` on the replay's clock: the period it is in (the last that has begun; the first, before any has) and how much of it has been played. The game clock runs only while play is
+ * on: it stands still in each of the timeline's `stoppages`, while the replay's clock moves on through it. A period's `length` is spread over the seconds of it that are not in a stoppage, so a game
+ * re-timed to minutes reads like the real one. Pure.
+ * @example
+ * ```ts
+ * import { replayGameClock } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * const timeline = {
+ *   frames: [{ t: 0, objects: [] }, { t: 70, objects: [] }],
+ *   periods: [{ start: 0, end: 70, length: 1200 }],
+ *   stoppages: [{ start: 30, end: 40, reason: "goal" }],
+ * };
+ * const at = (t: number) => { const c = replayGameClock(timeline, t); return `${c.played} ${c.running}`; };
+ * console.log(at(15), at(30), at(35), at(40), at(55));
+ * // 300 true 600 false 600 false 600 true 900 true
+ * ```
+ */
+export function replayGameClock(timeline, t) {
+    const periods = replayPeriods(timeline);
+    let at = periods[0];
+    for (const p of periods)
+        if (p.start <= t)
+            at = p;
+    const live = at.end - at.start - deadSeconds(timeline, at.start, at.end);
+    const into = Math.min(at.end, Math.max(at.start, t));
+    const gone = into - at.start - deadSeconds(timeline, at.start, into);
+    const share = live > 0 ? Math.min(1, Math.max(0, gone / live)) : 0;
+    const length = isNum(at.length) && at.length > 0 ? at.length : live;
+    const stoppage = stoppageAt(timeline, t);
+    const played = share * length;
+    const running = stoppage === undefined && t >= at.start && t < at.end;
+    return { ...(at.number === undefined ? {} : { period: at.number }), played, left: length - played, running, ...(stoppage === undefined ? {} : { stoppage }) };
+}
+/**
+ * The game time at `t` on the replay's clock: the seconds of game clock played since the first period began (the lengths of the periods before, and what has been played of this one). It stands still in a
+ * stoppage, as the game clock does: a penalty's two minutes are two minutes of it.
+ */
+export function replayGameTime(timeline, t) {
+    const periods = replayPeriods(timeline);
+    let before = 0;
+    for (const p of periods) {
+        if (p.end > t)
+            break;
+        const next = periods[periods.indexOf(p) + 1];
+        if (next === undefined || next.start > t)
+            break;
+        before += isNum(p.length) && p.length > 0 ? p.length : p.end - p.start - deadSeconds(timeline, p.start, p.end);
+    }
+    return before + replayGameClock(timeline, t).played;
+}
+/** The penalties of a timeline, each checked: a side, a start and minutes that are numbers. Kept for the next call. */
+const PENALTIES = new WeakMap();
+export function replayPenalties(timeline) {
+    const hit = PENALTIES.get(timeline);
+    if (hit !== undefined)
+        return hit;
+    const given = Array.isArray(timeline.penalties) ? timeline.penalties : [];
+    const out = given.filter((p) => typeof p === "object" && p !== null && (p.team === "home" || p.team === "away") && isNum(p.start) && isNum(p.minutes) && p.minutes > 0 && (p.end === undefined || (isNum(p.end) && p.end >= p.start))).map((p) => ({ ...p }));
+    PENALTIES.set(timeline, out);
+    return out;
+}
+/**
+ * The penalties being served at `t` (the player is in the box: from the call to his `end`) with the game seconds left of each, and each side's skaters on the ice: five, less one for each penalty that
+ * makes it play short, never fewer than three. A penalty's time left is the game clock from now to its `end` (it runs only while the game clock does), or, with no end or one a power-play goal
+ * brought early (`endedBy: "goal"`), its minutes from the drop after the call. Pure.
+ * @example
+ * ```ts
+ * import { penaltiesAt } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * const timeline = {
+ *   frames: [{ t: 0, objects: [] }, { t: 60, objects: [] }],
+ *   periods: [{ start: 0, end: 60, length: 1200 }],
+ *   penalties: [{ team: "away" as const, by: "a4", start: 10, end: 16, minutes: 2 }],
+ * };
+ * const at = penaltiesAt(timeline, 12);
+ * console.log(at.strength, at.served.map((s) => `${s.penalty.by} ${s.left}`), penaltiesAt(timeline, 16).strength);
+ * // [ 5, 4 ] [ 'a4 80' ] [ 5, 5 ]
+ * ```
+ */
+export function penaltiesAt(timeline, t) {
+    const served = [];
+    const short = { home: 0, away: 0 };
+    const now = replayGameTime(timeline, t);
+    for (const p of replayPenalties(timeline)) {
+        if (p.start > t || (p.end !== undefined && p.end <= t))
+            continue;
+        const full = p.minutes * 60;
+        // Its time left: to its end on the game clock (a penalty that waited for a side two short begins its count later), or, with no end or one a power-play goal brought early, its minutes from the call.
+        const left = p.end !== undefined && p.endedBy !== "goal" ? Math.min(full, replayGameTime(timeline, p.end) - now) : full - (now - replayGameTime(timeline, p.start));
+        if (left <= 0 && p.end === undefined)
+            continue;
+        served.push({ penalty: p, left: Math.max(0, left) });
+        if (p.short !== false)
+            short[p.team] += 1;
+    }
+    return { served, strength: [Math.max(3, 5 - short.home), Math.max(3, 5 - short.away)] };
+}
+/**
+ * The scoreboard of a replay at a time `t`, in seconds on the timeline's clock. The score is the goals at or before it; the period and the clock are the game clock's (`replayGameClock`): the clock runs
+ * through the period from its full length to nothing, or from nothing up when the timeline counts `up`, and stands still in a stoppage. A period with a `length` of its own runs its clock through that many
+ * seconds however long it lasts on the timeline, so a game re-timed to minutes can read like the real one. A timeline with `penalties` adds each side's `strength` and the penalties being served,
+ * with their time left (`penaltiesAt`).
  * @example
  * ```ts
  * import { replayBoard } from "@johnmorrisdotca/kyogijo-stadiums/replay";
@@ -48,15 +146,17 @@ export function replayBoard(timeline, t) {
         if (e.kind === "goal" && (e.team === "home" || e.team === "away"))
             score[e.team === "home" ? 0 : 1] += 1;
     }
-    const periods = replayPeriods(timeline);
-    let at = periods[0];
-    for (const p of periods)
-        if (p.start <= t)
-            at = p;
-    const span = at.end - at.start;
-    const share = span > 0 ? Math.min(1, Math.max(0, (t - at.start) / span)) : 0;
-    const length = isNum(at.length) && at.length > 0 ? at.length : span;
+    const game = replayGameClock(timeline, t);
     // Down: the time left, rounded up, so that the full length shows until the period has moved and nothing shows only at its end. Up: the whole seconds gone.
-    const clock = timeline.clock === "up" ? boardClock(share * length) : boardClock(Math.ceil((1 - share) * length - 1e-9));
-    return at.number === undefined ? { score, clock } : { score, period: at.number, clock };
+    const clock = timeline.clock === "up" ? boardClock(game.played) : boardClock(Math.ceil(game.left - 1e-9));
+    const board = game.period === undefined ? { score, clock } : { score, period: game.period, clock };
+    if (replayPenalties(timeline).length > 0) {
+        const { served, strength } = penaltiesAt(timeline, t);
+        board.strength = strength;
+        board.penalties = served
+            .map((s) => ({ team: s.penalty.team, left: boardClock(Math.ceil(s.left - 1e-9)), short: s.penalty.short !== false, seconds: s.left }))
+            .sort((a, b) => Number(b.short) - Number(a.short) || a.seconds - b.seconds)
+            .map(({ team, left, short }) => ({ team, left, short }));
+    }
+    return board;
 }

package/dist/replay.d.ts

@@ -44,7 +44,7 @@ export declare function interpolate(timeline: ReplayTimeline, t: number, options
 }): ReplayObject[];
 /**
  * The path each object took over the last `seconds` before `t`, oldest place first and ending at its place at `t`: the frames in between, and the places at the two ends.
- * Only objects that are there at `t` have a trail. `teams` and `ids` choose whose; all by default.
+ * Only objects that are there at `t` have a trail, and it begins after the last frame the object was not in (a dead puck out of sight). `teams` and `ids` choose whose; all by default.
  * @example
  * ```ts
  * import { trails } from "@johnmorrisdotca/kyogijo-stadiums/replay";

package/dist/replay.deadtime.d.ts

@@ -0,0 +1,58 @@
+import type { ReplayObject, ReplayStoppage, ReplayTimeline } from "./replay.types.ts";
+type P = readonly [number, number];
+/**
+ * The stoppages of a timeline, in order, each checked: a `start` and an `end` that are numbers, the end not before the start. Ones that overlap are joined. Read once and kept.
+ * @example
+ * ```ts
+ * import { replayStoppages } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * const frames = [{ t: 0, objects: [] }];
+ * console.log(replayStoppages({ frames, stoppages: [{ start: 9, end: 12 }, { start: 2, end: 5, reason: "goal" }, { start: 4, end: 6 }, { start: 8, end: 7 }] }));
+ * // [ { start: 2, end: 6, reason: 'goal' }, { start: 9, end: 12 } ]
+ * ```
+ */
+export declare function replayStoppages(timeline: ReplayTimeline): readonly ReplayStoppage[];
+/** The stoppage a time is in (from its start, up to but not at its end, when play starts again), or `undefined` while play is on. */
+export declare function stoppageAt(timeline: ReplayTimeline, t: number): ReplayStoppage | undefined;
+/** The seconds of a span of the timeline's clock that were dead: the parts of it in stoppages. */
+export declare function deadSeconds(timeline: ReplayTimeline, from: number, to: number): number;
+/**
+ * The restarts that went by while the clock moved from `from` to `to` (`(from, to]`): the stoppages whose end, the drop of the puck, is in it. What a page plays the drop's sound on, as it plays the
+ * horn on a goal of `eventsBetween`.
+ */
+export declare function restartsBetween(timeline: ReplayTimeline, from: number, to: number): readonly ReplayStoppage[];
+/** How a sport's dead time goes: the speed the players go at and how long each part lasts, by the reason for the stoppage. */
+export interface DeadTimeRules {
+    /** The fastest a player goes to his place, in the timeline's units a second. */
+    speed: number;
+    /** Seconds after play stops before anyone heads for the restart: a goal is celebrated, a whistle is a moment. */
+    pause(reason: string): number;
+    /** Seconds after play stops that the dead ball or puck is still seen where it stopped; then it is out of sight until the restart. */
+    shown(reason: string): number;
+    /** The shortest time the players take to get to their places, and how long they stand in them before the restart. */
+    least: number;
+    hold: number;
+    /** Where a player who comes off goes, and one who comes on comes from (the bench's gate), or `undefined` for none: then they only go and come at the restart. */
+    bench?(object: ReplayObject): P | undefined;
+    /** Is it the ball or the puck: dead in the stoppage, out of sight until the restart. */
+    dead(object: ReplayObject): boolean;
+}
+/** A stoppage to write into a timeline: play stops at `t`; the timeline's frames from `until` on (the players in their places, the puck on the dot) are the restart. */
+export interface DeadStop {
+    t: number;
+    /** The time on the timeline given of the restart's frame: `t` and `until` are moved apart by the dead time, what was between them is left out, and the instant between them becomes part of the stoppage. 0.04 seconds after `t` by default. */
+    until?: number;
+    reason: string;
+    /** Where play starts again. */
+    x?: number;
+    y?: number;
+    team?: "home" | "away";
+}
+/**
+ * Write stoppages into a timeline. The timeline given has each stoppage as an instant: the play up to `t`, then at `until` the restart (the players in their places, the puck on the dot). Each is
+ * opened into the dead time the rules give: the puck stays where it stopped for a moment and is then out of sight, the players stand a moment (a goal is celebrated) and then go to their places at the
+ * rules' speed or slower (all getting there together, the farthest at the rules' speed), a player going off goes to the bench and the one coming on comes from it, and they stand in their places a
+ * moment before the restart. Everything after is moved on by the dead time; the periods with it (each keeps its length on the game clock), the events, the stoppages already there and the
+ * penalties. Pure.
+ */
+export declare function addDeadTime(timeline: ReplayTimeline, stops: readonly DeadStop[], rules: DeadTimeRules): ReplayTimeline;
+export {};

package/dist/replay.deadtime.js

@@ -0,0 +1,169 @@
+// Dead time: the stoppages of a replay. A stoppage stops the game clock (the board's) while the replay's own clock moves on; in it the ball or the puck is dead (it stays where play stopped,
+// then is out of sight until the restart) and the players go to their places for the restart at a speed a player would. The functions here are pure and know no sport: a sport's rule set
+// (`replay.hockey.ts` for the rink) says where play starts again, how long each part of the dead time lasts and how fast the players go, and `addDeadTime` writes the stoppages into a timeline.
+import { interpolate } from "./replay.js";
+const isNum = (value) => typeof value === "number" && Number.isFinite(value);
+const CLEAN = new WeakMap();
+/**
+ * The stoppages of a timeline, in order, each checked: a `start` and an `end` that are numbers, the end not before the start. Ones that overlap are joined. Read once and kept.
+ * @example
+ * ```ts
+ * import { replayStoppages } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * const frames = [{ t: 0, objects: [] }];
+ * console.log(replayStoppages({ frames, stoppages: [{ start: 9, end: 12 }, { start: 2, end: 5, reason: "goal" }, { start: 4, end: 6 }, { start: 8, end: 7 }] }));
+ * // [ { start: 2, end: 6, reason: 'goal' }, { start: 9, end: 12 } ]
+ * ```
+ */
+export function replayStoppages(timeline) {
+    const hit = CLEAN.get(timeline);
+    if (hit !== undefined)
+        return hit;
+    const given = Array.isArray(timeline.stoppages) ? timeline.stoppages : [];
+    const sorted = given
+        .filter((s) => typeof s === "object" && s !== null && isNum(s.start) && isNum(s.end) && s.end >= s.start)
+        .map((s) => ({ ...s }))
+        .sort((a, b) => a.start - b.start);
+    const out = [];
+    for (const s of sorted) {
+        const last = out[out.length - 1];
+        if (last !== undefined && s.start <= last.end)
+            last.end = Math.max(last.end, s.end);
+        else
+            out.push(s);
+    }
+    CLEAN.set(timeline, out);
+    return out;
+}
+/** The stoppage a time is in (from its start, up to but not at its end, when play starts again), or `undefined` while play is on. */
+export function stoppageAt(timeline, t) {
+    for (const s of replayStoppages(timeline)) {
+        if (s.start > t)
+            return undefined;
+        if (t < s.end)
+            return s;
+    }
+    return undefined;
+}
+/** The seconds of a span of the timeline's clock that were dead: the parts of it in stoppages. */
+export function deadSeconds(timeline, from, to) {
+    let dead = 0;
+    for (const s of replayStoppages(timeline)) {
+        if (s.start >= to)
+            break;
+        dead += Math.max(0, Math.min(to, s.end) - Math.max(from, s.start));
+    }
+    return dead;
+}
+/**
+ * The restarts that went by while the clock moved from `from` to `to` (`(from, to]`): the stoppages whose end, the drop of the puck, is in it. What a page plays the drop's sound on, as it plays the
+ * horn on a goal of `eventsBetween`.
+ */
+export function restartsBetween(timeline, from, to) {
+    return replayStoppages(timeline).filter((s) => s.end > from && s.end <= to);
+}
+const round2 = (n) => Math.round(n * 100) / 100;
+const round1 = (n) => Math.round(n * 10) / 10;
+const ceil2 = (n) => Math.ceil(n * 100 - 1e-6) / 100;
+const dist = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1]);
+const placeOn = (path, t) => {
+    if (t < path.from || t >= path.until)
+        return undefined;
+    let at = path.legs[0].a;
+    for (const leg of path.legs) {
+        if (t < leg.t0)
+            break;
+        if (t >= leg.t1)
+            at = leg.b;
+        else {
+            const f = leg.t1 > leg.t0 ? (t - leg.t0) / (leg.t1 - leg.t0) : 1;
+            return [leg.a[0] + (leg.b[0] - leg.a[0]) * f, leg.a[1] + (leg.b[1] - leg.a[1]) * f];
+        }
+    }
+    return at;
+};
+/**
+ * Write stoppages into a timeline. The timeline given has each stoppage as an instant: the play up to `t`, then at `until` the restart (the players in their places, the puck on the dot). Each is
+ * opened into the dead time the rules give: the puck stays where it stopped for a moment and is then out of sight, the players stand a moment (a goal is celebrated) and then go to their places at the
+ * rules' speed or slower (all getting there together, the farthest at the rules' speed), a player going off goes to the bench and the one coming on comes from it, and they stand in their places a
+ * moment before the restart. Everything after is moved on by the dead time; the periods with it (each keeps its length on the game clock), the events, the stoppages already there and the
+ * penalties. Pure.
+ */
+export function addDeadTime(timeline, stops, rules) {
+    // Each period's length on the game clock, before the dead time stretches it: a period that had none keeps the live seconds it had.
+    const periods = timeline.periods?.map((p) => ({ ...p, length: isNum(p.length) ? p.length : p.end - p.start - deadSeconds(timeline, p.start, p.end) }));
+    let frames = [...timeline.frames];
+    let events = [...(timeline.events ?? [])];
+    let stoppages = [...replayStoppages(timeline)];
+    // The last first, so that a stoppage does not move the ones before it.
+    const order = [...stops].filter((s) => isNum(s.t)).sort((a, b) => b.t - a.t);
+    let pers = periods;
+    let penalties = timeline.penalties?.map((p) => ({ ...p }));
+    for (const stop of order) {
+        const t0 = stop.t;
+        const u = isNum(stop.until) && stop.until > t0 ? stop.until : t0 + 0.04;
+        const view = { ...timeline, frames, events: [] };
+        const at = new Map(interpolate(view, t0).map((o) => [o.id, o]));
+        const next = new Map(interpolate(view, u).map((o) => [o.id, o]));
+        const pause = round2(Math.max(0, rules.pause(stop.reason)));
+        const shown = round2(Math.max(0, rules.shown(stop.reason)));
+        // The players: who stays on, who goes off and who comes on, and how far each goes.
+        const stay = [];
+        const off = [];
+        const on = [];
+        for (const [id, o] of at) {
+            if (rules.dead(o))
+                continue;
+            const b = next.get(id);
+            if (b !== undefined)
+                stay.push([o, [o.x, o.y], [b.x, b.y]]);
+            else
+                off.push([o, [o.x, o.y], rules.bench?.(o)]);
+        }
+        for (const [id, o] of next)
+            if (!rules.dead(o) && !at.has(id))
+                on.push([o, rules.bench?.(o), [o.x, o.y]]);
+        const leave = Math.max(0, ...off.map(([, a, b]) => (b === undefined ? 0 : dist(a, b) / rules.speed)));
+        const swap = off.length > 0 || on.length > 0 ? ceil2(pause + leave) : pause;
+        const come = Math.max(0, ...on.map(([, a, b]) => (a === undefined ? 0 : dist(a, b) / rules.speed)));
+        const skate = Math.max(...stay.map(([, a, b]) => dist(a, b) / rules.speed), 0);
+        const arrive = ceil2(Math.max(pause + Math.max(rules.least, skate), on.length > 0 ? round2(swap + 0.04) + come : 0));
+        const total = round2(Math.max(arrive + rules.hold, shown + 1));
+        // The paths.
+        const paths = [];
+        for (const [object, a, b] of stay)
+            paths.push({ object, from: 0, until: Infinity, legs: [{ t0: 0, t1: pause, a, b: a }, { t0: pause, t1: arrive, a, b }] });
+        for (const [object, a, b] of off)
+            paths.push({ object, from: 0, until: b === undefined ? swap : round2(swap + 0.04), legs: [{ t0: 0, t1: pause, a, b: a }, { t0: pause, t1: swap, a, b: b ?? a }] });
+        for (const [object, a, b] of on)
+            paths.push({ object, from: a === undefined ? arrive : round2(swap + 0.04), until: Infinity, legs: [{ t0: round2(swap + 0.04), t1: arrive, a: a ?? b, b }] });
+        const deadOnes = [...at.values()].filter((o) => rules.dead(o));
+        const changes = off.length > 0 || on.length > 0 ? [swap, round2(swap + 0.04)] : [];
+        const moments = [...new Set([0, pause, shown, ...changes, arrive].map(round2))].filter((m) => m >= 0 && m < total).sort((a, b) => a - b);
+        const inserted = moments.map((m) => {
+            const objects = [];
+            for (const path of paths) {
+                const p = placeOn(path, m);
+                if (p !== undefined)
+                    objects.push({ ...path.object, x: round1(p[0]), y: round1(p[1]) });
+            }
+            // The dead puck: where it stopped, and out of sight from `shown` on.
+            if (m < shown)
+                for (const o of deadOnes)
+                    objects.push({ ...o });
+            return { t: round2(t0 + m), objects };
+        });
+        // The restart: the frame given at `until`, and everything after it, moved on.
+        const shift = round2(t0 + total - u);
+        const move = (t) => (t >= u ? round2(t + shift) : t > t0 ? t0 : t);
+        const restart = { t: round2(t0 + total), objects: [...next.values()] };
+        frames = [...frames.filter((f) => f.t < t0), ...inserted, restart, ...frames.filter((f) => f.t > u).map((f) => ({ ...f, t: move(f.t) }))];
+        events = events.map((e) => ({ ...e, t: move(e.t), ...(isNum(e.until) ? { until: move(e.until) } : {}) }));
+        stoppages = [
+            ...stoppages.map((s) => ({ ...s, start: move(s.start), end: move(s.end) })),
+            { start: t0, end: round2(t0 + total), reason: stop.reason, ...(isNum(stop.x) && isNum(stop.y) ? { x: stop.x, y: stop.y } : {}), ...(stop.team === undefined ? {} : { team: stop.team }) },
+        ].sort((a, b) => a.start - b.start);
+        pers = pers?.map((p) => ({ ...p, start: move(p.start), end: move(p.end) }));
+        penalties = penalties?.map((p) => ({ ...p, start: move(p.start), ...(isNum(p.end) ? { end: move(p.end) } : {}) }));
+    }
+    return { ...timeline, frames, events: events.sort((a, b) => a.t - b.t), stoppages, ...(pers === undefined ? {} : { periods: pers }), ...(penalties === undefined ? {} : { penalties }) };
+}

package/dist/replay.feed.d.ts

@@ -0,0 +1,54 @@
+import type { FeedFormat, FeedGame } from "./feeds.core.ts";
+import type { FeedError } from "./feeds.core.ts";
+import type { FeedFollowState } from "./feeds.fetch.ts";
+import type { KyogijoReplay } from "./mount.ts";
+import type { ReplaySettings, ReplayTimeline } from "./replay.types.ts";
+/** What a feed played from an address can be told: its format, the replay's settings, and for a test the function that fetches. */
+export interface FeedReplayOptions {
+    format?: FeedFormat;
+    settings?: ReplaySettings;
+    base?: string;
+    signal?: AbortSignal;
+    fetch?: (input: string, init?: RequestInit) => Promise<Response>;
+}
+/** A replay of a feed: the replay's controller, and the game the feed was read into. */
+export type FeedReplay = KyogijoReplay & {
+    feed: FeedGame;
+};
+/** What a live follow can be told, beyond `FeedReplayOptions`. */
+export interface ReplayFollowOptions extends FeedReplayOptions {
+    /** Seconds between asks: 15 by default, never less than 10. */
+    every?: number;
+    /** Each new answer, after it is played. */
+    onGame?: (game: FeedGame, replay: KyogijoReplay) => void;
+    onError?: (error: FeedError) => void;
+    onState?: (state: FeedFollowState) => void;
+    /** The document whose visibility it follows: the page's by default. */
+    doc?: Document;
+}
+/** A replay that follows a feed live: the replay playing now (a new one on each answer that changed), the follow's state, and `stop`, which stops asking and leaves the replay. */
+export interface ReplayFollow {
+    replay(): KyogijoReplay | undefined;
+    state(): FeedFollowState;
+    stop(): void;
+}
+/** A mount's or a view's `replay`: play a timeline, or a feed from an address. */
+export interface ReplayCall {
+    (timeline: ReplayTimeline, settings?: ReplaySettings): KyogijoReplay;
+    /**
+     * Fetch a feed from an address, by the reader's browser (no server of ours, no cookie, nothing kept), read it (`readFeed`: kyogijo's open timeline, or an NHL-style play-by-play) and play it. Rejects with a
+     * `FeedError` that says what was wrong: a server that does not let the page read it (`cors`), a status (`http`), an answer that is not a feed (`format`).
+     */
+    fromUrl(url: string, options?: FeedReplayOptions): Promise<FeedReplay>;
+    /** Follow a feed live: ask it every 15 seconds or more while the page is shown, play each answer that changed from where the replay was (or at its newest moment, when it was there), and stop when the game is over or the server says no. */
+    follow(url: string, options?: ReplayFollowOptions): ReplayFollow;
+}
+/** What `feeds.dom.ts` lends a `replay`. */
+export interface FeedKit {
+    fromUrl(play: (timeline: ReplayTimeline, settings?: ReplaySettings) => KyogijoReplay, url: string, options?: FeedReplayOptions): Promise<FeedReplay>;
+    follow(play: (timeline: ReplayTimeline, settings?: ReplaySettings) => KyogijoReplay, url: string, options?: ReplayFollowOptions): ReplayFollow;
+}
+/** Put the feeds' code in: called once by `feeds.dom.ts`. */
+export declare function useFeedKit(next: FeedKit): void;
+/** A `replay` with `fromUrl` and `follow` on it. */
+export declare function withFeeds(play: (timeline: ReplayTimeline, settings?: ReplaySettings) => KyogijoReplay): ReplayCall;

package/dist/replay.feed.js

@@ -0,0 +1,17 @@
+let kit;
+/** Put the feeds' code in: called once by `feeds.dom.ts`. */
+export function useFeedKit(next) {
+    kit = next;
+}
+const need = () => {
+    if (kit === undefined)
+        throw new Error("the feeds are not loaded: import \"@johnmorrisdotca/kyogijo-stadiums/feeds\" once, before replay.fromUrl or replay.follow");
+    return kit;
+};
+/** A `replay` with `fromUrl` and `follow` on it. */
+export function withFeeds(play) {
+    return Object.assign(play, {
+        fromUrl: (url, options) => need().fromUrl(play, url, options),
+        follow: (url, options) => need().follow(play, url, options),
+    });
+}

package/dist/replay.hockey.d.ts

@@ -0,0 +1,143 @@
+import type { DeadTimeRules } from "./replay.deadtime.ts";
+/** Why play stopped, in hockey: each says where it starts again. */
+export type HockeyStop = "goal" | "save" | "frozen" | "icing" | "offside" | "penalty" | "whistle" | "period-start" | "period-end";
+/** The nine face-off spots, feet from centre ice (NHL Rule 1.9): centre, the four in the neutral zone (5 feet outside the blue lines, 44 feet apart) and the four in the end zones (20 feet out from the goal lines, 44 feet apart). */
+export declare const HOCKEY_DOTS: readonly (readonly [number, number])[];
+/** The blue lines are 25 feet either side of centre: past one, play is in an end zone. */
+export declare const HOCKEY_BLUE_LINE = 25;
+/** Is a place one of the nine face-off spots (to a tenth of a foot)? */
+export declare const isHockeyDot: (x: number, y: number) => boolean;
+/** Where play stopped and why, to say where it starts again. */
+export interface HockeyStopAt {
+    reason: HockeyStop | string;
+    /** Where play stopped: the puck's place, or for a save the place the shot came from. Centre ice when not given. */
+    x?: number;
+    y?: number;
+    /** For icing, offside and a penalty: the end the side it was called against defends, as the sign of its goal line's x (-1 for the left end, 1 for the right). */
+    defends?: 1 | -1;
+}
+/**
+ * The face-off spot play starts again at after a stoppage, by NHL rule: centre ice after a goal and at the start of a period; after a save or a frozen puck, the end-zone spot of that end on the side
+ * the puck was (the nearest spot in the zone); after icing and after a penalty, an end-zone spot of the end the offending side defends (Rules 81 and 76); after offside, the
+ * neutral-zone spot just outside the zone the offending side attacks (Rule 83); after any other whistle, the nearest spot in the zone where play stopped (an end-zone spot in an end, a neutral-zone
+ * spot between the blue lines, never centre ice). An end-zone spot's side is the side of the rink the puck was on.
+ * @example
+ * ```ts
+ * import { hockeyFaceoffDot } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * console.log(hockeyFaceoffDot({ reason: "goal", x: 88, y: 2 }).join(), hockeyFaceoffDot({ reason: "save", x: 60, y: -18 }).join());
+ * console.log(hockeyFaceoffDot({ reason: "icing", x: 80, y: 30, defends: -1 }).join(), hockeyFaceoffDot({ reason: "offside", x: 26, y: 5, defends: -1 }).join());
+ * // 0,0 69,-22
+ * // -69,22 20,22
+ * ```
+ */
+export declare function hockeyFaceoffDot(stop: HockeyStopAt): readonly [number, number];
+/** The places of a face-off's line-up. */
+export type HockeyRole = "C" | "LW" | "RW" | "LD" | "RD" | "G";
+/**
+ * Where a side lines up for a face-off at a spot (NHL Rule 76), as `[x, y]` in feet from centre ice: `attacks` is the end it attacks (1 for the right). The centre stands on the dot a step back on his
+ * own side; the wingers on their own side of the circle's hash marks, outside it; the defence behind them (at the blue line when the spot is in the end the side attacks, in front of its own net when it
+ * is in its own end, a stride back from the wingers at centre and in the neutral zone); the goaltender in the crease. A left winger is on the left of a player facing the end his side attacks.
+ * @example
+ * ```ts
+ * import { hockeyFormation } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * const at = hockeyFormation([0, 0], 1);
+ * console.log(at.C.join(), at.LW.join(), at.G.join());
+ * // -2.5,0 -5,17 -85,0
+ * ```
+ */
+export declare function hockeyFormation(dot: readonly [number, number], attacks: 1 | -1): Record<HockeyRole, [number, number]>;
+/** The speeds and seconds of hockey's dead time in a replay, and where each side's bench is. */
+export declare const HOCKEY_DEAD_TIME: {
+    /** The fastest a player glides to his place, feet a second (about 12 miles an hour: a glide, not a sprint). */
+    readonly speed: 18;
+    /** Seconds before the players head for the face-off: a goal is celebrated. */
+    readonly pause: {
+        readonly goal: 2.5;
+        readonly other: 0.6;
+    };
+    /** Seconds the dead puck is seen where it stopped (in the net after a goal), then out of sight until the drop. */
+    readonly shown: {
+        readonly goal: 2.5;
+        readonly other: 1.2;
+    };
+    /** The least time the players take to their places, and the seconds they stand in them before the puck is dropped. */
+    readonly least: 2;
+    readonly hold: 1;
+    /** The line-up before the opening face-off of a period, seconds: the clock reads the period's full time until the drop. */
+    readonly lineUp: 1.5;
+    /** The players' benches' gates, on the side of negative y (the side the benches are on, as the arenas draw them): the home side's nearer the left end, the away side's the right. */
+    readonly bench: Record<"home" | "away", readonly [number, number]>;
+};
+/** Hockey's dead time as `addDeadTime` reads it: the puck is the dead one, and a player going off or coming on goes by his side's bench. */
+export declare const HOCKEY_RULES: DeadTimeRules;
+/**
+ * The stoppage a play of an NHL-style play-by-play is (`typeDescKey` and, for a `stoppage`, `details.reason`): `goal`, `penalty`, the rule set's word for the stoppage's reason, or `undefined` for a
+ * play that does not stop play (a shot, a hit, a delayed penalty, which play goes on through until the side it is against touches the puck).
+ * @example
+ * ```ts
+ * import { hockeyStopOf } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * console.log(hockeyStopOf("stoppage", "icing"), hockeyStopOf("stoppage", "puck-in-netting"), hockeyStopOf("goal"), hockeyStopOf("delayed-penalty"));
+ * // icing whistle goal undefined
+ * ```
+ */
+export declare function hockeyStopOf(typeDescKey: string, reason?: string): HockeyStop | undefined;
+/** The kinds of penalty, and their minutes on the game clock (NHL Rules 16 to 21: a minor 2, a double minor 4, a major 5, a misconduct 10; a bench minor is a minor served by a player the coach names). */
+export declare const HOCKEY_PENALTY_MINUTES: {
+    readonly minor: 2;
+    readonly "bench-minor": 2;
+    readonly "double-minor": 4;
+    readonly major: 5;
+    readonly misconduct: 10;
+};
+export type HockeyPenaltyKind = keyof typeof HOCKEY_PENALTY_MINUTES;
+/**
+ * The kind of a penalty of an NHL-style play-by-play (`details.typeCode` and `details.duration` of a `penalty`): `MIN` a minor (4 minutes of it a double minor), `BEN` a bench minor, `MAJ` a major,
+ * `MIS` and `GMIS` a misconduct; else by its minutes. `undefined` for a penalty shot or a match penalty, which this rule set does not play.
+ * @example
+ * ```ts
+ * import { hockeyPenaltyKind } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * console.log(hockeyPenaltyKind("MIN", 2), hockeyPenaltyKind("MIN", 4), hockeyPenaltyKind("BEN", 2), hockeyPenaltyKind("MAJ", 5), hockeyPenaltyKind("MIS", 10), hockeyPenaltyKind("PS", 0));
+ * // minor double-minor bench-minor major misconduct undefined
+ * ```
+ */
+export declare function hockeyPenaltyKind(typeCode?: string, duration?: number): HockeyPenaltyKind | undefined;
+/**
+ * Where a side's penalty box is, the seat its penalized player sits on, in the `nhl-api` frame: across the ice from the players' benches (NHL Rule 1: the two penalty boxes on the side opposite the
+ * benches, one each side of the off-ice officials' box at centre), the home side's on the left, behind the boards. A stand-in for the rink's own figures (the benches and boxes of the rink, KYOGIJO-
+ * STADIUMS-47) until they are in the package: then this reads them, and nothing that calls it changes.
+ */
+export declare function hockeyPenaltyBox(team: "home" | "away"): readonly [number, number];
+/** A call of a penalty, on the game clock: when (seconds of game played since the start), against which side, what kind. */
+export interface HockeyCall {
+    team: "home" | "away";
+    kind: HockeyPenaltyKind;
+    at: number;
+}
+/** When a penalty's time begins and ends on the game clock, and whether its side plays short. */
+export interface HockeyServed {
+    /** When its time begins: the call, or, for a side already two short, when one of those ends (it never plays with fewer than three skaters). */
+    from: number;
+    /** When the player leaves the box: his time ran out, or a power-play goal ended his minor. */
+    to: number;
+    short: boolean;
+    /** Ended by a power-play goal. */
+    byGoal: boolean;
+}
+/**
+ * How a game's penalties are served, by NHL rule, all on the game clock (seconds played since the start): each penalty's player sits from the call; a minor is 2 minutes, a double minor 4, a major 5 and a
+ * misconduct 10; his side plays a skater short (not for a misconduct, served by a substitute, nor for coincidental penalties, called on both sides at once and as many each, which leave the strength
+ * even); a side is never more than two short, so a third penalty's time waits for one of the first two to end; a goal by the side with more skaters ends the scored-on side's minor with the least time
+ * left (a double minor loses the part it is in; a major is served in full). Pure.
+ * @example
+ * ```ts
+ * import { hockeyPenaltyEnds } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * const calls = [{ team: "away" as const, kind: "minor" as const, at: 100 }, { team: "home" as const, kind: "major" as const, at: 400 }];
+ * const goals = [{ team: "home" as const, at: 160 }, { team: "away" as const, at: 500 }];
+ * console.log(hockeyPenaltyEnds(calls, goals).map((s) => `${s.from}-${s.to} ${s.short} ${s.byGoal}`).join(", "));
+ * // 100-160 true true, 400-700 true false
+ * ```
+ */
+export declare function hockeyPenaltyEnds(calls: readonly HockeyCall[], goals: readonly {
+    team: "home" | "away";
+    at: number;
+}[]): HockeyServed[];