@johnmorrisdotca/kyogijo-stadiums 0.45.0 → 0.45.2

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,3 +1,4 @@
+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";

package/dist/turn-entry.js

@@ -1,4 +1,5 @@
 // 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";

package/dist/turn.camera.d.ts

@@ -114,6 +114,11 @@ export declare function covered(b: Box3, view: TurnView, at: Placement, distance
  * extent of the scene on the screen changes with the pitch. The perspective bends the sum, so it is found by a few rounds of scaling and re-centring; six is plenty.
  */
 export declare function fit(b: Box3, view: TurnView, w: number, h: number, distance: number, pad?: number): Placement;
+/**
+ * The scale (screen pixels for a pixel of the scene, at a zoom of 1) a scene's box is fitted at in a container, the largest any tip of the view makes it: a view tipped towards the horizon is fitted larger, and the layers are made
+ * for the largest so that tipping the view does not make them again.
+ */
+export declare function viewScale(b: Box3, w: number, h: number, lens?: number): number;
 /** A 4 by 4 matrix, as CSS writes it in `matrix3d`: sixteen numbers, a column after a column. */
 export type Mat4 = readonly number[];
 /** Two matrices as one: `b` first, then `a`. */

package/dist/turn.camera.js

@@ -179,6 +179,14 @@ export function fit(b, view, w, h, distance, pad = 0.03) {
     lastFit = { key, at: { ...at } };
     return at;
 }
+/**
+ * The scale (screen pixels for a pixel of the scene, at a zoom of 1) a scene's box is fitted at in a container, the largest any tip of the view makes it: a view tipped towards the horizon is fitted larger, and the layers are made
+ * for the largest so that tipping the view does not make them again.
+ */
+export function viewScale(b, w, h, lens) {
+    const distance = eyeDistance(w, h, lens);
+    return Math.max(...[0, 30, 58, 70, PITCH_MAX].map((pitch) => fit(b, { yaw: 0, pitch, zoom: 1 }, w, h, distance).k));
+}
 /** Two matrices as one: `b` first, then `a`. */
 export function multiply(a, b) {
     const out = new Array(16);

package/dist/turn.dom.js

@@ -3,14 +3,14 @@
 // reduced motion gets jumps for glides, and where the browser cannot draw in 3D the flat drawing stays. Nothing is polled and nothing runs while the view is
 // still: the elements' `transform`s are written when the view changes, and a glide between viewpoints is a short run of animation frames.
 import { drawKyogijo } from "./draw.js";
-import { STEP, TURN_PRESET_NAMES, clampView, drag, nearest, nudge, presetOf, presetView, step, turnDirection, wheelTip } from "./turn.camera.js";
+import { STEP, TURN_PRESET_NAMES, clampView, drag, nearest, nudge, presetOf, presetView, step, turnDirection, viewScale, wheelTip } from "./turn.camera.js";
 import { buildTurn, floorOptions, openingView, turnWords } from "./turn.model.js";
 import { controlsMarkup, layoutOf, turnMarkupOf, worldMarkup } from "./turn.markup.js";
 import { KYOGIJO_TURN_STYLE } from "./turn.style.js";
 import { esc } from "./format.js";
 import { turnBoardMarkup } from "./overlay.js";
 import { attachOutside3d } from "./outside.dom.js";
-import { TIER_PROFILES, createGovernor, handheld, layerBudget, qualityOf, rasterOf, rasterShares, tierOf } from "./quality.js";
+import { TIER_PROFILES, createGovernor, handheld, layerBudget, qualityOf, rasterOf, rasterShares, tierOf, viewShare, FLOOR_SHARE } from "./quality.js";
 import { size } from "./turn.kit.js";
 /** True where the page can draw a plane in 3D by one `matrix3d`: that is, nearly everywhere with a stylesheet. */
 export function turnSupported(win = typeof window === "undefined" ? undefined : window) {
@@ -50,6 +50,12 @@ export function mountTurn(host, options, settings, build) {
     let tier = tierOf(quality);
     // (Set again below, once the model is built, for a view that has no tiers.)
     const isHandheld = handheld(win);
+    /**
+     * The share of its size a layer needs to be as fine as this screen shows it (`viewShare`): a district on a phone is drawn at a sixth of the scene's own size, so its layers need a quarter as many pixels on a side. It is worked out from the container's
+     * size and the zoom, and held while they are as they are: `settleRaster` draws the layers again when they change enough to need another.
+     */
+    let ceiling = 1;
+    const ceilingFor = (of, width, height, zoom) => (of.tiered === true ? viewShare(viewScale(of.box, width, height, settings.lens ?? of.lens), zoom) : 1);
     /** The share of its size each layer is made at for a model, now: one number when they all are, one each when the biggest are held to a budget of pixels. */
     const rasterFor = (of) => {
         // (Only a model that has tiers is made smaller: a surface on its own is small, and nothing of it would be left out.)
@@ -58,16 +64,21 @@ export function mountTurn(host, options, settings, build) {
         const dpr = win?.devicePixelRatio ?? 1;
         const share = rasterOf(quality, tier, dpr, isHandheld);
         const budget = layerBudget(tier, isHandheld);
-        if (share === 1 && budget === Infinity)
+        if (share === 1 && budget === Infinity && ceiling === 1)
             return 1;
         const boxes = [[of.viewBox.w * of.scale, of.viewBox.h * of.scale], ...of.planes.map((p) => { const [w, h] = size(p); return [w * of.scale, h * of.scale]; })];
-        return rasterShares(boxes, share, dpr, budget);
+        return rasterShares(boxes, share, dpr, budget, ceiling, FLOOR_SHARE);
     };
     const sameRaster = (a, b) => (typeof a === "number" || typeof b === "number" ? a === b : a.length === b.length && a.every((x, i) => x === b[i]));
     let current = options;
     let model = build(options, { ...settings, quality: tier });
     if (model.tiered !== true)
         tier = "high";
+    // (The container is not written yet: its width is the host's and its height the one the stylesheet gives it, 16 by 10 or 5 by 4 on a phone; `settleRaster` corrects it once the view is in the page.)
+    {
+        const width = host.clientWidth > 0 ? host.clientWidth : (settings.size?.width ?? 960);
+        ceiling = ceilingFor(model, width, Math.max(260, width * (width <= 560 ? 0.8 : 0.625)), model.view.zoom);
+    }
     let raster = rasterFor(model);
     /** The models built at each tier for the options now, so that a step back to a tier is not built again. */
     let made = new Map([[tier, model]]);
@@ -155,6 +166,7 @@ export function mountTurn(host, options, settings, build) {
     crowd();
     root.dataset.quality = quality;
     root.dataset.tier = tier;
+    root.dataset.share = String(ceiling);
     // ---- Quality: in `auto`, the frames the view makes while it turns decide the tier. ----
     let governor = quality === "auto" && win !== null && model.tiered === true ? createGovernor(tier, settings.qualityTuning) : undefined;
     let meterFrame;
@@ -230,6 +242,7 @@ export function mountTurn(host, options, settings, build) {
         const known = made.get(tier);
         model = known ?? build(current, { ...settings, quality: tier, id: settings.id ?? baseId, venue, preset: undefined, view });
         made.set(tier, model);
+        ceiling = ceilingFor(model, stage.clientWidth || 960, stage.clientHeight || 600, shown.zoom);
         raster = rasterFor(model);
         const layout = layoutOf(model, shown, stage.clientWidth || 960, stage.clientHeight || 600, settings.lens, false, raster);
         const world = root.querySelector(".ky-turn-world");
@@ -249,6 +262,7 @@ export function mountTurn(host, options, settings, build) {
         crowd();
         root.dataset.quality = quality;
         root.dataset.tier = tier;
+        root.dataset.share = String(ceiling);
     };
     /** The governor stepped: draw at the new tier. */
     const retier = (next) => {
@@ -273,6 +287,30 @@ export function mountTurn(host, options, settings, build) {
         if (glyph !== null)
             glyph.textContent = playing ? "❚❚" : "▶";
     };
+    // ---- The pixels of the layers follow the view: a zoom or a new size of the container may need a finer or allow a coarser share, and the layers are drawn again at it. ----
+    let seenZoom = shown.zoom;
+    let settling;
+    /** Draw the layers again if the view needs another share than they were made at. */
+    const settleRaster = () => {
+        settling = undefined;
+        if (!alive || model.tiered !== true)
+            return;
+        if (ceilingFor(model, stage.clientWidth || 960, stage.clientHeight || 600, shown.zoom) === ceiling)
+            return;
+        renderWorld();
+        paint(shown);
+    };
+    /**
+     * The view changed in a way that may change the share it needs. A finer share is drawn soon (a moment after the zoom has stopped, so that a pinch is not drawn again at every step), a coarser one only after a while at rest: until
+     * then the layers are finer than needed, which costs memory and nothing to the eye.
+     */
+    const wantRaster = () => {
+        if (!alive || model.tiered !== true || win === null)
+            return;
+        clearTimeout(settling);
+        const next = ceilingFor(model, stage.clientWidth || 960, stage.clientHeight || 600, shown.zoom);
+        settling = next === ceiling ? undefined : win.setTimeout(settleRaster, next > ceiling ? 160 : 1500);
+    };
     /** Put a view on the screen. */
     const paint = (now) => {
         const width = stage.clientWidth || 960;
@@ -298,6 +336,10 @@ export function mountTurn(host, options, settings, build) {
             if (faded[i] !== o)
                 one.style.opacity = faded[i] = o;
         });
+        if (now.zoom !== seenZoom) {
+            seenZoom = now.zoom;
+            wantRaster();
+        }
         touched();
     };
     const label = () => {
@@ -308,6 +350,8 @@ export function mountTurn(host, options, settings, build) {
     };
     paint(shown);
     label();
+    // The container is in the page now: the share its layers need, at its real size.
+    settleRaster();
     const stop = () => {
         if (flight !== undefined)
             win?.cancelAnimationFrame(flight.frame);
@@ -602,7 +646,12 @@ export function mountTurn(host, options, settings, build) {
     // ---- The size of the box. ----
     let observer;
     if (typeof ResizeObserver === "function") {
-        observer = new ResizeObserver(() => alive && paint(shown));
+        observer = new ResizeObserver(() => {
+            if (!alive)
+                return;
+            paint(shown);
+            wantRaster();
+        });
         observer.observe(stage);
     }
     // Nothing moves until the reader asks, unless the page did: `autoPlay` starts it, but not for a reader who prefers reduced motion (`"force"` does).
@@ -719,6 +768,7 @@ export function mountTurn(host, options, settings, build) {
             if (!alive)
                 return;
             alive = false;
+            clearTimeout(settling);
             outside?.destroy();
             stop();
             stopTick();

package/dist/uprights.fields.d.ts

@@ -1,7 +1,7 @@
 import type { FieldPlan } from "./fields.types.ts";
 import { type FencePoint, type FootballSpec } from "./geometry.ts";
 import type { SoccerSpec } from "./surfaces/soccer-spec.ts";
-import type { ParkWall } from "./parks.ts";
+import type { ParkWall } from "./parks.core.ts";
 import { type Plane, type Upright } from "./turn.kit.ts";
 /**
  * The crossbar of a football post is 10 ft over the ground (NFL 2026 Rule 1-3-1: "the top face of which is 10 feet above the ground"; CFL 2026 Rule 1-1-1:

package/dist/uprights.js

@@ -11,7 +11,7 @@ import { diamondFence } from "./leagues/baseball.js";
 import { NBA_COURT } from "./leagues/basketball.js";
 import { NHL_RINK } from "./leagues/hockey.js";
 import { chooseLeague, courtOf, diamondOf, fieldOf, rinkOf } from "./leagues.js";
-import { fenceFor, parkById, parkWallsIn } from "./parks.js";
+import { fenceFor, heldPark, parkWallsIn } from "./parks.core.js";
 import { fenceOutline } from "./surfaces/baseball.js";
 import { KYOGIJO_STRINGS, fill } from "./strings.js";
 import { soccerSpec } from "./surfaces/soccer-spec.js";
@@ -65,7 +65,7 @@ export function uprightsFor(o, settings = {}) {
     }
     else if (sport === "mlb") {
         const diamond = league?.family === "baseball" ? diamondOf(league, o.year) : undefined;
-        const park = parkById(o.park);
+        const park = heldPark(o.park);
         const points = fenceFor(park, feetFence(o.fence, unit), o.year, diamond === undefined ? undefined : diamondFence(diamond));
         thin = 0.4;
         items = ballparkUprights(points, park === undefined ? [] : parkWallsIn(park, o.year), thin);

package/dist/venue-data-entry.d.ts

@@ -0,0 +1,5 @@
+export { loadArena, loadGround, loadPark, loadVenueDataFor, venueDataKeysFor, venueName } from "./venue-data.ts";
+export type { VenueDataKeys } from "./venue-data.ts";
+export type { Arena } from "./arenas.core.ts";
+export type { Ground } from "./grounds.core.ts";
+export type { Park } from "./parks.core.ts";

package/dist/venue-data-entry.js

@@ -0,0 +1,2 @@
+// The data of the venues a page shows, one file each, read when asked for: `loadVenueDataFor` for the venues of a district, `loadArena`, `loadPark` and `loadGround` for one, `venueName` to list the venues by name without reading any of them.
+export { loadArena, loadGround, loadPark, loadVenueDataFor, venueDataKeysFor, venueName } from "./venue-data.js";

package/dist/venue-data.d.ts

@@ -0,0 +1,64 @@
+import { type Arena } from "./arenas.core.ts";
+import { type Ground } from "./grounds.core.ts";
+import { type Park } from "./parks.core.ts";
+import type { Language } from "./types.ts";
+/**
+ * An arena by its key, read from its own file the first time and held for the drawing after: asking again gives the same promise. A key that is not an arena rejects, naming the keys there are.
+ * @example
+ * ```ts
+ * import { loadArena } from "@johnmorrisdotca/kyogijo-stadiums/venue-data";
+ * const arena = await loadArena("rogers-arena");
+ * console.log(arena.name, arena.city);
+ * // Rogers Arena Vancouver
+ * ```
+ */
+export declare const loadArena: (id: string) => Promise<Arena>;
+/** A park by its key, read from its own file the first time and held for the drawing after (see `loadArena`). */
+export declare const loadPark: (id: string) => Promise<Park>;
+/** A ground by its key, read from its own file the first time and held for the drawing after (see `loadArena`). */
+export declare const loadGround: (id: string) => Promise<Ground>;
+/** The keys of the arenas, parks and grounds whose records the drawing of some venues reads. */
+export interface VenueDataKeys {
+    arenas: string[];
+    parks: string[];
+    grounds: string[];
+}
+/**
+ * The records the drawing of some venues of a district reads, by kind: an arena's own, a ballpark's park, a stadium's ground, and nothing for a hall (which carries its own names) or the Kodokan. The keys are a district's (`rogers-arena`,
+ * `bc-place:cfl`).
+ * @example
+ * ```ts
+ * import { venueDataKeysFor } from "@johnmorrisdotca/kyogijo-stadiums/venue-data";
+ * console.log(venueDataKeysFor(["rogers-arena", "bc-place:cfl", "t-mobile-park:mlb"]));
+ * // {
+ * //   arenas: [ 'rogers-arena' ],
+ * //   parks: [ 't-mobile-park' ],
+ * //   grounds: [ 'bc-place' ]
+ * // }
+ * ```
+ */
+export declare function venueDataKeysFor(venues: readonly string[]): VenueDataKeys;
+/**
+ * The records of the venues a page is about to draw, each read from its own file and no other, and held for the drawing: what `planDistrict`, `drawDistrict` and `mountDistrictTurn` of the lean district read. Await it before the
+ * first call and again when the venues change; a venue whose records are held is not read twice.
+ * @example
+ * ```ts
+ * import { loadVenueDataFor, planDistrict } from "@johnmorrisdotca/kyogijo-stadiums/district-lean";
+ * const venues = ["bc-place:cfl", "rogers-arena"];
+ * await loadVenueDataFor(venues);
+ * console.log(planDistrict({ venues }).members.length);
+ * // 2
+ * ```
+ */
+export declare function loadVenueDataFor(venues: readonly string[]): Promise<void>;
+/**
+ * The name of a venue of a district in a language, from the lists of names alone: no record is read, so a page can list every venue to choose from and read only the records of those chosen. It is the name `districtMember(key, language).name[language]` gives.
+ * `undefined` for a key that is not a venue of a district.
+ * @example
+ * ```ts
+ * import { venueName } from "@johnmorrisdotca/kyogijo-stadiums/venue-data";
+ * console.log(venueName("rogers-arena", "en"), venueName("bc-place:cfl", "ja"));
+ * // Rogers Arena BCプレイス
+ * ```
+ */
+export declare function venueName(key: string, language?: Language): string | undefined;

package/dist/venue-data.js

@@ -0,0 +1,115 @@
+// The data of the venues a page shows, one file each, read when asked for. The drawing reads an arena, a park or a ground from a table (`heldArena`, `heldPark`, `heldGround`) that the full lists fill (`full.ts`, which every
+// entry but the lean district imports); a page that imports the lean district holds none until `loadVenueDataFor` has read the files of the venues it is about to draw. Nothing here holds a record: `arenas.index.ts`, `parks.index.ts`
+// and `grounds.index.ts` list every key with its names and the `import()` of its file, and the files are `arenas/<key>.data.ts` and so on, made by `pnpm arenas`, `pnpm parks` and `pnpm grounds`.
+import { registerArenas } from "./arenas.core.js";
+import { ARENA_INDEX } from "./arenas.index.js";
+import { registerGrounds } from "./grounds.core.js";
+import { GROUND_INDEX } from "./grounds.index.js";
+import { registerParks } from "./parks.core.js";
+import { PARK_INDEX } from "./parks.index.js";
+import { KODOKAN_NAME } from "./kodokan.js";
+import { STADIUMS, stadiumKind } from "./stadiums.js";
+/** The files read, by kind and key, each once: asking again gives the same promise, and one that failed (the network) is asked for again next time. */
+const kept = new Map();
+function read(kind, index, id, keep) {
+    const key = `${kind}:${id}`;
+    const found = kept.get(key);
+    if (found !== undefined)
+        return found;
+    const entry = Object.hasOwn(index, id) ? index[id] : undefined;
+    if (entry === undefined)
+        return Promise.reject(new Error(`no ${kind} ${JSON.stringify(id)}: the ${kind}s are ${Object.keys(index).join(", ")}`));
+    const promise = entry.load().then(keep);
+    kept.set(key, promise);
+    promise.catch(() => kept.delete(key));
+    return promise;
+}
+/**
+ * An arena by its key, read from its own file the first time and held for the drawing after: asking again gives the same promise. A key that is not an arena rejects, naming the keys there are.
+ * @example
+ * ```ts
+ * import { loadArena } from "@johnmorrisdotca/kyogijo-stadiums/venue-data";
+ * const arena = await loadArena("rogers-arena");
+ * console.log(arena.name, arena.city);
+ * // Rogers Arena Vancouver
+ * ```
+ */
+export const loadArena = (id) => read("arena", ARENA_INDEX, id, (m) => registerArenas([m.ARENA])[0]);
+/** A park by its key, read from its own file the first time and held for the drawing after (see `loadArena`). */
+export const loadPark = (id) => read("park", PARK_INDEX, id, (m) => registerParks([m.PARK])[0]);
+/** A ground by its key, read from its own file the first time and held for the drawing after (see `loadArena`). */
+export const loadGround = (id) => read("ground", GROUND_INDEX, id, (m) => registerGrounds([m.GROUND])[0]);
+/**
+ * The records the drawing of some venues of a district reads, by kind: an arena's own, a ballpark's park, a stadium's ground, and nothing for a hall (which carries its own names) or the Kodokan. The keys are a district's (`rogers-arena`,
+ * `bc-place:cfl`).
+ * @example
+ * ```ts
+ * import { venueDataKeysFor } from "@johnmorrisdotca/kyogijo-stadiums/venue-data";
+ * console.log(venueDataKeysFor(["rogers-arena", "bc-place:cfl", "t-mobile-park:mlb"]));
+ * // {
+ * //   arenas: [ 'rogers-arena' ],
+ * //   parks: [ 't-mobile-park' ],
+ * //   grounds: [ 'bc-place' ]
+ * // }
+ * ```
+ */
+export function venueDataKeysFor(venues) {
+    const keys = { arenas: [], parks: [], grounds: [] };
+    const add = (list, id) => {
+        if (id !== undefined && !list.includes(id))
+            list.push(id);
+    };
+    for (const venue of venues) {
+        const id = venue.split(":")[0];
+        const stadium = Object.hasOwn(STADIUMS, id) ? STADIUMS[id] : undefined;
+        if (stadium !== undefined) {
+            const kind = stadiumKind(stadium);
+            if (kind === "park")
+                add(keys.parks, stadium.park);
+            else if (kind === "stadium")
+                add(keys.grounds, stadium.ground);
+        }
+        else if (Object.hasOwn(ARENA_INDEX, id))
+            add(keys.arenas, id);
+    }
+    return keys;
+}
+/**
+ * The records of the venues a page is about to draw, each read from its own file and no other, and held for the drawing: what `planDistrict`, `drawDistrict` and `mountDistrictTurn` of the lean district read. Await it before the
+ * first call and again when the venues change; a venue whose records are held is not read twice.
+ * @example
+ * ```ts
+ * import { loadVenueDataFor, planDistrict } from "@johnmorrisdotca/kyogijo-stadiums/district-lean";
+ * const venues = ["bc-place:cfl", "rogers-arena"];
+ * await loadVenueDataFor(venues);
+ * console.log(planDistrict({ venues }).members.length);
+ * // 2
+ * ```
+ */
+export async function loadVenueDataFor(venues) {
+    const keys = venueDataKeysFor(venues);
+    await Promise.all([...keys.arenas.map(loadArena), ...keys.parks.map(loadPark), ...keys.grounds.map(loadGround)]);
+}
+const nameIn = (index, id, language) => (id !== undefined && Object.hasOwn(index, id) ? (language === "ja" ? index[id].nameJa : index[id].name) : undefined);
+/**
+ * The name of a venue of a district in a language, from the lists of names alone: no record is read, so a page can list every venue to choose from and read only the records of those chosen. It is the name `districtMember(key, language).name[language]` gives.
+ * `undefined` for a key that is not a venue of a district.
+ * @example
+ * ```ts
+ * import { venueName } from "@johnmorrisdotca/kyogijo-stadiums/venue-data";
+ * console.log(venueName("rogers-arena", "en"), venueName("bc-place:cfl", "ja"));
+ * // Rogers Arena BCプレイス
+ * ```
+ */
+export function venueName(key, language = "en") {
+    const id = key.split(":")[0];
+    if (id === "kodokan")
+        return KODOKAN_NAME[language];
+    const stadium = Object.hasOwn(STADIUMS, id) ? STADIUMS[id] : undefined;
+    if (stadium === undefined)
+        return nameIn(ARENA_INDEX, id, language);
+    const kind = stadiumKind(stadium);
+    if (kind === "hall")
+        return stadium.names === undefined ? undefined : stadium.names[language];
+    return kind === "park" ? nameIn(PARK_INDEX, stadium.park, language) : nameIn(GROUND_INDEX, stadium.ground, language);
+}

package/dist/venue.js

@@ -6,7 +6,7 @@ import { densityOf, resolveCrowd } from "./crowd.js";
 import { patterns } from "./crowd.draw.js";
 import { crowdStands } from "./draw.js";
 import { NHL } from "./geometry.js";
-import { groundById } from "./grounds.js";
+import { heldGround } from "./grounds.core.js";
 import { ARC_STEPS, clipAround, clipConvex, clipSegment, areaOf, pointList, raked, slopeOf, stripsOf, tidy } from "./venue.geom.js";
 import { APRON_RISE, apronPlanes, backEdges, backWall, concourseFloor, rimAt, suiteWall } from "./venue.fill.js";
 import { firstHit, realBuilding } from "./venue.real.js";
@@ -47,7 +47,7 @@ export function standsVenue(o, v, lift) {
 export function standsVenueOf(stands, crowd, o, v, lift) {
     const cut = v.detail ?? "auto";
     const fine = crowd.detail !== "plain" && o.detail !== "simple";
-    const density = densityOf(crowd, stands.seats, groundById(o.ground)?.capacity);
+    const density = densityOf(crowd, stands.seats, heldGround(o.ground)?.capacity);
     const tifo = { home: stands.sectors.some((s) => s.kind === "tifo-home"), away: stands.sectors.some((s) => s.kind === "tifo-away") };
     const pid = `${v.id}-v`;
     const defs = fine ? patterns(pid, crowd, density, tifo.home || tifo.away ? tifo : undefined, stands.real !== undefined, true, stands.rings.some((r) => r.closed === true) || stands.sectors.some((s) => s.kind === "closed")) : "";

package/dist/venues-entry.d.ts

@@ -1,2 +1,3 @@
+import "./full.ts";
 export { VENUE_ATTRIBUTION, VENUE_CONFERENCES, VENUE_DIVISIONS, VENUE_IDS, VENUES, arenaOfVenue, bowlInside, conferenceOf, planVenue, venueBowl, venueById, venueByWikidata, venueOrientation, venueRink, venuesIn, venuesInConference } from "./venues.ts";
 export type { RealVenue, RealVenueData, VenueBasis, VenueConference, VenueDivision, VenueOrientation, VenueOsm, VenuePlan, VenueRoof } from "./venues.ts";

package/dist/venues-entry.js

@@ -1,2 +1,3 @@
 // The real venues of the NHL's arenas: the outline of each building and the way its rink lies (OpenStreetMap, ODbL 1.0) and a plausible bowl from the seats, tiers and roof the sources give (Wikidata, Wikipedia).
+import "./full.js";
 export { VENUE_ATTRIBUTION, VENUE_CONFERENCES, VENUE_DIVISIONS, VENUE_IDS, VENUES, arenaOfVenue, bowlInside, conferenceOf, planVenue, venueBowl, venueById, venueByWikidata, venueOrientation, venueRink, venuesIn, venuesInConference } from "./venues.js";

package/dist/venues.d.ts

@@ -1,4 +1,4 @@
-import { type Arena, type ArenaSource } from "./arenas.ts";
+import { type Arena, type ArenaSource } from "./arenas.core.ts";
 import { type Box, type Pt, type RealBowl } from "./crowd.ts";
 import { VENUE_ATTRIBUTION } from "./venues.osm.data.ts";
 export { VENUE_ATTRIBUTION };