@johnmorrisdotca/kyogijo-stadiums 0.61.0 → 0.63.0

package/dist/feeds.js

@@ -0,0 +1,211 @@
+// A feed of a game read into a replay: kyogijo's own open timeline (a bare timeline, or a game file with its sides and periods) or a play-by-play of a shape that is common, each read by a pure function of
+// its own (an adapter). The answer is the user's: it comes from a file they picked, text they pasted or an address they gave, and nothing in it is trusted. Every number is checked, every list is capped,
+// and a name is only ever text. Nothing here fetches: `feeds.fetch.ts` is the page's side.
+import { FEED_LIMITS, FeedError, feedText } from "./feeds.core.js";
+import { nhlPlayByPlay } from "./feeds.nhl.js";
+export { FEED_FORMATS, FEED_LIMITS, FeedError, feedText } from "./feeds.core.js";
+const TEAMS = ["home", "away", "ball", "puck", "official"];
+const isNum = (value) => typeof value === "number" && Number.isFinite(value);
+const isObj = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** A side of a feed's game, as a scoreboard writes it: its letters, name and colour as text. */
+const sideOf = (value) => {
+    if (!isObj(value))
+        return undefined;
+    const name = isObj(value.name) ? feedText(value.name.en ?? Object.values(value.name)[0]) : feedText(value.name);
+    const side = {};
+    const abbr = feedText(value.abbr, 8);
+    const color = feedText(value.color, 32);
+    if (abbr !== undefined)
+        side.abbr = abbr;
+    if (name !== undefined)
+        side.name = name;
+    if (color !== undefined && /^#[0-9a-f]{3,8}$/i.test(color))
+        side.color = color;
+    return side;
+};
+/** An object of a frame, checked: an id, a known team and a place, else nothing. */
+function objectOf(value) {
+    if (!isObj(value) || !isNum(value.x) || !isNum(value.y))
+        return undefined;
+    const id = feedText(value.id, 40);
+    const team = TEAMS.find((t) => t === value.team);
+    if (id === undefined || team === undefined)
+        return undefined;
+    const o = { id, team, x: value.x, y: value.y };
+    const label = feedText(value.label);
+    if (label !== undefined)
+        o.label = label;
+    if (isNum(value.number) || typeof value.number === "string")
+        o.number = typeof value.number === "string" ? (feedText(value.number, 4) ?? "") : value.number;
+    return o;
+}
+/** An event, checked: a time and a kind, and what else it has that is of the right type. */
+function eventOf(value) {
+    if (!isObj(value) || !isNum(value.t))
+        return undefined;
+    const kind = feedText(value.kind, 24);
+    if (kind === undefined)
+        return undefined;
+    const e = { t: value.t, kind };
+    if (value.team === "home" || value.team === "away")
+        e.team = value.team;
+    for (const key of ["x", "y", "x2", "y2", "until"])
+        if (isNum(value[key]))
+            e[key] = value[key];
+    for (const key of ["by", "to"]) {
+        const text = feedText(value[key], 40);
+        if (text !== undefined)
+            e[key] = text;
+    }
+    const label = feedText(value.label);
+    if (label !== undefined)
+        e.label = label;
+    return e;
+}
+/** A period, checked: a start and an end no earlier than it, and its number and game-clock length when they are numbers. */
+function periodOf(value) {
+    if (!isObj(value) || !isNum(value.start) || !isNum(value.end) || value.end < value.start)
+        return undefined;
+    return { start: value.start, end: value.end, ...(isNum(value.number) ? { number: value.number } : {}), ...(isNum(value.length) && value.length > 0 ? { length: value.length } : {}) };
+}
+/** A stoppage, checked: a start and an end no earlier than it, and its reason, the place of its restart and the side it was called against when they are of the right type. */
+function stoppageOf(value) {
+    if (!isObj(value) || !isNum(value.start) || !isNum(value.end) || value.end < value.start)
+        return undefined;
+    const s = { start: value.start, end: value.end };
+    const reason = feedText(value.reason, 24);
+    if (reason !== undefined)
+        s.reason = reason;
+    if (isNum(value.x))
+        s.x = value.x;
+    if (isNum(value.y))
+        s.y = value.y;
+    if (value.team === "home" || value.team === "away")
+        s.team = value.team;
+    return s;
+}
+/** A penalty, checked: a side, a start and its minutes on the game clock, and who serves it, when he leaves the box, its kind, whether his side plays short and whether a goal ended it, when they are of the right type. */
+function penaltyOf(value) {
+    if (!isObj(value) || (value.team !== "home" && value.team !== "away") || !isNum(value.start) || !isNum(value.minutes) || value.minutes <= 0)
+        return undefined;
+    const p = { team: value.team, start: value.start, minutes: value.minutes };
+    if (isNum(value.end) && value.end >= value.start)
+        p.end = value.end;
+    const by = feedText(value.by, 40);
+    if (by !== undefined)
+        p.by = by;
+    const kind = feedText(value.kind, 24);
+    if (kind !== undefined)
+        p.kind = kind;
+    if (typeof value.short === "boolean")
+        p.short = value.short;
+    if (value.endedBy === "goal")
+        p.endedBy = "goal";
+    return p;
+}
+const FROM = /^[a-z0-9-]{1,32}$/;
+/**
+ * Read kyogijo's own open timeline: a bare timeline (`{ frames, events?, periods?, stoppages?, penalties?, teams?, from? }`) or a game file (`{ kind: "kyogijo-game", sport, teams, periods, timeline }`, as
+ * `examples/games` has them). Every frame, object, event, period, stoppage and penalty is checked; what is not of the format is left out, and a timeline with no frame is an error.
+ */
+export function kyogijoFeed(json) {
+    if (!isObj(json))
+        throw new FeedError("format", "not a kyogijo timeline: the answer is not a JSON object");
+    const game = json.kind === "kyogijo-game" && isObj(json.timeline);
+    const source = game ? json.timeline : json;
+    if (!Array.isArray(source.frames))
+        throw new FeedError("format", "not a kyogijo timeline: it has no list of frames");
+    const frames = [];
+    for (const f of source.frames.slice(0, FEED_LIMITS.frames)) {
+        if (!isObj(f) || !isNum(f.t) || !Array.isArray(f.objects))
+            continue;
+        const objects = f.objects.slice(0, FEED_LIMITS.objects).map(objectOf).filter((o) => o !== undefined);
+        const frame = { t: f.t, objects };
+        if (f.possession === null || typeof f.possession === "string")
+            frame.possession = f.possession === null ? null : feedText(f.possession, 40) ?? null;
+        frames.push(frame);
+    }
+    if (frames.length === 0)
+        throw new FeedError("empty", "the timeline has no frame to play");
+    const events = (Array.isArray(source.events) ? source.events.slice(0, FEED_LIMITS.events) : []).map(eventOf).filter((e) => e !== undefined);
+    const periodsIn = game ? json.periods : source.periods;
+    const periods = (Array.isArray(periodsIn) ? periodsIn.slice(0, FEED_LIMITS.periods) : []).map(periodOf).filter((p) => p !== undefined);
+    const stoppages = (Array.isArray(source.stoppages) ? source.stoppages.slice(0, FEED_LIMITS.stoppages) : [])
+        .map(stoppageOf)
+        .filter((s) => s !== undefined)
+        .sort((a, b) => a.start - b.start);
+    const penalties = (Array.isArray(source.penalties) ? source.penalties.slice(0, FEED_LIMITS.penalties) : [])
+        .map(penaltyOf)
+        .filter((p) => p !== undefined)
+        .sort((a, b) => a.start - b.start);
+    const teamsIn = game ? json.teams : source.teams;
+    const home = isObj(teamsIn) ? sideOf(teamsIn.home) : undefined;
+    const away = isObj(teamsIn) ? sideOf(teamsIn.away) : undefined;
+    const timeline = {
+        frames,
+        events,
+        ...(typeof source.from === "string" && FROM.test(source.from) ? { from: source.from } : {}),
+        ...(periods.length > 0 ? { periods } : {}),
+        ...(source.clock === "up" || source.clock === "down" ? { clock: source.clock } : {}),
+        ...(stoppages.length > 0 ? { stoppages } : {}),
+        ...(penalties.length > 0 ? { penalties } : {}),
+    };
+    const players = {};
+    const rosters = game && isObj(json.rosters) ? json.rosters : {};
+    for (const side of ["home", "away"]) {
+        const roster = rosters[side];
+        if (!Array.isArray(roster))
+            continue;
+        for (const p of roster.slice(0, 80)) {
+            const id = isObj(p) ? feedText(p.id, 40) : undefined;
+            if (id === undefined || !isObj(p))
+                continue;
+            const name = isObj(p.name) ? feedText(p.name.en ?? Object.values(p.name)[0]) : feedText(p.name);
+            players[id] = { side, ...(isNum(p.number) ? { number: p.number } : {}), ...(name === undefined ? {} : { name }) };
+        }
+    }
+    const sport = game ? feedText(json.sport, 24) : undefined;
+    return { format: "kyogijo", ...(sport === undefined ? {} : { sport }), timeline, teams: { home: home ?? {}, away: away ?? {} }, ended: true, players };
+}
+/** Which format a feed's answer is in: a timeline or a game file of kyogijo's, or a play-by-play shaped as the NHL's. `undefined` when it is neither. */
+export function feedFormatOf(json) {
+    if (!isObj(json))
+        return undefined;
+    if (json.kind === "kyogijo-game" || Array.isArray(json.frames))
+        return "kyogijo";
+    if (Array.isArray(json.plays) && (isObj(json.homeTeam) || isObj(json.awayTeam)))
+        return "nhl";
+    return undefined;
+}
+/**
+ * Read a feed's answer into a game: in the format asked, or the one `feedFormatOf` finds. Throws a `FeedError` (`format`, `empty`) that says what was wrong in plain words.
+ * @example
+ * ```ts
+ * import { readFeed } from "@johnmorrisdotca/kyogijo-stadiums/feeds";
+ * const answer = { frames: [{ t: 0, objects: [{ id: "puck", team: "puck", x: 0, y: 0 }] }, { t: 30, objects: [{ id: "puck", team: "puck", x: 80, y: 4 }] }], events: [{ t: 30, kind: "goal", team: "home" }], from: "nhl-api" };
+ * const game = readFeed(answer);
+ * console.log(game.format, game.timeline.frames.length, game.timeline.events?.length);
+ * try { readFeed({ hello: "world" }); } catch (error) { console.log((error as Error).name, (error as { kind?: string }).kind); }
+ * // kyogijo 2 1
+ * // FeedError format
+ * ```
+ */
+export function readFeed(json, format = "auto") {
+    const as = format === "auto" ? feedFormatOf(json) : format;
+    if (as === "kyogijo")
+        return kyogijoFeed(json);
+    if (as === "nhl")
+        return nhlPlayByPlay(json);
+    throw new FeedError("format", "not a feed this package reads: neither a kyogijo timeline nor an NHL-style play-by-play");
+}
+/** Read text (a file or what was pasted) as JSON and then as a feed. */
+export function readFeedText(text, format = "auto") {
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        throw new FeedError("format", "not JSON: the text could not be read");
+    }
+    return readFeed(json, format);
+}

package/dist/feeds.nhl.d.ts

@@ -0,0 +1,28 @@
+import { type FeedGame } from "./feeds.core.ts";
+/** A regulation period, and an overtime in the regular season (the playoffs play twenty-minute overtimes): seconds. */
+export declare const NHL_PERIOD = 1200;
+export declare const NHL_OVERTIME = 300;
+/**
+ * Read a play-by-play shaped as the NHL's public one into a game: the puck's places at the plays that have one (between them it moves in a straight line), a mark for each shot, goal and whistle, the periods with their
+ * clocks (a twenty-minute period, the board counting it down, an overtime of five minutes in the regular season and twenty in the playoffs, the shoot-out left out), each side's letters and name from the feed, and the players it names
+ * (by `p` and their id). Times are the game's, so the board's clock is the game's: period 2 starts at 1200 s. Throws a `FeedError` when it is not of the shape, or has no play with a place.
+ * @example
+ * ```ts
+ * import { nhlPlayByPlay } from "@johnmorrisdotca/kyogijo-stadiums/feeds";
+ * const answer = {
+ *   gameState: "LIVE", gameType: 2,
+ *   homeTeam: { id: 1, abbrev: "AAA", commonName: { default: "Aardvarks" } }, awayTeam: { id: 2, abbrev: "BBB" },
+ *   plays: [
+ *     { periodDescriptor: { number: 1, periodType: "REG" }, timeInPeriod: "00:00", typeDescKey: "faceoff", sortOrder: 1, details: { xCoord: 0, yCoord: 0 } },
+ *     { periodDescriptor: { number: 1, periodType: "REG" }, timeInPeriod: "01:30", typeDescKey: "goal", sortOrder: 2, details: { xCoord: 80, yCoord: -4, eventOwnerTeamId: 1, scoringPlayerId: 9 } },
+ *   ],
+ *   rosterSpots: [{ teamId: 1, playerId: 9, sweaterNumber: 19, firstName: { default: "Ada" }, lastName: { default: "Example" } }],
+ * };
+ * const game = nhlPlayByPlay(answer);
+ * console.log(game.timeline.events, game.teams.home, game.ended);
+ * console.log(game.players.p9);
+ * // [ { t: 90, kind: 'goal', x: 80, y: -4, team: 'home', by: 'p9' } ] { abbr: 'AAA', name: 'Aardvarks' } false
+ * // { side: 'home', number: 19, name: 'Ada Example' }
+ * ```
+ */
+export declare function nhlPlayByPlay(json: unknown): FeedGame;

package/dist/feeds.nhl.js

@@ -0,0 +1,132 @@
+// An adapter: a play-by-play shaped as the NHL's public one (`plays`, each with `periodDescriptor`, `timeInPeriod`, `typeDescKey` and `details` with `xCoord` and `yCoord` in feet from centre ice; `homeTeam` and
+// `awayTeam` with their `id` and `abbrev`; `rosterSpots`; `gameState`) read into a replay. A play-by-play has events and no tracking: the puck goes from one event's place to the next in a straight line (it is
+// modelled between the known places), the shots, the goals and the whistles are marked where they were, and the clock is the game's (twenty minutes a period). Pure; every value is checked. The shape was read
+// from public descriptions of the answer; tests run on answers we made up.
+import { FEED_LIMITS, FeedError, feedText } from "./feeds.core.js";
+const isNum = (value) => typeof value === "number" && Number.isFinite(value);
+const isObj = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** A text field of the NHL's shape: a string, or `{ default: string }`. */
+const textOf = (value, most) => feedText(isObj(value) ? value.default : value, most);
+/** `mm:ss` as seconds; `undefined` for anything else. */
+const secondsOf = (value) => {
+    const m = typeof value === "string" ? /^(\d{1,3}):([0-5]\d)$/.exec(value.trim()) : null;
+    return m === null ? undefined : Number(m[1]) * 60 + Number(m[2]);
+};
+/** A regulation period, and an overtime in the regular season (the playoffs play twenty-minute overtimes): seconds. */
+export const NHL_PERIOD = 1200;
+export const NHL_OVERTIME = 300;
+/** What a kind of play is on the replay: the shots, the goal, and a whistle for a stoppage or a penalty. The rest only moves the puck. */
+const KINDS = { "shot-on-goal": "shot", "missed-shot": "shot", "blocked-shot": "shot", goal: "goal", stoppage: "whistle", penalty: "whistle", "delayed-penalty": "whistle" };
+/** The states of a game the NHL's shape says are over. */
+const OVER = new Set(["OFF", "FINAL"]);
+/**
+ * Read a play-by-play shaped as the NHL's public one into a game: the puck's places at the plays that have one (between them it moves in a straight line), a mark for each shot, goal and whistle, the periods with their
+ * clocks (a twenty-minute period, the board counting it down, an overtime of five minutes in the regular season and twenty in the playoffs, the shoot-out left out), each side's letters and name from the feed, and the players it names
+ * (by `p` and their id). Times are the game's, so the board's clock is the game's: period 2 starts at 1200 s. Throws a `FeedError` when it is not of the shape, or has no play with a place.
+ * @example
+ * ```ts
+ * import { nhlPlayByPlay } from "@johnmorrisdotca/kyogijo-stadiums/feeds";
+ * const answer = {
+ *   gameState: "LIVE", gameType: 2,
+ *   homeTeam: { id: 1, abbrev: "AAA", commonName: { default: "Aardvarks" } }, awayTeam: { id: 2, abbrev: "BBB" },
+ *   plays: [
+ *     { periodDescriptor: { number: 1, periodType: "REG" }, timeInPeriod: "00:00", typeDescKey: "faceoff", sortOrder: 1, details: { xCoord: 0, yCoord: 0 } },
+ *     { periodDescriptor: { number: 1, periodType: "REG" }, timeInPeriod: "01:30", typeDescKey: "goal", sortOrder: 2, details: { xCoord: 80, yCoord: -4, eventOwnerTeamId: 1, scoringPlayerId: 9 } },
+ *   ],
+ *   rosterSpots: [{ teamId: 1, playerId: 9, sweaterNumber: 19, firstName: { default: "Ada" }, lastName: { default: "Example" } }],
+ * };
+ * const game = nhlPlayByPlay(answer);
+ * console.log(game.timeline.events, game.teams.home, game.ended);
+ * console.log(game.players.p9);
+ * // [ { t: 90, kind: 'goal', x: 80, y: -4, team: 'home', by: 'p9' } ] { abbr: 'AAA', name: 'Aardvarks' } false
+ * // { side: 'home', number: 19, name: 'Ada Example' }
+ * ```
+ */
+export function nhlPlayByPlay(json) {
+    if (!isObj(json) || !Array.isArray(json.plays))
+        throw new FeedError("format", "not an NHL-style play-by-play: it has no list of plays");
+    const home = isObj(json.homeTeam) ? json.homeTeam : {};
+    const away = isObj(json.awayTeam) ? json.awayTeam : {};
+    const sideOf = (teamId) => (teamId !== undefined && teamId === home.id ? "home" : teamId !== undefined && teamId === away.id ? "away" : undefined);
+    const playoffs = json.gameType === 3;
+    const lengthOf = (number, type) => (type === "OT" || (type === undefined && number > 3) ? (playoffs ? NHL_PERIOD : NHL_OVERTIME) : NHL_PERIOD);
+    // The plays in order, the shoot-out left out (it has no clock, and its goals are not the score's).
+    const plays = json.plays
+        .slice(0, FEED_LIMITS.events)
+        .filter(isObj)
+        .map((play, i) => ({ play, order: isNum(play.sortOrder) ? play.sortOrder : i }))
+        .sort((a, b) => a.order - b.order)
+        .map((one) => one.play);
+    const periods = new Map();
+    const frames = [];
+    const events = [];
+    /** The time a period starts on the game's clock: the lengths of the periods before it. */
+    const startOf = (number, type) => {
+        let start = 0;
+        for (let p = 1; p < number; p += 1)
+            start += lengthOf(p, p <= 3 ? "REG" : type);
+        return start;
+    };
+    for (const play of plays) {
+        const d = isObj(play.periodDescriptor) ? play.periodDescriptor : {};
+        const number = isNum(d.number) && d.number >= 1 && d.number <= FEED_LIMITS.periods ? Math.trunc(d.number) : undefined;
+        if (number === undefined || d.periodType === "SO")
+            continue;
+        const length = lengthOf(number, d.periodType);
+        const start = startOf(number, d.periodType);
+        if (!periods.has(number))
+            periods.set(number, { number, start, end: start + length });
+        const into = secondsOf(play.timeInPeriod);
+        if (into === undefined)
+            continue;
+        const t = start + Math.min(length, into);
+        const details = isObj(play.details) ? play.details : {};
+        const placed = isNum(details.xCoord) && isNum(details.yCoord);
+        const [x, y] = placed ? [Math.max(-100, Math.min(100, details.xCoord)), Math.max(-42.5, Math.min(42.5, details.yCoord))] : [0, 0];
+        const type = typeof play.typeDescKey === "string" ? play.typeDescKey : "";
+        // A period starts with the puck at centre ice.
+        if (type === "period-start")
+            frames.push({ t, objects: [{ id: "puck", team: "puck", x: 0, y: 0 }] });
+        if (placed)
+            frames.push({ t, objects: [{ id: "puck", team: "puck", x, y }] });
+        const kind = KINDS[type];
+        if (kind === undefined)
+            continue;
+        const team = sideOf(details.eventOwnerTeamId);
+        const by = isNum(details.scoringPlayerId) ? details.scoringPlayerId : isNum(details.shootingPlayerId) ? details.shootingPlayerId : isNum(details.committedByPlayerId) ? details.committedByPlayerId : undefined;
+        events.push({ t, kind, ...(placed ? { x, y } : {}), ...(team === undefined ? {} : { team }), ...(by === undefined ? {} : { by: `p${by}` }) });
+    }
+    if (frames.length === 0)
+        throw new FeedError("empty", "the play-by-play has no play with a place on the ice yet");
+    // Frames at one time keep the last; the timeline is in order.
+    const byTime = new Map();
+    for (const f of frames)
+        byTime.set(f.t, f);
+    const ordered = [...byTime.values()].sort((a, b) => a.t - b.t);
+    const side = (team) => {
+        const abbr = textOf(team.abbrev, 8);
+        const name = textOf(team.commonName) ?? textOf(team.name) ?? textOf(team.placeName);
+        return { ...(abbr === undefined ? {} : { abbr }), ...(name === undefined ? {} : { name }) };
+    };
+    const players = {};
+    if (Array.isArray(json.rosterSpots)) {
+        for (const spot of json.rosterSpots.slice(0, 120)) {
+            if (!isObj(spot) || !isNum(spot.playerId))
+                continue;
+            const s = sideOf(spot.teamId);
+            if (s === undefined)
+                continue;
+            const name = [textOf(spot.firstName, 40), textOf(spot.lastName, 40)].filter((part) => part !== undefined).join(" ");
+            players[`p${spot.playerId}`] = { side: s, ...(isNum(spot.sweaterNumber) ? { number: spot.sweaterNumber } : {}), ...(name === "" ? {} : { name }) };
+        }
+    }
+    const state = typeof json.gameState === "string" ? json.gameState : "";
+    return {
+        format: "nhl",
+        sport: "nhl",
+        timeline: { from: "nhl-api", frames: ordered, events, periods: [...periods.values()].sort((a, b) => a.start - b.start) },
+        teams: { home: side(home), away: side(away) },
+        ended: OVER.has(state),
+        players,
+    };
+}

package/dist/judging.mount.js

@@ -62,7 +62,7 @@ export function mountJudgingBroadcast(host, options, settings = {}) {
         direction: () => turn.direction(),
         setDirection: (direction) => turn.setDirection(direction),
         togglePlay: () => turn.togglePlay(),
-        replay: (timeline, replaySettings) => turn.replay(timeline, replaySettings),
+        replay: turn.replay,
         get quality() {
             return turn.quality;
         },

package/dist/mount-entry.d.ts

@@ -2,3 +2,4 @@ import "./full.ts";
 import "./venues.all.ts";
 export { containerAspect, kyogijoElement, mountKyogijo } from "./mount.ts";
 export type { KyogijoMount, KyogijoReplay, MountSettings } from "./mount.ts";
+export type { FeedReplay, FeedReplayOptions, ReplayCall, ReplayFollow, ReplayFollowOptions } from "./replay.feed.ts";

package/dist/mount.d.ts

@@ -1,5 +1,5 @@
 import type { ReplayController } from "./replay.control.ts";
-import type { ReplaySettings, ReplayTimeline } from "./replay.types.ts";
+import { type ReplayCall } from "./replay.feed.ts";
 import type { ScoreOptions, SurfaceOptions } from "./types.ts";
 /** A replay on a mount: the controller of its clock, and `destroy` to take the replay away and leave the surface. */
 export type KyogijoReplay = ReplayController & {
@@ -16,9 +16,10 @@ export interface KyogijoMount {
     /**
      * Play tracking data on the surface: the players, the ball and the events of a timeline, with controls under the drawing (play, pause, step,
      * speed, loop, position), the keyboard (space, the arrow keys, Home and End) and a live region for goals and shots. Only the marks that move are
-     * moved, on animation frames. A reader who prefers reduced motion gets steps, and nothing plays by itself; a hidden page pauses. `update` keeps the replay.
+     * moved, on animation frames. A reader who prefers reduced motion gets steps, and nothing plays by itself; a hidden page pauses. `update` keeps the replay. `replay.fromUrl(url, options)` plays a feed from an
+     * address the reader gives, and `replay.follow(url, options)` follows one live, once the `/feeds` entry is loaded (see `docs/feeds.md`).
      */
-    replay(timeline: ReplayTimeline, settings?: ReplaySettings): KyogijoReplay;
+    replay: ReplayCall;
     /** Stop watching the container and empty it. */
     destroy(): void;
 }

package/dist/mount.js

@@ -2,6 +2,7 @@ import { drawKyogijo, isPortrait } from "./draw.js";
 import { resolveHomeSide } from "./homeside.js";
 import { chooseLeague } from "./leagues.js";
 import { createReplayView } from "./replay.dom.js";
+import { withFeeds } from "./replay.feed.js";
 const isScored = (o) => o.home !== undefined && o.away !== undefined;
 const scoreText = (team) => (team.score === undefined || team.score === null ? "" : String(team.score));
 /**
@@ -120,7 +121,7 @@ export function mountKyogijo(host, options, settings = {}) {
             if (settings.highlight !== false)
                 highlightScores(host, before, next);
         },
-        replay(timeline, replaySettings = {}) {
+        replay: withFeeds((timeline, replaySettings = {}) => {
             if (!alive)
                 throw new Error("this mount was destroyed");
             view?.destroy();
@@ -136,7 +137,7 @@ export function mountKyogijo(host, options, settings = {}) {
                     render();
                 },
             };
-        },
+        }),
         svg: () => (alive ? host.querySelector("svg.kyogijo") : null),
         orientation: () => (portrait ? "portrait" : "landscape"),
         destroy() {

package/dist/replay-entry.d.ts

@@ -2,8 +2,12 @@ import "./full.ts";
 import "./venues.all.ts";
 export { activeEvents, describeEvent, drawFrame, eventsBetween, interpolate, possession, replayClock, replayEvents, replayInfo, replayLayers, replaySnapshot, replaySummary, replayTable, replayTimes, trails } from "./replay.ts";
 export type { ReplaySnapshot } from "./replay.ts";
-export { boardClock, replayBoard, replayPeriods } from "./replay.board.ts";
-export type { ReplayBoardState } from "./replay.board.ts";
+export { boardClock, penaltiesAt, replayBoard, replayGameClock, replayGameTime, replayPenalties, replayPeriods } from "./replay.board.ts";
+export type { ReplayBoardState, ReplayGameClock, ServedPenalty } from "./replay.board.ts";
+export { addDeadTime, deadSeconds, replayStoppages, restartsBetween, stoppageAt } from "./replay.deadtime.ts";
+export type { DeadStop, DeadTimeRules } from "./replay.deadtime.ts";
+export { HOCKEY_BLUE_LINE, HOCKEY_DEAD_TIME, HOCKEY_DOTS, HOCKEY_PENALTY_MINUTES, HOCKEY_RULES, hockeyFaceoffDot, hockeyFormation, hockeyPenaltyBox, hockeyPenaltyEnds, hockeyPenaltyKind, hockeyStopOf, isHockeyDot, } from "./replay.hockey.ts";
+export type { HockeyCall, HockeyPenaltyKind, HockeyRole, HockeyServed, HockeyStop, HockeyStopAt } from "./replay.hockey.ts";
 export { alongPool, distanceAt, progressOf, raceTimeline } from "./pool.replay.ts";
 export type { Progress, RaceReplayOptions } from "./pool.replay.ts";
 export { formatTime, parseTime } from "./pool.race.ts";
@@ -11,4 +15,4 @@ export { REPLAY_SPEEDS, REPLAY_SPEED_RANGE, createReplay } from "./replay.contro
 export { FOLLOW_LIMITS, FOLLOW_MODES, clampShot, followCamera, followMode, followShot, followStop, followWindow, frameOf, springStep, zoomFor } from "./replay.follow.ts";
 export type { FollowBox, FollowCamera, FollowInput, FollowLimits, FollowMode, FollowShot } from "./replay.follow.ts";
 export type { ReplayController } from "./replay.control.ts";
-export type { ActiveEvent, Possession, ReplayChange, ReplayEvent, ReplayEventKind, ReplayFrame, ReplayLook, ReplayObject, ReplayPeriod, ReplayReason, ReplaySettings, ReplayState, ReplayTeam, ReplayTimeline, ReplayTrail, } from "./replay.types.ts";
+export type { ActiveEvent, Possession, ReplayChange, ReplayEvent, ReplayEventKind, ReplayFrame, ReplayLook, ReplayObject, ReplayPenalty, ReplayPeriod, ReplayReason, ReplaySettings, ReplayState, ReplayStoppage, ReplayTeam, ReplayTimeline, ReplayTrail, } from "./replay.types.ts";

package/dist/replay-entry.js

@@ -4,7 +4,9 @@ import "./full.js";
 // The real venues of the NHL's arenas, as this entry has always had them (the lean district reads the ones it shows).
 import "./venues.all.js";
 export { activeEvents, describeEvent, drawFrame, eventsBetween, interpolate, possession, replayClock, replayEvents, replayInfo, replayLayers, replaySnapshot, replaySummary, replayTable, replayTimes, trails } from "./replay.js";
-export { boardClock, replayBoard, replayPeriods } from "./replay.board.js";
+export { boardClock, penaltiesAt, replayBoard, replayGameClock, replayGameTime, replayPenalties, replayPeriods } from "./replay.board.js";
+export { addDeadTime, deadSeconds, replayStoppages, restartsBetween, stoppageAt } from "./replay.deadtime.js";
+export { HOCKEY_BLUE_LINE, HOCKEY_DEAD_TIME, HOCKEY_DOTS, HOCKEY_PENALTY_MINUTES, HOCKEY_RULES, hockeyFaceoffDot, hockeyFormation, hockeyPenaltyBox, hockeyPenaltyEnds, hockeyPenaltyKind, hockeyStopOf, isHockeyDot, } from "./replay.hockey.js";
 export { alongPool, distanceAt, progressOf, raceTimeline } from "./pool.replay.js";
 export { formatTime, parseTime } from "./pool.race.js";
 export { REPLAY_SPEEDS, REPLAY_SPEED_RANGE, createReplay } from "./replay.control.js";

package/dist/replay.board.d.ts

@@ -1,4 +1,4 @@
-import type { ReplayPeriod, ReplayTimeline } from "./replay.types.ts";
+import type { ReplayPenalty, ReplayPeriod, ReplayStoppage, ReplayTimeline } from "./replay.types.ts";
 /** The board at a time. */
 export interface ReplayBoardState {
     /** The goals so far: the events of kind `goal` at or before the time, by `team`. */
@@ -7,6 +7,14 @@ export interface ReplayBoardState {
     period?: number;
     /** The game clock as it is written, `19:20`: the time left in the period, or the time gone when the timeline counts `up`. Whole seconds, so it changes once a second of game time at most. */
     clock: string;
+    /** Only when the timeline has penalties: the skaters each side has on the ice (`[5, 4]` is a power play for the home side). */
+    strength?: [number, number];
+    /** Only when the timeline has penalties: each penalty being served at the time, by its side, with its time left as the board writes it (`1:42`), those that make the side play short first. */
+    penalties?: {
+        team: "home" | "away";
+        left: string;
+        short: boolean;
+    }[];
 }
 /** Seconds on a board's clock, `19:20`. A board has two digits of minutes, so more than 99:59 is shown as 99:59. */
 export declare function boardClock(seconds: number): string;
@@ -14,10 +22,73 @@ export declare function boardClock(seconds: number): string;
 export declare function replayPeriods(timeline: ReplayTimeline): readonly (ReplayPeriod & {
     number?: number;
 })[];
+/** The game clock at a time on the replay's clock. */
+export interface ReplayGameClock {
+    /** The period's number, or `undefined` when the timeline has no periods. */
+    period?: number;
+    /** Seconds of the period played on the game clock, and seconds left of it. */
+    played: number;
+    left: number;
+    /** `false` in a stoppage (and before a period has begun or after it has ended): the game clock is standing still. */
+    running: boolean;
+    /** The stoppage the time is in, when it is in one. */
+    stoppage?: ReplayStoppage;
+}
+/**
+ * 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 declare function replayGameClock(timeline: ReplayTimeline, t: number): ReplayGameClock;
+/**
+ * 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 declare function replayGameTime(timeline: ReplayTimeline, t: number): number;
+export declare function replayPenalties(timeline: ReplayTimeline): readonly ReplayPenalty[];
+/** A penalty being served at a time, and its game seconds left. */
+export interface ServedPenalty {
+    penalty: ReplayPenalty;
+    left: number;
+}
+/**
+ * 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 declare function penaltiesAt(timeline: ReplayTimeline, t: number): {
+    served: ServedPenalty[];
+    strength: [number, number];
+};
 /**
- * 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 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";