@johnmorrisdotca/kyogijo-stadiums 0.44.2 → 0.45.1

package/dist/parks.js

@@ -1,27 +1,9 @@
-import { FEET_PER_METRE, fenceAt, fencePoints, DEFAULT_FENCE } from "./geometry.js";
 import { PARK_DATA } from "./parks.data.js";
-import { officialName, placesNamed } from "./names.js";
-/** The address of the revision of an article that a park's figures were read from. */
-export function parkSourceUrl(source, language = "en") {
-    return `https://${language}.wikipedia.org/w/index.php?title=${encodeURIComponent(source.title.replace(/ /g, "_"))}&oldid=${source.revision}`;
-}
-const toFeet = (data) => {
-    const { points, unit, periods, walls, ...rest } = data;
-    const scale = unit === "m" ? FEET_PER_METRE : 1;
-    const feet = (list) => list.map(([angle, distance]) => [angle, Math.round(distance * scale * 10) / 10]);
-    const high = (wall) => {
-        const { height, ...stretch } = wall;
-        return { ...stretch, height_ft: Math.round(height * scale * 1000) / 1000 };
-    };
-    return {
-        ...rest,
-        points: feet(points),
-        ...(periods === undefined ? {} : { periods: periods.map((period) => ({ ...period, points: feet(period.points) })) }),
-        ...(walls === undefined ? {} : { walls: walls.map(high) }),
-    };
-};
+import { parkNameIn, parkOfficialName, parkPointsIn, parkQuirksIn, parkSourceUrl, parkWallsIn, fenceFor, registerParks } from "./parks.core.js";
+import { placesNamed } from "./names.js";
+export { fenceFor, parkNameIn, parkOfficialName, parkPointsIn, parkQuirksIn, parkSourceUrl, parkWallsIn };
 /** Every park by its key: the thirty current MLB ballparks, forty-three past ones, the twelve NPB home parks, and eight secondary or past NPB grounds. */
-export const PARKS = Object.freeze(Object.fromEntries(PARK_DATA.map((data) => [data.id, toFeet(data)])));
+export const PARKS = Object.freeze(Object.fromEntries(registerParks(PARK_DATA).map((park) => [park.id, park])));
 /** The keys of `PARKS`: the current MLB parks, then the past ones by their first season, then the NPB's, each in the order of the sources. */
 export const PARK_IDS = Object.freeze(PARK_DATA.map((data) => data.id));
 /** The unit a park's figures were published in: metres for the parks of Japan (converted to feet once, in `PARKS`), feet for the rest. `undefined` for a key that is not a park. */
@@ -39,54 +21,7 @@ export const parkUnit = (id) => PARK_DATA.find((data) => data.id === id)?.unit;
 export const parksByName = (name) => placesNamed(Object.values(PARKS), name);
 /** The park a name belongs to (see `parksByName`; the best match when several answer to it), or `undefined`. */
 export const parkByName = (name) => parksByName(name)[0];
-/** A park's name in a language: the everyday name in English, or in Japanese. */
-export const parkNameIn = (park, language = "en") => (language === "ja" ? park.nameJa : park.name);
-/** The name a park officially has in a language, when it is not the everyday name (`Hanshin Koshien Stadium` for `Koshien Stadium`), in the year given or today; else `undefined`. */
-export const parkOfficialName = (park, language = "en", year) => officialName(park, language, undefined, Number.isFinite(year) ? year : undefined);
 /** The park with a key, or `undefined`. */
 export const parkById = (id) => (id === undefined ? undefined : PARKS[id]);
 /** The park whose Wikidata item is `Q49136`, or `undefined`. */
 export const parkByWikidata = (wikidata) => Object.values(PARKS).find((park) => park.wikidata === wikidata);
-/** A park's fence in a season: the period that names the season, else the park's last fence. */
-export function parkPointsIn(park, year) {
-    if (year === undefined || !Number.isFinite(year))
-        return park.points;
-    return park.periods?.find((period) => period.from <= year && year <= period.to)?.points ?? park.points;
-}
-/** True when something dated by its `first` and `last` season stands in `year`; without a year, what stands today (has no `last`). */
-const standsIn = (dated, year) => {
-    if (year === undefined || !Number.isFinite(year))
-        return dated.last === undefined;
-    return (dated.first === undefined || dated.first <= year) && (dated.last === undefined || year <= dated.last);
-};
-/** The stretches of fence a park has in a season, with their heights in feet: the heights the article dates for that season, else those of today. */
-export function parkWallsIn(park, year) {
-    return (park.walls ?? []).filter((wall) => standsIn(wall, year));
-}
-/** The quirks a park has in a season: those the article dates for that season, else those of today. */
-export function parkQuirksIn(park, year) {
-    return (park.quirks ?? []).filter((quirk) => standsIn(quirk, year));
-}
-/**
- * The fence points a drawing uses: a park's (as it stood in `year`, when the park has dated fences), with any of the
- * five usual distances in `fence` laid over them, or the usual 330, 375, 400, 375 and 330 feet of a generic field (or the
- * `generic` points a league's rules give).
- */
-export function fenceFor(park, fence, year, generic = fencePoints(DEFAULT_FENCE)) {
-    const base = park === undefined ? [...generic] : parkPointsIn(park, year);
-    if (fence === undefined)
-        return base;
-    const keys = [["left", -45], ["leftCenter", -22.5], ["center", 0], ["rightCenter", 22.5], ["right", 45]];
-    const given = keys.filter(([key]) => typeof fence[key] === "number" && Number.isFinite(fence[key]) && fence[key] > 0);
-    if (given.length === 0)
-        return base;
-    // The caller's distances stand at their angles; the park's own points that fall near one of them give way.
-    const mine = given.map(([key, angle]) => [angle, fence[key]]);
-    const kept = base.filter(([angle]) => !mine.some(([chosen]) => Math.abs(chosen - angle) < 11));
-    const filled = [...kept, ...mine];
-    if (!filled.some(([angle]) => angle === -45))
-        filled.push([-45, fenceAt(base, -45)]);
-    if (!filled.some(([angle]) => angle === 45))
-        filled.push([45, fenceAt(base, 45)]);
-    return filled.sort((a, b) => a[0] - b[0]);
-}

package/dist/parks.walls.d.ts

@@ -0,0 +1 @@
+export declare const PARK_IDS_WITHOUT_WALLS: readonly string[];

package/dist/parks.walls.js

@@ -0,0 +1,3 @@
+// Made by scripts/build-parks.mjs from scripts/parks.data.json: do not edit by hand.
+// The keys of the parks whose article gives no wall height anywhere on the fence (`PARKS_WITHOUT_WALL_HEIGHTS`), kept apart from the table of parks so that a page that needs the list does not carry the table.
+export const PARK_IDS_WITHOUT_WALLS = ["tropicana-field", "rogers-centre", "target-field", "sutter-health-park", "t-mobile-park", "globe-life-field", "truist-park", "loandepot-park", "citizens-bank-park", "nationals-park", "great-american-ball-park", "american-family-field", "busch-stadium", "chase-field", "dodger-stadium", "exposition-park-pittsburgh", "polo-grounds", "south-end-grounds", "huntington-avenue-grounds", "league-park-cleveland", "sportsmans-park", "hilltop-park", "comiskey-park", "crosley-field", "tiger-stadium", "ebbets-field", "braves-field", "yankee-stadium-1923", "cleveland-stadium", "milwaukee-county-stadium", "baltimore-memorial-stadium", "municipal-stadium-kansas-city", "seals-stadium", "candlestick-park", "wrigley-field-los-angeles", "colt-stadium", "robert-f-kennedy-memorial-stadium", "shea-stadium", "astrodome", "atlanta-fulton-county-stadium", "busch-memorial-stadium", "oakland-coliseum", "sicks-stadium", "jarry-park-stadium", "veterans-stadium", "arlington-stadium", "exhibition-stadium", "olympic-stadium-montreal", "globe-life-park-in-arlington", "turner-field", "hanshin-koshien-stadium", "yokohama-stadium", "es-con-field-hokkaido", "rakuten-mobile-park-miyagi", "sapporo-dome", "korakuen-stadium", "heiwadai-stadium", "kawasaki-stadium", "nagoya-stadium"];

package/dist/plot-entry.d.ts

@@ -1,2 +1,3 @@
+import "./full.ts";
 export { surfaceMark, surfaceScales } from "./plot.ts";
 export type { PlotContext, PlotDocument, PlotElement, PlotScales, SurfaceMark, SurfaceScales } from "./plot.ts";

package/dist/plot-entry.js

@@ -1,2 +1,3 @@
 // A drawing as a mark for Observable Plot, with Plot not imported.
+import "./full.js";
 export { surfaceMark, surfaceScales } from "./plot.js";

package/dist/png-entry.d.ts

@@ -1,2 +1,3 @@
+import "./full.ts";
 export { PNG_PEER_MISSING, toPNG } from "./png.ts";
 export type { PngOptions } from "./png.ts";

package/dist/png-entry.js

@@ -1,2 +1,3 @@
 // A drawing as a PNG in Node, through the optional peer @resvg/resvg-js.
+import "./full.js";
 export { PNG_PEER_MISSING, toPNG } from "./png.js";

package/dist/pointer-entry.d.ts

@@ -1,2 +1,3 @@
+import "./full.ts";
 export { clientPointToField, clientPointToFrames, fieldPointToClient } from "./pointer.ts";
 export type { ElementLike, FieldPoint, MatrixLike, PointerOptions, SvgLike } from "./pointer.ts";

package/dist/pointer-entry.js

@@ -1,2 +1,3 @@
 // A click on a drawing as a place on the field: the pointer in a provider's numbers with the zone, and the way back.
+import "./full.js";
 export { clientPointToField, clientPointToFrames, fieldPointToClient } from "./pointer.js";

package/dist/quality.d.ts

@@ -0,0 +1,110 @@
+/** The tiers of detail, from the most to the least. */
+export type QualityTier = "high" | "medium" | "low";
+/** What a view is asked for: one tier, or `auto`, which chooses by the frames the view makes. */
+export type Quality = "auto" | QualityTier;
+/** The tiers, highest first: a step down is one place later in this list. */
+export declare const QUALITY_TIERS: readonly QualityTier[];
+/** The values a page can ask for: `auto` and the tiers. */
+export declare const QUALITIES: readonly Quality[];
+/** What a tier draws. */
+export interface TierProfile {
+    tier: QualityTier;
+    /** The most buildings of a district's context that stand up as blocks in the 3D view (the tallest and widest first); the rest are the floor's flat footprints, which every tier draws. */
+    blocks: number;
+    /** The share of the context's trees that are drawn, 0 to 1. */
+    trees: number;
+    /** A venue whose longest side is under this share of the plan's longest side is drawn as its footprint standing up to its height, one block, in place of its stands and roof; 0 draws every venue in full. */
+    proxy: number;
+    /** The small parts of a venue (benches, glass, posts, goals, the fascia and its fittings) are left out, and the crowd in its stands is drawn as blocks of colour. */
+    simple: boolean;
+    /** The share of the crowd outside that is drawn, 0 to 1 (0 hides it), and the width of its canvas as a share of the usual. */
+    outside: {
+        people: number;
+        width: number;
+    };
+    /** The pixel ratio the layers are rastered at, at most: on a phone or a tablet, and elsewhere. `Infinity` leaves the device's own. */
+    ratio: {
+        handheld: number;
+        other: number;
+    };
+}
+/** The profile of each tier. `high` leaves everything as it always was (the cap on a handheld's pixel ratio is the mode `auto`'s and is made in `rasterOf`). */
+export declare const TIER_PROFILES: Record<QualityTier, TierProfile>;
+/** Whether a value is one of the qualities. */
+export declare const isQuality: (value: unknown) => value is Quality;
+/** A quality from whatever a page or an address gave: the same if it is one, else `fallback`. */
+export declare const qualityOf: (value: unknown, fallback?: Quality) => Quality;
+/** The tier a view with no frames to go by is drawn at: the tier asked for, and `high` for `auto` (a page made on a server, a first draw). */
+export declare const tierOf: (quality: Quality | undefined) => QualityTier;
+/** The tier one step lower or higher than `tier`, or the same at the end. */
+export declare const lower: (tier: QualityTier) => QualityTier;
+export declare const higher: (tier: QualityTier) => QualityTier;
+/** What decides whether the device is a phone or a tablet: it has a coarse pointer, or its screen is small. It is asked of the page's own window, never of the browser's name. */
+export declare function handheld(win: {
+    matchMedia?: (query: string) => {
+        matches: boolean;
+    };
+    screen?: {
+        width: number;
+        height: number;
+    };
+    innerWidth?: number;
+} | null | undefined): boolean;
+/**
+ * The share of its size a layer is made at, from the device's pixel ratio `dpr`: a layer is made `share` times as wide and as high in CSS pixels and turned back to its size by its matrix, so that it holds `share` squared as many device
+ * pixels, as far as the engine keeps a layer's pixels to its own box (the layers of a district at a ratio of 3 are hundreds of megabytes, which a phone's browser does not always keep). An engine that draws a layer again at the scale its matrix has
+ * (Chromium does) makes the same pixels from it, so there it changes nothing, and the sizes this package reports are the boxes times the ratio squared, not what an engine allocates. 1 when the ratio is within the cap. The mode `auto` caps a handheld
+ * at 2 even at `high`; a tier asked for by name is exactly that tier's, and `high` asked for by name is the device's own ratio, as it always was.
+ */
+export declare function rasterOf(quality: Quality, tier: QualityTier, dpr: number, isHandheld: boolean): number;
+/**
+ * The most device pixels one layer may hold in a tier: a flat floor of a building is a layer as big as the building's box (the Kodokan's fourteen plates are 47 megabytes each at a ratio of 3), so a layer past the budget is made smaller
+ * still (see `rasterOf`). `Infinity` at `high`, by name or in `auto`.
+ */
+export declare function layerBudget(tier: QualityTier, isHandheld: boolean): number;
+/**
+ * The share of its size each layer is made at, from the sizes the layers would have at full size (their boxes in CSS pixels), the share every layer is made at (`rasterOf`), the device's pixel ratio and the layer budget: a layer is
+ * made at the smaller of the share and the one that holds `budget` device pixels, never under a fifth. The floor comes first, then the planes, as `layoutOf` takes them.
+ */
+export declare function rasterShares(sizes: readonly (readonly [number, number])[], share: number, dpr: number, budget: number): number[];
+/** How the governor judges the frames. Times are in milliseconds. */
+export interface GovernorTuning {
+    /** The frames in a window it keeps (the oldest are dropped past twice this), and the fewest it judges: a window is also at least `settleMs` long, so a view at 60 frames a second judges 42 frames and one at 6 frames a second judges 8. */
+    frames: number;
+    minFrames: number;
+    settleMs: number;
+    /** The first frames after the view is mounted are slow whatever it holds (scripts are still compiling, the page is still being laid out): they are not judged. */
+    warmMs: number;
+    /** The mean interval between frames above which the view is over budget (21 is below 48 frames a second: a view that misses a refresh in three does not hold 60; it widens on a display that refreshes slower than 60 Hz), and the mean at or under which it is steady (18.5 holds 60 frames a second). */
+    budgetMs: number;
+    steadyMs: number;
+    /** How long the view must stay steady before it tries the tier above, and the most that wait grows to after steps that were taken back. */
+    upAfterMs: number;
+    maxUpAfterMs: number;
+    /** Frames are ignored for this long after a step, while the view is drawn again. */
+    quietMs: number;
+    /** A gap longer than this between two frames is a pause (a hidden page, a stopped turn), not a slow frame. */
+    pauseMs: number;
+}
+export declare const GOVERNOR_TUNING: GovernorTuning;
+/** What the governor does with a frame. */
+export interface Governor {
+    /** The tier now. */
+    readonly tier: QualityTier;
+    /** Give it the time since the last frame and the time now; it gives the new tier when it steps, else `undefined`. */
+    frame(interval: number, now: number): QualityTier | undefined;
+    /** The interval of the display, in milliseconds, as the page measured it with nothing else going on (16.7 for 60 Hz, 33.3 for a phone in a power-saving mode): a display that refreshes slower than 60 Hz is not taken for a view that is too slow. 16.7 until told. */
+    display(interval: number): void;
+    /** Forget the frames so far (the turn stopped, the page was hidden). */
+    pause(): void;
+    /** Put it on a tier without a step (a page chose one). */
+    set(tier: QualityTier, now?: number): void;
+    /** How long it now waits, steady, before it tries a tier up. */
+    readonly wait: number;
+}
+/**
+ * The governor of a view that turns. It keeps a window of frame intervals; when their mean is over budget it steps one tier down, and when the mean has been steady for `wait` it tries one tier up. A try that goes over budget
+ * is taken back, and every step down within thirty seconds of a step up doubles the wait (up to `maxUpAfterMs`), so a device on the edge between two tiers settles on the lower one and stays there. A step up that holds (steady
+ * for `settleMs` after it) leaves the wait as it was.
+ */
+export declare function createGovernor(start: QualityTier, tuning?: Partial<GovernorTuning>): Governor;

package/dist/quality.js

@@ -0,0 +1,160 @@
+// How much a 3D view draws, so that it turns well on every device. A view has three tiers of detail, `high` (everything, as it always was), `medium` and `low`, and a mode, `auto`, that chooses the tier by watching the frames
+// the view really makes while it turns: nothing here looks at the browser's name or the device's model. A tier says what is left out or made smaller (the buildings round a district stand up fewer, the trees and the crowd are thinner, a
+// small or far venue is a block with its height, the layers are rastered at a lower pixel ratio); the governor steps a tier down when the frames run over budget for a while and back up when they have been steady for longer, with a wait
+// after a step up that fails that doubles each time, so that the view never flickers between two tiers. Pure: numbers in, numbers out; `turn.dom.ts` feeds it frames and `district.turn.ts` reads the tier's profile.
+/** The tiers, highest first: a step down is one place later in this list. */
+export const QUALITY_TIERS = ["high", "medium", "low"];
+/** The values a page can ask for: `auto` and the tiers. */
+export const QUALITIES = ["auto", ...QUALITY_TIERS];
+/** The profile of each tier. `high` leaves everything as it always was (the cap on a handheld's pixel ratio is the mode `auto`'s and is made in `rasterOf`). */
+export const TIER_PROFILES = {
+    high: { tier: "high", blocks: 130, trees: 1, proxy: 0, simple: false, outside: { people: 1, width: 1 }, ratio: { handheld: Infinity, other: Infinity } },
+    medium: { tier: "medium", blocks: 24, trees: 0.5, proxy: 0.12, simple: true, outside: { people: 0.5, width: 0.7 }, ratio: { handheld: 1.5, other: 2 } },
+    low: { tier: "low", blocks: 0, trees: 0.25, proxy: 0.4, simple: true, outside: { people: 0, width: 0.5 }, ratio: { handheld: 1, other: 1 } },
+};
+/** Whether a value is one of the qualities. */
+export const isQuality = (value) => typeof value === "string" && QUALITIES.includes(value);
+/** A quality from whatever a page or an address gave: the same if it is one, else `fallback`. */
+export const qualityOf = (value, fallback = "auto") => (isQuality(value) ? value : fallback);
+/** The tier a view with no frames to go by is drawn at: the tier asked for, and `high` for `auto` (a page made on a server, a first draw). */
+export const tierOf = (quality) => (quality === undefined || quality === "auto" ? "high" : quality);
+/** The tier one step lower or higher than `tier`, or the same at the end. */
+export const lower = (tier) => QUALITY_TIERS[Math.min(QUALITY_TIERS.length - 1, QUALITY_TIERS.indexOf(tier) + 1)];
+export const higher = (tier) => QUALITY_TIERS[Math.max(0, QUALITY_TIERS.indexOf(tier) - 1)];
+/** What decides whether the device is a phone or a tablet: it has a coarse pointer, or its screen is small. It is asked of the page's own window, never of the browser's name. */
+export function handheld(win) {
+    if (win === null || win === undefined)
+        return false;
+    if (win.matchMedia?.("(pointer: coarse)").matches === true)
+        return true;
+    const sides = [win.screen?.width, win.screen?.height, win.innerWidth].filter((n) => typeof n === "number" && n > 0);
+    return sides.length > 0 && Math.min(...sides) <= 820;
+}
+/**
+ * The share of its size a layer is made at, from the device's pixel ratio `dpr`: a layer is made `share` times as wide and as high in CSS pixels and turned back to its size by its matrix, so that it holds `share` squared as many device
+ * pixels, as far as the engine keeps a layer's pixels to its own box (the layers of a district at a ratio of 3 are hundreds of megabytes, which a phone's browser does not always keep). An engine that draws a layer again at the scale its matrix has
+ * (Chromium does) makes the same pixels from it, so there it changes nothing, and the sizes this package reports are the boxes times the ratio squared, not what an engine allocates. 1 when the ratio is within the cap. The mode `auto` caps a handheld
+ * at 2 even at `high`; a tier asked for by name is exactly that tier's, and `high` asked for by name is the device's own ratio, as it always was.
+ */
+export function rasterOf(quality, tier, dpr, isHandheld) {
+    const cap = quality === "auto" && tier === "high" ? (isHandheld ? 2 : Infinity) : TIER_PROFILES[tier].ratio[isHandheld ? "handheld" : "other"];
+    if (!(dpr > 0) || dpr <= cap)
+        return 1;
+    return Math.max(0.25, Math.round((cap / dpr) * 1000) / 1000);
+}
+/**
+ * The most device pixels one layer may hold in a tier: a flat floor of a building is a layer as big as the building's box (the Kodokan's fourteen plates are 47 megabytes each at a ratio of 3), so a layer past the budget is made smaller
+ * still (see `rasterOf`). `Infinity` at `high`, by name or in `auto`.
+ */
+export function layerBudget(tier, isHandheld) {
+    if (tier === "high")
+        return Infinity;
+    return { medium: isHandheld ? 2e6 : 4e6, low: isHandheld ? 1e6 : 2e6 }[tier];
+}
+/**
+ * The share of its size each layer is made at, from the sizes the layers would have at full size (their boxes in CSS pixels), the share every layer is made at (`rasterOf`), the device's pixel ratio and the layer budget: a layer is
+ * made at the smaller of the share and the one that holds `budget` device pixels, never under a fifth. The floor comes first, then the planes, as `layoutOf` takes them.
+ */
+export function rasterShares(sizes, share, dpr, budget) {
+    const ratio = dpr > 0 ? dpr : 1;
+    return sizes.map(([w, h]) => {
+        const area = w * h * ratio * ratio;
+        const own = area > budget ? Math.sqrt(budget / area) : 1;
+        return Math.max(0.2, Math.round(Math.min(share, own) * 1000) / 1000);
+    });
+}
+export const GOVERNOR_TUNING = { frames: 24, minFrames: 8, settleMs: 700, warmMs: 600, budgetMs: 21, steadyMs: 18.5, upAfterMs: 5000, maxUpAfterMs: 300000, quietMs: 600, pauseMs: 250 };
+/**
+ * The governor of a view that turns. It keeps a window of frame intervals; when their mean is over budget it steps one tier down, and when the mean has been steady for `wait` it tries one tier up. A try that goes over budget
+ * is taken back, and every step down within thirty seconds of a step up doubles the wait (up to `maxUpAfterMs`), so a device on the edge between two tiers settles on the lower one and stays there. A step up that holds (steady
+ * for `settleMs` after it) leaves the wait as it was.
+ */
+export function createGovernor(start, tuning = {}) {
+    const t = { ...GOVERNOR_TUNING, ...tuning };
+    let tier = start;
+    let wait = t.upAfterMs;
+    let window = [];
+    let since = 0;
+    let quietUntil = 0;
+    let steadyFrom;
+    let lastUp = -Infinity;
+    let firstAt;
+    // The interval of the display: told by the page, which measures it with nothing else going on (a view that cannot keep up looks, from its frames alone, like a screen that refreshes more slowly).
+    let refresh = 16.7;
+    const reset = (now) => {
+        window = [];
+        since = now;
+        steadyFrom = undefined;
+    };
+    const step = (to, now) => {
+        tier = to;
+        quietUntil = now + t.quietMs;
+        reset(now);
+        return tier;
+    };
+    return {
+        get tier() {
+            return tier;
+        },
+        get wait() {
+            return wait;
+        },
+        display(interval) {
+            if (Number.isFinite(interval))
+                refresh = Math.min(34, Math.max(6, interval));
+        },
+        pause() {
+            window = [];
+            steadyFrom = undefined;
+        },
+        set(next, now = 0) {
+            tier = next;
+            quietUntil = now + t.quietMs;
+            reset(now);
+        },
+        frame(interval, now) {
+            if (interval > t.pauseMs || interval <= 0) {
+                window = [];
+                steadyFrom = undefined;
+                return undefined;
+            }
+            firstAt ?? (firstAt = now);
+            if (now < quietUntil || now - firstAt < t.warmMs)
+                return undefined;
+            if (window.length === 0)
+                since = now - interval;
+            window.push(interval);
+            if (window.length > t.frames * 2)
+                window.shift();
+            if (window.length < t.minFrames || now - since < t.settleMs)
+                return undefined;
+            const mean = window.reduce((s, x) => s + x, 0) / window.length;
+            const slow = refresh / 16.7;
+            const budget = Math.max(t.budgetMs, t.budgetMs * slow);
+            // Steady is steady on any display: only a view that really holds 60 frames a second tries a tier up.
+            const steady = t.steadyMs;
+            // Over budget is judged without the slowest frames of the window (a hitch, a script that ran in the middle of a turn is not a slow view); steady is judged with all of them.
+            const sorted = [...window].sort((x, y) => x - y).slice(0, window.length - Math.max(1, Math.floor(window.length / 12)));
+            const trimmed = sorted.reduce((sum, x) => sum + x, 0) / sorted.length;
+            if (trimmed > budget && tier !== "low") {
+                // A step down soon after a step up is a try that failed: the next try waits longer.
+                if (now - lastUp < 30000)
+                    wait = Math.min(t.maxUpAfterMs, wait * 2);
+                return step(lower(tier), now);
+            }
+            if (mean <= steady) {
+                steadyFrom ?? (steadyFrom = now);
+                if (tier !== "high" && now - steadyFrom >= wait) {
+                    lastUp = now;
+                    return step(higher(tier), now);
+                }
+            }
+            else
+                steadyFrom = undefined;
+            // Window turned over: judge the next frames afresh once it is full of them.
+            if (window.length >= t.frames * 2)
+                window = window.slice(t.frames);
+            return undefined;
+        },
+    };
+}

package/dist/react-entry.d.ts

@@ -1,2 +1,3 @@
+import "./full.ts";
 export { createKyogijo, kyogijoHtml, kyogijoProps } from "./react.ts";
 export type { KyogijoProps, ReactLike } from "./react.ts";

package/dist/react-entry.js

@@ -1,2 +1,3 @@
 // A helper for React that does not depend on it: props to spread onto a div, and a component made from the React you pass.
+import "./full.js";
 export { createKyogijo, kyogijoHtml, kyogijoProps } from "./react.js";

package/dist/replay-entry.d.ts

@@ -1,3 +1,4 @@
+import "./full.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 { alongPool, distanceAt, progressOf, raceTimeline } from "./pool.replay.ts";

package/dist/replay-entry.js

@@ -1,5 +1,6 @@
 // Replay: tracking data over time on a surface. The frame, the clock and the pure functions between them; the controls and the animation
 // are in the mount (`mountKyogijo(...).replay(...)`) and in `<kyogijo-field>`.
+import "./full.js";
 export { activeEvents, describeEvent, drawFrame, eventsBetween, interpolate, possession, replayClock, replayEvents, replayInfo, replayLayers, replaySnapshot, replaySummary, replayTable, replayTimes, trails } from "./replay.js";
 export { alongPool, distanceAt, progressOf, raceTimeline } from "./pool.replay.js";
 export { formatTime, parseTime } from "./pool.race.js";

package/dist/rules.d.ts

@@ -1,7 +1,7 @@
 import { type Attacking, type Frame, type SurfaceSize } from "./frames.ts";
 import "./frames.providers.ts";
 import "./surfaces/soccer-providers.ts";
-import { type Park } from "./parks.ts";
+import { type Park } from "./parks.core.ts";
 import type { Language, Sport, SurfaceOptions } from "./types.ts";
 export { RULE_IDS } from "./rules.types.ts";
 export type { RuleId } from "./rules.types.ts";

package/dist/rules.js

@@ -20,7 +20,8 @@ import "./frames.providers.js";
 import "./surfaces/soccer-providers.js";
 import { buildZoneSet, infieldReach, ZONE_SETS, ZONE_SET_IDS } from "./heat.zones.js";
 import { feetFence, lengthUnit } from "./common.js";
-import { fenceFor, parkById, parkWallsIn, PARKS } from "./parks.js";
+import { fenceFor, heldPark, parkWallsIn } from "./parks.core.js";
+import { PARK_IDS_WITHOUT_WALLS } from "./parks.walls.js";
 import { frameSizeOf, outlineOf } from "./outline.js";
 import { soccerSpec } from "./surfaces/soccer-spec.js";
 import { KYOGIJO_STRINGS } from "./strings.js";
@@ -210,8 +211,8 @@ export function wallHeightAt(park, angle, year) {
 }
 function baseJudge(o, league) {
     const generic = league?.family === "baseball" ? diamondFence(diamondOf(league, o.year)) : undefined;
-    const points = fenceFor(parkById(o.park), feetFence(o.fence, lengthUnit(o)), o.year, generic);
-    const track = parkById(o.park)?.track_ft ?? MLB.warningTrack;
+    const points = fenceFor(heldPark(o.park), feetFence(o.fence, lengthUnit(o)), o.year, generic);
+    const track = heldPark(o.park)?.track_ft ?? MLB.warningTrack;
     return (x, y) => {
         const flags = [];
         // The foul lines are the fair territory's edges, and a ball on one is fair: fair is out from home plate between them.
@@ -468,7 +469,7 @@ export const onWarningTrack = holds("mlb", "warning-track");
  * The ballparks whose wall heights the package holds nowhere in their fence: of the 94 parks, the 35 whose article gives heights have them for some stretch,
  * and for the rest the height is not known here, so a decision that needs it is undecided (`homeRun: undefined`), never guessed.
  */
-export const PARKS_WITHOUT_WALL_HEIGHTS = Object.freeze(Object.values(PARKS).filter((park) => (park.walls ?? []).length === 0).map((park) => park.id));
+export const PARKS_WITHOUT_WALL_HEIGHTS = Object.freeze([...PARK_IDS_WITHOUT_WALLS]);
 /**
  * Whether a ball is a home run, from the park's own fence: the fence's distance at the bearing and, when the height of the ball is given, the wall's height there
  * (`wall` data of the park: the stretches of fence with their heights). A ball in fair territory that came down beyond the fence is a home run; one that was
@@ -484,7 +485,7 @@ export const PARKS_WITHOUT_WALL_HEIGHTS = Object.freeze(Object.values(PARKS).fil
  * ```
  */
 export function homeRun(park, point, options = {}) {
-    const found = typeof park === "string" ? parkById(park) : park;
+    const found = typeof park === "string" ? heldPark(park) : park;
     if (found === undefined)
         throw new RangeError(`Unknown park "${String(park)}": use a key of PARKS`);
     const o = { ...options, park: found.id };

package/dist/scene-entry.d.ts

@@ -1,3 +1,4 @@
+import "./full.ts";
 export { sceneFromSvg, sceneOf } from "./scene.ts";
 export { sceneToSvg } from "./scene.flat.ts";
 export type { FlatOptions } from "./scene.flat.ts";

package/dist/scene-entry.js

@@ -1,4 +1,5 @@
 // A drawing as plain data: the shapes it is painted with, in order, their colours worked out for light or dark; and the SVG that needs no stylesheet.
+import "./full.js";
 export { sceneFromSvg, sceneOf } from "./scene.js";
 export { sceneToSvg } from "./scene.flat.js";
 export { pathCommands } from "./scene.path.js";

package/dist/skating-entry.d.ts

@@ -1,3 +1,4 @@
+import "./full.ts";
 export { skatingPairs, skatingGrid, skatingResults, skatingReplay, figureElements, formatTime, distanceSkated } from "./charts.skating.ts";
 export type { DrawTotals, ElementTotals, FigureElementsOptions, SkatingElement, SkatingEntry, SkatingPair, SkatingRaceOptions, SkatingReplay, SkatingReplayOptions, SkatingResult, SkatingResultsTotals, SkatingRunner, SkatingStarter } from "./charts.skating.ts";
 export { ELEMENT_KINDS, ELEMENT_NAMES, LONG_TRACK_RACES, LONG_TRACK_RACE_IDS, RACES, RACE_IDS, SHORT_TRACK_RACES, SHORT_TRACK_RACE_IDS, raceById } from "./skating/events.ts";

package/dist/skating-entry.js

@@ -1,5 +1,6 @@
 // The ice skating rinks: the standard 400 m speed skating track, the short track oval and the figure skating rink, with the plan of each, the track's geometry (a point of a lane, the start of a race, the
 // lap of the crossing), the races and the elements, and the data: the pairs of a race, the starting positions of a short track race, the results, a replay and the elements of a programme as marks.
+import "./full.js";
 export { skatingPairs, skatingGrid, skatingResults, skatingReplay, figureElements, formatTime, distanceSkated } from "./charts.skating.js";
 export { ELEMENT_KINDS, ELEMENT_NAMES, LONG_TRACK_RACES, LONG_TRACK_RACE_IDS, RACES, RACE_IDS, SHORT_TRACK_RACES, SHORT_TRACK_RACE_IDS, raceById } from "./skating/events.js";
 export { disciplineOf, furnitureOf, racesOf, skatingLeague, skatingPlan } from "./skating/plan.js";

package/dist/special.js

@@ -4,7 +4,7 @@
 import { convertLength } from "./units.js";
 import { num, el } from "./format.js";
 import { MLB } from "./geometry.js";
-import { groundById } from "./grounds.js";
+import { heldGround } from "./grounds.core.js";
 import { lengthUnit } from "./common.js";
 import { lineLook, restyleLines } from "./restyle.js";
 import { outlineOf } from "./outline.js";
@@ -15,7 +15,7 @@ export function hostSurfaceOptions(host, o) {
     if (host.park !== undefined)
         return { ...common, sport: "mlb", park: host.park };
     if (host.ground !== undefined || host.pitch !== undefined) {
-        const ground = groundById(host.ground);
+        const ground = heldGround(host.ground);
         const pitch = host.pitch ?? (ground === undefined || ground.pitchSize === "default" ? undefined : { ...ground.pitch, unit: "m" });
         return { ...common, sport: "soccer", ground: host.ground, pitch };
     }

package/dist/stadiums-entry.d.ts

@@ -1,2 +1,3 @@
+import "./full.ts";
 export { VENUE_ATTRIBUTION, STADIUMS, STADIUM_IDS, groundOfStadium, planPark, planStadium, stadiumBowl, stadiumBowlInside, stadiumById, stadiumByWikidata, stadiumConfigOf, stadiumConfigs, stadiumFrameHeading, stadiumKind, stadiumNames, stadiumOrientation, stadiumSeats } from "./stadiums.ts";
 export type { ParkPlan, RealStadium, RealStadiumData, StadiumBasis, StadiumConfigData, StadiumConfigId, StadiumKind, StadiumOrientation, StadiumOsm, StadiumPlan, StadiumRoof } from "./stadiums.ts";

package/dist/stadiums-entry.js

@@ -1,2 +1,3 @@
 // The real stadiums and ballparks: the outline of each building and the way its field lies (OpenStreetMap, ODbL 1.0) and a plausible bowl from the seats of each configuration, the bowls and the roof the sources give (Wikidata, Wikipedia).
+import "./full.js";
 export { VENUE_ATTRIBUTION, STADIUMS, STADIUM_IDS, groundOfStadium, planPark, planStadium, stadiumBowl, stadiumBowlInside, stadiumById, stadiumByWikidata, stadiumConfigOf, stadiumConfigs, stadiumFrameHeading, stadiumKind, stadiumNames, stadiumOrientation, stadiumSeats } from "./stadiums.js";

package/dist/stadiums.d.ts

@@ -1,6 +1,6 @@
 import { type Box, type CrowdStands, type Pt, type RealBowl } from "./crowd.ts";
 import { type ParkInput } from "./crowd.park.ts";
-import { type Ground } from "./grounds.ts";
+import { type Ground } from "./grounds.core.ts";
 import { VENUE_ATTRIBUTION } from "./venues.ts";
 export { VENUE_ATTRIBUTION };
 /** How a fact is known: `documented` is what a source cited with it says; `plausible` is ours, for a bowl no source describes. */

package/dist/stadiums.js

@@ -6,8 +6,8 @@
 import { NORTH_ROOM, aisleParameters, aislesOf, areaOfOutline, outlinePoints, sectorPolygon } from "./crowd.js";
 import { parkLayout } from "./crowd.park.js";
 import { FEET_PER_METRE, FOOTBALL } from "./geometry.js";
-import { groundById } from "./grounds.js";
-import { PARKS } from "./parks.js";
+import { heldGround } from "./grounds.core.js";
+import { heldPark } from "./parks.core.js";
 import { GAP, HALL, MAX_RAKE, SEAT_AREAS, WALL, VENUE_ATTRIBUTION } from "./venues.js";
 import { boxOf, edgeDistance, inside, metresFrom, middleOf, northOn, turnedTo } from "./venues.geo.js";
 import { clipConvex } from "./venue.geom.js";
@@ -28,7 +28,7 @@ export const stadiumKind = (stadium) => stadium.kind ?? "stadium";
 export const stadiumConfigs = (stadium) => Object.keys(stadium.configs);
 /** The ground a stadium is (its name, place and pitch). Throws for a ballpark, which has a park, and for a hall, which has none. */
 export const groundOfStadium = (stadium) => {
-    const ground = groundById(stadium.ground);
+    const ground = heldGround(stadium.ground);
     if (ground === undefined)
         throw new Error(`${stadium.id} has no ground ${String(stadium.ground)}`);
     return ground;
@@ -41,7 +41,7 @@ export function stadiumNames(stadium) {
         return { en: stadium.names.en, ja: stadium.names.ja };
     }
     if (stadiumKind(stadium) === "park") {
-        const park = PARKS[stadium.park ?? ""];
+        const park = heldPark(stadium.park);
         if (park === undefined)
             throw new Error(`${stadium.id} has no park ${String(stadium.park)}`);
         return { en: park.name, ja: park.nameJa };

package/dist/target-entry.d.ts

@@ -1,2 +1,3 @@
+import "./full.ts";
 export { GOAL_SPORTS, KYOGIJO_TARGET_STYLE, LENGTH_ZONES, TARGET_SPORTS, drawGoalMouth, drawStrikeZone, drawStumps, drawTarget, goalSize, goalZoneIds, lengthZoneOf, targetZoneAt } from "./target.ts";
 export type { GoalSport, TargetDrawing, TargetFrame, TargetOptions, TargetPlace, TargetShot, TargetSport, TargetUnit } from "./target.ts";

package/dist/target-entry.js

@@ -1,2 +1,3 @@
 // The targets seen end-on: the mouth of a goal from the shooter's side, the stumps from the bowler's end and the strike zone from the catcher's, with the shots, deliveries and pitches on them.
+import "./full.js";
 export { GOAL_SPORTS, KYOGIJO_TARGET_STYLE, LENGTH_ZONES, TARGET_SPORTS, drawGoalMouth, drawStrikeZone, drawStumps, drawTarget, goalSize, goalZoneIds, lengthZoneOf, targetZoneAt } from "./target.js";

package/dist/turn-entry.d.ts

@@ -1,9 +1,12 @@
+import "./full.ts";
 export { mountKyogijoTurn, mountTurn, turnSupported } from "./turn.dom.ts";
 export type { KyogijoTurn } from "./turn.dom.ts";
 export { buildTurn, floorOptions, openingView } from "./turn.model.ts";
 export { turnDirection } from "./turn.camera.ts";
 export type { TurnDirection } from "./turn.camera.ts";
 export type { TurnModel, TurnSettings } from "./turn.model.ts";
+export { GOVERNOR_TUNING, QUALITIES, QUALITY_TIERS, TIER_PROFILES, createGovernor, handheld, isQuality, qualityOf, rasterOf, tierOf } from "./quality.ts";
+export type { Governor, GovernorTuning, Quality, QualityTier, TierProfile } from "./quality.ts";
 export { layoutOf, planeMarkup, planeMatrix, turnMarkup, turnMarkupOf } from "./turn.markup.ts";
 export type { Layout } from "./turn.markup.ts";
 export { KYOGIJO_TURN_STYLE } from "./turn.style.ts";

package/dist/turn-entry.js

@@ -1,7 +1,9 @@
 // The 3D view: a surface as a floor that turns, with a net, a basket, a goal or a pair of posts standing on it.
+import "./full.js";
 export { mountKyogijoTurn, mountTurn, turnSupported } from "./turn.dom.js";
 export { buildTurn, floorOptions, openingView } from "./turn.model.js";
 export { turnDirection } from "./turn.camera.js";
+export { GOVERNOR_TUNING, QUALITIES, QUALITY_TIERS, TIER_PROFILES, createGovernor, handheld, isQuality, qualityOf, rasterOf, tierOf } from "./quality.js";
 export { layoutOf, planeMarkup, planeMatrix, turnMarkup, turnMarkupOf } from "./turn.markup.js";
 export { KYOGIJO_TURN_STYLE } from "./turn.style.js";
 export { CURLING_PRESETS, LONG_PRESETS, NET_PRESETS, PITCH_MAX, STEP, TURN_DEFAULT, TURN_PRESETS, TURN_PRESET_NAMES, ZOOM_MAX, ZOOM_MIN, cameraMatrix, clampView, depthOf, drag, eyeDistance, fit, matrix3d, multiply, nudge, presetOf, presetView, presetsFor, project, step } from "./turn.camera.js";