@johnmorrisdotca/kyogijo-stadiums 0.45.0 → 0.45.1

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/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 };

package/dist/venues.js

@@ -2,7 +2,7 @@
 // the sources give (Wikidata, CC0, and the English Wikipedia article each fact cites), fitted inside the outline. Level one is the building: its outline and orientation, as OpenStreetMap maps them. Level two is a plausible
 // bowl: a number of seats in the number of tiers the sources say, between the rink's boards and the building's wall, under the roof's kind. It stops there: no team's or ticket seller's seat map is read or copied, no
 // section or row is named, and no mark of a team or a league is drawn. The drawing is `drawKyogijo({ sport: "nhl", arena, crowd: { real: true } })` and, in 3D, the same options in `buildTurn` or `mountTurn`.
-import { arenaById, arenaRinkIn } from "./arenas.js";
+import { heldArena, arenaRinkIn } from "./arenas.core.js";
 import { NORTH_ROOM, aislesOf, areaOfOutline, outlinePoints } from "./crowd.js";
 import { NHL, FEET_PER_METRE } from "./geometry.js";
 import { boxOf, edgeDistance, inside, metresFrom, middleOf, northOn, turnedTo } from "./venues.geo.js";
@@ -29,7 +29,7 @@ export const conferenceOf = (division) => VENUE_CONFERENCES.western.includes(div
 export const venuesInConference = (conference) => VENUE_CONFERENCES[conference].flatMap((division) => venuesIn(division));
 /** The arena a venue is of. */
 export const arenaOfVenue = (venue) => {
-    const arena = arenaById(venue.id);
+    const arena = heldArena(venue.id);
     if (arena === undefined)
         throw new Error(`${venue.id} is not an arena`);
     return arena;
@@ -41,7 +41,7 @@ export const venueOrientation = (venue) => ({ heading: venue.osm.axis.heading, b
 // ---- The bowl. ----
 /** The rink's box as the drawing has it: the arena's own where its sources publish a size, else the NHL's. */
 export function venueRink(venue) {
-    const sized = arenaRinkIn(arenaById(venue.id));
+    const sized = arenaRinkIn(heldArena(venue.id));
     return { x: 0, y: 0, w: sized?.length ?? NHL.length, h: sized?.width ?? NHL.width };
 }
 /** How far the first row is from the boards at the sides and at the ends, and the bench side's extra, and the corner's radius: the NHL profile of `crowd.ts`, so that a real venue's first row is the usual one. */

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** The package's version: the same as package.json's, and a test holds them to each other. */
-export declare const VERSION = "0.45.0";
+export declare const VERSION = "0.45.1";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** The package's version: the same as package.json's, and a test holds them to each other. */
-export const VERSION = "0.45.0";
+export const VERSION = "0.45.1";

package/dist/zones-entry.d.ts

@@ -1,2 +1,3 @@
+import "./full.ts";
 export { PARKS_WITHOUT_WALL_HEIGHTS, RULE_IDS, betweenHashes, homeRun, inCrease, inPaint, inPenaltyArea, inRedZone, inRestrictedArea, inSixYardBox, inSlot, isFair, isHomeRun, isThreePointer, onWarningTrack, overWall, wallHeightAt, zoneAt, zoneAtSurface, zoneName, zoneResolver } from "./rules.ts";
 export type { HomeRunOptions, HomeRunVerdict, PlaceLike, RuleId, ZoneAnswer, ZoneOptions } from "./rules.ts";

package/dist/zones-entry.js

@@ -1,2 +1,3 @@
 // The rulebook as code: where a point lies on a surface in the sport's own terms (the zone, the area in it, every other area that holds), and the yes-or-no questions a coach asks.
+import "./full.js";
 export { PARKS_WITHOUT_WALL_HEIGHTS, RULE_IDS, betweenHashes, homeRun, inCrease, inPaint, inPenaltyArea, inRedZone, inRestrictedArea, inSixYardBox, inSlot, isFair, isHomeRun, isThreePointer, onWarningTrack, overWall, wallHeightAt, zoneAt, zoneAtSurface, zoneName, zoneResolver } from "./rules.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johnmorrisdotca/kyogijo-stadiums",
-  "version": "0.45.0",
+  "version": "0.45.1",
   "description": "Kyogijo Stadiums 競技場, 40 sports' surfaces as SVG, drawn to scale from the rulebooks: NFL, CFL and IFAF football fields, an NHL rink, an NBA court, MLB ballparks, soccer pitches, curling sheets, athletics stadiums, speed skating, short track and figure skating rinks, swimming pools, water polo fields, diving wells, artistic swimming areas, and the courts and fields of tennis, volleyball (indoor, beach and sitting), badminton, pickleball, table tennis, padel, squash, racquetball, sepak takraw, teqball, roundnet, netball, lacrosse, rugby, Australian football, Gaelic games, cricket, field hockey and handball, and the budo of judo, karate, kendo, sumo and kyudo with a dojo of tatami laid as real units, the MMA cage, with each team's name and logo on its side and the score in the middle, stands and a crowd, a pageant of flags, and a 3D view. Light and dark, accessible, a compact badge for lists, a helper for React and a custom element. Zero dependencies.",
   "keywords": [
     "sports",
@@ -67,7 +67,11 @@
   "type": "module",
   "sideEffects": [
     "./dist/element-define.js",
-    "./dist/frames.providers.js"
+    "./dist/frames.providers.js",
+    "./dist/full.js",
+    "./dist/arenas.js",
+    "./dist/parks.js",
+    "./dist/grounds.js"
   ],
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -158,6 +162,16 @@
       "import": "./dist/areas-entry.js",
       "default": "./dist/areas-entry.js"
     },
+    "./venue-data": {
+      "types": "./dist/venue-data-entry.d.ts",
+      "import": "./dist/venue-data-entry.js",
+      "default": "./dist/venue-data-entry.js"
+    },
+    "./district-lean": {
+      "types": "./dist/district-lean-entry.d.ts",
+      "import": "./dist/district-lean-entry.js",
+      "default": "./dist/district-lean-entry.js"
+    },
     "./osm": {
       "types": "./dist/osm-entry.d.ts",
       "import": "./dist/osm-entry.js",
@@ -341,7 +355,9 @@
     "names:fetch": "node scripts/fetch-names.mjs",
     "tenants": "node scripts/build-tenants.mjs",
     "tenants:fetch": "node scripts/fetch-tenants.mjs",
-    "parks:check": "node scripts/check-parks.mjs"
+    "parks:check": "node scripts/check-parks.mjs",
+    "bundles": "node scripts/bundle-report.mjs --markdown",
+    "bundles:budget": "node scripts/bundle-report.mjs --no-paint --budget --write scripts/bundle-budget.json"
   },
   "devDependencies": {
     "@eslint/js": "^9.0.0",