@johnmorrisdotca/kyogijo-stadiums 0.28.0 → 0.31.0

package/dist/stadiums.js

@@ -1,12 +1,16 @@
-// The real stadiums: for a stadium that stages football and soccer, the outline of its building and the way its field lies in it (from OpenStreetMap, ODbL 1.0), and a bowl of the seats of each configuration, the
-// number of bowls and the kind of roof the sources give (Wikidata, CC0, and the English Wikipedia article each fact cites), fitted inside the outline. It is the stadium's counterpart of `venues.ts`, for a surface that is a
+// The real stadiums: for a stadium that stages football and soccer, or a ballpark, the outline of its building and the way its field lies in it (from OpenStreetMap, ODbL 1.0), and a bowl of the seats of each configuration,
+// the number of bowls and the kind of roof the sources give (Wikidata, CC0, and the English Wikipedia article each fact cites), fitted inside the outline. It is the stadium's counterpart of `venues.ts`, for a surface that is a
 // field and not a rink: level one is the building, level two a plausible bowl, and it stops there (no team's, ticket seller's or federation's seat map is read or copied, no section or row is named, and no mark of a club, a
-// league or a tournament is drawn). The drawing is `drawKyogijo({ sport: "cfl", stadium, crowd: { real: true } })` (or `sport: "soccer"` with a `ground` or a `stadium`) and, in 3D, the same options in `buildTurn`.
+// league or a tournament is drawn). The drawing is `drawKyogijo({ sport: "cfl", stadium, crowd: { real: true } })` (or `sport: "soccer"` with a `ground` or a `stadium`, `sport: "mlb"` with a `park`) and, in 3D, the same options
+// in `buildTurn`.
 import { NORTH_ROOM, aislesOf, areaOfOutline, outlinePoints } 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 { 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";
 import { STADIUM_DATA } from "./stadiums.data.js";
 import { STADIUM_OSM } from "./stadiums.osm.data.js";
 export { VENUE_ATTRIBUTION };
@@ -18,30 +22,49 @@ export const STADIUM_IDS = Object.freeze(STADIUM_DATA.map((data) => data.id));
 export const stadiumById = (id) => (id !== undefined && Object.prototype.hasOwnProperty.call(STADIUMS, id) ? STADIUMS[id] : undefined);
 /** The stadium whose Wikidata item is `Q612227`, or `undefined`. */
 export const stadiumByWikidata = (wikidata) => Object.values(STADIUMS).find((s) => s.wikidata === wikidata);
-/** The ground a stadium is (its name, place and pitch). */
+/** The kind of a stadium: a `stadium` unless it is a ballpark. */
+export const stadiumKind = (stadium) => stadium.kind ?? "stadium";
+/** The configurations a stadium has, in the order of its data. */
+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. */
 export const groundOfStadium = (stadium) => {
     const ground = groundById(stadium.ground);
     if (ground === undefined)
-        throw new Error(`${stadium.id} has no ground ${stadium.ground}`);
+        throw new Error(`${stadium.id} has no ground ${String(stadium.ground)}`);
     return ground;
 };
+/** The names a stadium goes by in both languages, of its ground or its park. */
+export function stadiumNames(stadium) {
+    if (stadiumKind(stadium) === "park") {
+        const park = PARKS[stadium.park ?? ""];
+        if (park === undefined)
+            throw new Error(`${stadium.id} has no park ${String(stadium.park)}`);
+        return { en: park.name, ja: park.nameJa };
+    }
+    const ground = groundOfStadium(stadium);
+    return { en: ground.name, ja: ground.nameJa };
+}
 const round = (value, places = 1) => Math.round(value * 10 ** places) / 10 ** places;
 const lonLat = (ring) => ring.map(([lon, lat]) => [lon, lat]);
+/** The heading the field's frame runs along, degrees clockwise from north: the long side's, and for a ballpark (whose frame has home plate at its origin, x to the right of the way out and y minus the way out) a quarter turn from the way out to centre field. */
+export const stadiumFrameHeading = (stadium) => (stadiumKind(stadium) === "park" ? (stadium.osm.axis.heading + 90) % 360 : stadium.osm.axis.heading);
 /** How the field lies in a stadium's building (see `StadiumOsm.axis`). */
-export const stadiumOrientation = (stadium) => ({ heading: stadium.osm.axis.heading, basis: stadium.osm.axis.basis, north: round(northOn(stadium.osm.axis.heading)) });
-/** The configuration a sport is: `cfl` or `soccer`, or `undefined` for a sport a stadium has no configuration for. */
-export const stadiumConfigOf = (sport) => (sport === "cfl" || sport === "soccer" ? sport : undefined);
-/** The seats of a stadium for a configuration. */
-export const stadiumSeats = (stadium, config) => stadium.configs[config].seats;
+export const stadiumOrientation = (stadium) => ({ heading: stadium.osm.axis.heading, basis: stadium.osm.axis.basis, north: round(northOn(stadiumFrameHeading(stadium))) });
+/** The configuration a sport is: `cfl`, `nfl`, `soccer` or `mlb`, or `undefined` for a sport a stadium has no configuration for. */
+export const stadiumConfigOf = (sport) => (sport === "cfl" || sport === "nfl" || sport === "soccer" || sport === "mlb" ? sport : undefined);
+/** The seats of a stadium for a configuration (0 for one it has none of). */
+export const stadiumSeats = (stadium, config) => stadium.configs[config]?.seats ?? 0;
 // ---- The bowl. ----
-/** How far the first row is from a football field's footprint (the CFL's, the field and its end zones) along a side and at an end, and the corner's radius: the package's own gridiron profile (`crowd.ts`), so that a real stadium's first row is the usual one. */
-const FIRST_ROW = { side: 42, end: 28, corner: 60 };
+/** How far the first row is from a football field's footprint (the league's field and its end zones) along a side and at an end, and the corner's radius: the package's own gridiron profile (`crowd.ts`), so that a real stadium's first row is the usual one. */
+const FIRST_ROW = { cfl: { side: 42, end: 28, corner: 60 }, nfl: { side: 40, end: 26, corner: 60 } };
 /** The height of the first row above the field, in feet, the rise of a bowl's rows by the number of bowls (what the lowest, a middle and the upper rise, at most), and the rise of the walk between two bowls (a suite level): ours, no source gives them. */
 export const STADIUM_FIRST_HEIGHT = 5;
 export const STADIUM_RISES = { 1: [60], 2: [38, 62], 3: [32, 26, 56] };
 export const STADIUM_WALK_RISE = 24;
 /** The height a roof's rim stands over the top row, at the least, in feet. */
 export const STADIUM_CLEARANCE = 22;
+/** How far a canopy's low edge stands over the top row at the least, in feet: a bowl under a canopy is lowered to keep it. */
+export const CANOPY_CLEARANCE = 6;
 /** The share of the seats in the lowest bowl where no source says. */
 const LOWER_SHARE = 0.5;
 const CORNER = 0.7;
@@ -68,17 +91,21 @@ function solveFor(f, lo, hi, target) {
 const PLANS = new WeakMap();
 /**
  * The plan of a stadium's bowl for a configuration: the building's outline turned so that the field lies along x, a first row round a football field's footprint as a gridiron's stands have it, the largest bowl-shaped
- * outline that fits the building round the middle of the field, and between the two the bowls, the outer edge of each placed so that its band holds the share of the configuration's seats the sources give it, with a walk
- * between them. The bowl is the same building for football and soccer (the seats of the configuration differ, and the field).
+ * outline that fits the building round the middle of the field, and between the two the bowls, the outer edge of each placed so that its band holds the share of the seats the sources give it, with a walk
+ * between them. The bowl is the same building for every configuration (the seats of the configuration differ, and the field); where a bowl holds more seats than a configuration opens, the rest are closed.
  * @example
  * ```ts
  * import { planStadium, stadiumById } from "@johnmorrisdotca/kyogijo-stadiums/stadiums";
  * const plan = planStadium(stadiumById("bc-place")!, "soccer", { x: 0, y: 0, w: 344.5, h: 223.1 });
- * console.log(plan.orientation.basis, plan.seats.map((t) => t.tier).join(" "), plan.total);
- * // opening lower upper 52497
+ * console.log(plan.orientation.basis, plan.seats.map((t) => `${t.tier} ${t.seats}`).join(", "), plan.total);
+ * // opening lower 27695, upper 24802 52497
  * ```
  */
 export function planStadium(stadium, config, box) {
+    if (stadiumKind(stadium) !== "stadium")
+        throw new Error(`${stadium.id} is a ballpark: planPark plans it`);
+    if (stadium.configs[config] === undefined)
+        throw new Error(`${stadium.id} has no configuration ${config}`);
     const key = `${config}|${box.x}|${box.y}|${box.w}|${box.h}`;
     const mine = PLANS.get(stadium) ?? new Map();
     PLANS.set(stadium, mine);
@@ -102,9 +129,11 @@ function plan(stadium, config, rink) {
     const openingRing = stadium.osm.roof?.opening?.ring;
     const opening = openingRing === undefined ? undefined : place(turned(openingRing));
     // The first row round a football field's footprint, and the largest bowl-shaped outline that fits inside the building round the middle of the field.
-    const gridiron = FOOTBALL.cfl;
+    const kind = stadium.gridiron ?? "cfl";
+    const gridiron = FOOTBALL[kind];
+    const row = FIRST_ROW[kind];
     const length = gridiron.length + 2 * gridiron.endZone;
-    const first = { kind: "rrect", x0: at[0] - length / 2 - FIRST_ROW.end, y0: at[1] - gridiron.width / 2 - FIRST_ROW.side, x1: at[0] + length / 2 + FIRST_ROW.end, y1: at[1] + gridiron.width / 2 + FIRST_ROW.side, r: FIRST_ROW.corner };
+    const first = { kind: "rrect", x0: at[0] - length / 2 - row.end, y0: at[1] - gridiron.width / 2 - row.side, x1: at[0] + length / 2 + row.end, y1: at[1] + gridiron.width / 2 + row.side, r: row.corner };
     const shapedAs = (long, s) => ({ kind: "rrect", x0: at[0] - long * s, y0: at[1] - s, x1: at[0] + long * s, y1: at[1] + s, r: CORNER * s });
     const largest = (long) => {
         let [lo, hi] = [60, Math.max(fb.x1 - fb.x0, fb.y1 - fb.y0)];
@@ -123,12 +152,15 @@ function plan(stadium, config, rink) {
     const outer = { ...wall, x0: Math.min(wall.x0, first.x0 - 40), y0: Math.min(wall.y0, first.y0 - 40), x1: Math.max(wall.x1, first.x1 + 40), y1: Math.max(wall.y1, first.y1 + 40) };
     const depth = (first.x0 - outer.x0) + (first.y0 - outer.y0) + (outer.x1 - first.x1) + (outer.y1 - first.y1);
     const gap = GAP / Math.max(20, depth / 4);
-    const seatsTotal = stadium.configs[config].seats;
-    const count = stadium.tiers.count;
+    const open = stadium.configs[config]?.seats ?? 0;
+    const seatsTotal = stadium.bowlSeats ?? open;
+    const count = Math.min(3, stadium.tiers.count);
     const lower = stadium.tiers.lowerSeats === undefined ? (count === 1 ? 1 : count === 2 ? LOWER_SHARE : 0.36) : stadium.tiers.lowerSeats / seatsTotal;
     const shares = count === 1 ? [1] : count === 2 ? [lower, 1 - lower] : [lower, (1 - lower) * 0.36, (1 - lower) * 0.64];
     const outlineAt = (t) => between(first, outer, t);
-    const build = (area) => {
+    // A canopy's low edge is the least height the top row may reach (less the clearance): a bowl under a canopy is lowered, by the factor `vscale`, if it would not clear.
+    const low = stadium.osm.canopies === undefined ? Infinity : Math.min(...stadium.osm.canopies.map((c) => (c.height - c.rise) * FEET_PER_METRE));
+    const build = (area, vscale) => {
         const seatsOf = (region, hole) => Math.round((areaOfOutline(region) - areaOfOutline(hole)) / area);
         const rings = [];
         let t0 = 0;
@@ -143,8 +175,8 @@ function plan(stadium, config, rink) {
             const hole = outlineAt(t0);
             const tier = TIER_IDS[count][k];
             const run = (region.y1 - hole.y1 + (hole.y0 - region.y0)) / 2;
-            const rise = Math.min(STADIUM_RISES[count][k], Math.max(6, run * Math.tan((MAX_RAKE * Math.PI) / 180)));
-            const h0 = k === 0 ? STADIUM_FIRST_HEIGHT : up + STADIUM_WALK_RISE;
+            const rise = Math.min(STADIUM_RISES[count][k] * vscale, Math.max(6, run * Math.tan((MAX_RAKE * Math.PI) / 180)));
+            const h0 = k === 0 ? STADIUM_FIRST_HEIGHT : up + STADIUM_WALK_RISE * vscale;
             const h1 = h0 + rise;
             up = h1;
             rings.push({
@@ -164,27 +196,43 @@ function plan(stadium, config, rink) {
         });
         return { rings, tight };
     };
+    const heightOf = (made) => made.rings[made.rings.length - 1].height[1];
     let seatArea = SEAT_AREAS[0];
-    let made = build(seatArea);
+    let made = build(seatArea, 1);
     for (const area of SEAT_AREAS.slice(1)) {
         if (!made.tight)
             break;
         seatArea = area;
-        made = build(area);
+        made = build(area, 1);
+    }
+    // (A bowl's rise is capped by its rake, so lowering it is not in proportion: a few rounds bring the top row under the canopy.)
+    let vscale = 1;
+    for (let pass = 0; pass < 10 && heightOf(made) > low - CANOPY_CLEARANCE + 0.5; pass += 1) {
+        vscale = Math.max(0.1, vscale * ((low - CANOPY_CLEARANCE - STADIUM_FIRST_HEIGHT) / (heightOf(made) - STADIUM_FIRST_HEIGHT)));
+        made = build(seatArea, vscale);
     }
     const { rings, tight } = made;
-    // The rounding of each bowl's seats leaves the total a seat or two off the configuration's: the last bowl takes the difference.
+    // The rounding of each bowl's seats leaves the total a seat or two off the bowl's: the last bowl takes the difference.
     const missing = seatsTotal - rings.reduce((sum, ring) => sum + ring.seats, 0);
     if (!tight && Math.abs(missing) <= 3)
         rings[rings.length - 1].seats += missing;
     const total = rings.reduce((sum, ring) => sum + ring.seats, 0);
+    // A configuration that opens fewer seats than the bowl holds opens them from the lowest bowl up: a bowl's people are its open share of them, and a closed one is empty.
+    if (open < seatsTotal) {
+        let before = 0;
+        for (const ring of rings) {
+            ring.fill = round(ring.fill * Math.min(1, Math.max(0, (open - before) / Math.max(1, ring.seats))), 3);
+            before += ring.seats;
+        }
+    }
     const top = rings[rings.length - 1].height[1];
     const roof = stadium.osm.roof;
     const rise = roof?.rise === undefined ? 0 : round(roof.rise * FEET_PER_METRE);
-    // The rim of the roof stands where OpenStreetMap maps it (its height less the roof's own rise), and at the least over the top row by a roof's clearance.
+    // The rim of a roof stands where OpenStreetMap maps it (its height less the roof's own rise), and at the least over the top row by a roof's clearance; a canopy's building has walls to the top row and a little over it.
     const mapped = roof?.height === undefined ? 0 : round((roof.height - (roof.rise ?? 0)) * FEET_PER_METRE);
-    const edge = Math.max(mapped, top + STADIUM_CLEARANCE);
+    const edge = stadium.roof.kind === "canopy" ? round(top + CANOPY_CLEARANCE) : Math.max(mapped, top + STADIUM_CLEARANCE);
     const cable = stadium.roof.kind === "cable" && opening !== undefined && rise > 0;
+    const canopies = stadium.roof.kind === "canopy" && stadium.osm.canopies !== undefined ? stadium.osm.canopies.map((c) => ({ ring: place(turned(c.ring)), low: round((c.height - c.rise) * FEET_PER_METRE), rise: round(c.rise * FEET_PER_METRE) })) : undefined;
     const north = orientation.basis === "none" ? undefined : orientation.north;
     const room = north === undefined ? 0 : NORTH_ROOM;
     const bowl = {
@@ -195,12 +243,13 @@ function plan(stadium, config, rink) {
             footprint,
             hall: { ...outer, x0: outer.x0 - HALL, y0: outer.y0 - HALL, x1: outer.x1 + HALL, y1: outer.y1 + HALL, r: outer.r + HALL },
             ...(north === undefined ? {} : { north }),
-            roof: cable ? "cable" : "fixed",
+            roof: cable ? "cable" : canopies === undefined ? "fixed" : "canopy",
             edge,
             ...(cable ? { crown: { rise, opening } } : {}),
+            ...(canopies === undefined ? {} : { canopies }),
         },
     };
-    return { stadium, config, orientation, box: rink, footprint, opening, bowl, seats: rings.map((ring) => ({ tier: ring.tier, seats: ring.seats })), total, seatArea, fit: tight ? "tight" : "fits" };
+    return { stadium, config, orientation, box: rink, footprint, opening, bowl, seats: rings.map((ring) => ({ tier: ring.tier, seats: ring.seats })), total, open, seatArea, fit: tight ? "tight" : "fits" };
 }
 /** The stands of a stadium for `layoutOf` and the 3D view, round a field: `planStadium`'s bowl. */
 export const stadiumBowl = (stadium, config, box) => planStadium(stadium, config, box).bowl;
@@ -208,3 +257,83 @@ export const stadiumBowl = (stadium, config, box) => planStadium(stadium, config
 export function stadiumBowlInside(plan) {
     return outlinePoints(plan.bowl.rings[plan.bowl.rings.length - 1].region).every((p) => inside(plan.footprint, p));
 }
+const PARK_PLANS = new WeakMap();
+/** The share of a ballpark's building the closed roof covers, and the share of its width along the east side the open roof's sections rest over (ours: the article says where they rest, not how much). */
+const PARK_COVER = 0.92;
+const PARK_PARKED = 0.3;
+/**
+ * The plan of a ballpark from what its stands are laid from (`input`: the park's fence, the backstop and the crowd): the usual stands with each band as deep as its seats need, the building's outline turned so that home
+ * plate faces where OpenStreetMap's infield and the outline say, and the roof: sections far over the field, closed over the stands and the field or resting over the east side where the article says they rest.
+ */
+export function planPark(stadium, input) {
+    if (stadiumKind(stadium) !== "park")
+        throw new Error(`${stadium.id} is not a ballpark`);
+    const key = JSON.stringify([input.fence, input.backstop, input.crowd.shape, input.crowd.awayEnd, input.crowd.tifo, input.crowd.gaps, input.seatsOnWalls ?? null]);
+    const mine = PARK_PLANS.get(stadium) ?? new Map();
+    PARK_PLANS.set(stadium, mine);
+    const known = mine.get(key);
+    if (known !== undefined)
+        return known;
+    const made = park(stadium, input);
+    mine.set(key, made);
+    return made;
+}
+function park(stadium, input) {
+    const config = "mlb";
+    const seats = stadium.configs.mlb?.seats ?? 0;
+    const bands = stadium.tiers.tierSeats ?? { lower: seats * 0.45, upper: seats * 0.47, bleachers: seats * 0.08 };
+    const sum = bands.lower + bands.upper + bands.bleachers;
+    const wanted = { lower: (bands.lower / sum) * seats, upper: (bands.upper / sum) * seats, bleachers: (bands.bleachers / sum) * seats };
+    // Each band is as deep as holds its seats: the usual depths scaled by what the seats of the band are to what the band holds, a few rounds over (a band's seats grow with its depth).
+    const depths = { lower: 60, upper: 56, bleachers: 54 };
+    let stands = parkLayout({ ...input, depths });
+    for (let i = 0; i < 12; i += 1) {
+        const held = (id) => stands.rings.find((r) => r.id === id)?.seats ?? 0;
+        const next = { lower: depths.lower * (wanted.lower / Math.max(1, held("lower"))), upper: depths.upper * (wanted.upper / Math.max(1, held("upper"))), bleachers: depths.bleachers * (wanted.bleachers / Math.max(1, held("bleachers"))) };
+        for (const k of ["lower", "upper", "bleachers"])
+            depths[k] = Math.min(160, Math.max(20, next[k]));
+        stands = parkLayout({ ...input, depths });
+    }
+    const total = stands.rings.reduce((n, r) => n + r.seats, 0);
+    const orientation = stadiumOrientation(stadium);
+    const frameHeading = stadiumFrameHeading(stadium);
+    // The building in the park's frame, in feet: home plate at the origin.
+    const origin = middleOf(lonLat(stadium.osm.ring));
+    const world = metresFrom(origin, lonLat(stadium.osm.ring));
+    const [home] = metresFrom(origin, [stadium.osm.axis.centre]);
+    const frameOf = (p) => {
+        const [x, y] = turnedTo(frameHeading, [p[0] - home[0], p[1] - home[1]]);
+        return [round(x * FEET_PER_METRE, 2), round(y * FEET_PER_METRE, 2)];
+    };
+    const footprint = world.map(frameOf);
+    const fb = boxOf(footprint);
+    const box = stands.box;
+    const c = [box.x + box.w / 2, box.y + box.h / 2];
+    const cover = footprint.map((p) => [c[0] + (p[0] - c[0]) * PARK_COVER, c[1] + (p[1] - c[1]) * PARK_COVER]);
+    // Where the sections rest: the east side of the building, over the railway there (the article says so): the strip of the outline east of a share of its width.
+    const [wx0, wx1] = [Math.min(...world.map((p) => p[0])), Math.max(...world.map((p) => p[0]))];
+    const [wy0, wy1] = [Math.min(...world.map((p) => p[1])), Math.max(...world.map((p) => p[1]))];
+    const strip = clipConvex(world, [[wx1 - (wx1 - wx0) * PARK_PARKED, wy0 - 1], [wx1 + 1, wy0 - 1], [wx1 + 1, wy1 + 1], [wx1 - (wx1 - wx0) * PARK_PARKED, wy1 + 1]]);
+    const parked = strip.map(frameOf);
+    const north = orientation.basis === "none" ? undefined : orientation.north;
+    const room = north === undefined ? 0 : NORTH_ROOM;
+    const wallFeet = round((stadium.osm.height ?? 20) * FEET_PER_METRE);
+    const hall = { kind: "rrect", x0: fb.x0 - 30, y0: fb.y0 - 30, x1: fb.x1 + 30, y1: fb.y1 + 30, r: 0 };
+    const shell = {
+        footprint,
+        hall,
+        ...(north === undefined ? {} : { north }),
+        roof: "panels",
+        edge: wallFeet,
+        wall: wallFeet,
+        panels: { cover, bottom: stadium.roof.bottom ?? 217, top: stadium.roof.top ?? 269, parked },
+    };
+    const reach = {
+        left: Math.max(stands.reach.left, box.x - fb.x0),
+        right: Math.max(stands.reach.right, fb.x1 - box.x - box.w),
+        top: Math.max(stands.reach.top, box.y - fb.y0) + room,
+        bottom: Math.max(stands.reach.bottom, fb.y1 - box.y - box.h),
+    };
+    const real = { ...stands, real: shell, reach };
+    return { stadium, config, orientation, footprint, stands: real, depths: { lower: round(depths.lower), upper: round(depths.upper), bleachers: round(depths.bleachers) }, seats: stands.rings.map((r) => ({ tier: r.id, seats: r.seats })), total, fit: Math.abs(total - seats) / seats <= 0.02 ? "fits" : "tight" };
+}

package/dist/stadiums.osm.data.js

@@ -5,6 +5,7 @@ export const STADIUM_OSM = {
         "base": "2026-10-20T21:46:16Z",
         "licence": "ODbL-1.0",
         "attribution": "(c) OpenStreetMap contributors, ODbL 1.0, openstreetmap.org/copyright",
+        "height": 61,
         "axis": { "heading": 52.8, "basis": "opening", "strength": 1.47, "elongation": 1.19, "centre": [-123.112002, 49.276698] },
         "roof": {
             "source": "relation/5836463",
@@ -55,4 +56,117 @@ export const STADIUM_OSM = {
             [-123.113623, 49.276478],
         ],
     },
+    "lumen-field": {
+        "source": "relation/2305831",
+        "read": "2026-10-20",
+        "base": "2026-10-20T23:05:49Z",
+        "licence": "ODbL-1.0",
+        "attribution": "(c) OpenStreetMap contributors, ODbL 1.0, openstreetmap.org/copyright",
+        "axis": { "heading": 0, "basis": "pitch", "strength": 1.32, "elongation": 2.16, "centre": [-122.33163, 47.595154] },
+        "canopies": [
+            { "source": "way/458208106", "height": 36, "rise": 10, "ring": [
+                    [-122.332395, 47.596154],
+                    [-122.33234, 47.595145],
+                    [-122.332404, 47.594143],
+                    [-122.332683, 47.594276],
+                    [-122.332869, 47.594407],
+                    [-122.333005, 47.594605],
+                    [-122.333075, 47.594764],
+                    [-122.333159, 47.595095],
+                    [-122.33313, 47.59539],
+                    [-122.332993, 47.595744],
+                    [-122.332861, 47.59592],
+                    [-122.332747, 47.596004],
+                    [-122.332452, 47.596154],
+                ] },
+            { "source": "way/458208107", "height": 36, "rise": 10, "ring": [
+                    [-122.330897, 47.596155],
+                    [-122.330837, 47.596159],
+                    [-122.33062, 47.596055],
+                    [-122.330448, 47.595948],
+                    [-122.330298, 47.595762],
+                    [-122.330117, 47.5953],
+                    [-122.330116, 47.59501],
+                    [-122.330212, 47.594711],
+                    [-122.33041, 47.594391],
+                    [-122.330582, 47.594279],
+                    [-122.330872, 47.59415],
+                    [-122.330942, 47.595174],
+                    [-122.330936, 47.595579],
+                ] },
+        ],
+        "ring": [
+            [-122.332249, 47.59627],
+            [-122.332463, 47.596203],
+            [-122.332661, 47.596118],
+            [-122.33284, 47.596015],
+            [-122.332996, 47.595897],
+            [-122.333126, 47.595765],
+            [-122.333162, 47.595677],
+            [-122.333156, 47.594577],
+            [-122.333041, 47.594455],
+            [-122.332904, 47.594343],
+            [-122.332747, 47.594244],
+            [-122.332574, 47.594159],
+            [-122.332187, 47.594034],
+            [-122.331979, 47.593997],
+            [-122.331766, 47.593978],
+            [-122.331338, 47.593994],
+            [-122.331311, 47.594047],
+            [-122.331129, 47.594028],
+            [-122.330739, 47.594148],
+            [-122.330405, 47.594329],
+            [-122.330265, 47.594439],
+            [-122.330166, 47.594722],
+            [-122.330125, 47.59496],
+            [-122.330117, 47.5953],
+            [-122.330168, 47.595589],
+            [-122.330269, 47.59587],
+            [-122.330506, 47.596048],
+            [-122.330646, 47.596124],
+            [-122.331021, 47.596263],
+            [-122.331021, 47.596093],
+            [-122.331134, 47.596093],
+            [-122.331227, 47.596281],
+            [-122.332031, 47.596283],
+            [-122.332131, 47.596089],
+            [-122.33225, 47.596089],
+        ],
+    },
+    "t-mobile-park": {
+        "source": "relation/3008332",
+        "read": "2026-10-20",
+        "base": "2026-10-20T23:06:50Z",
+        "licence": "ODbL-1.0",
+        "attribution": "(c) OpenStreetMap contributors, ODbL 1.0, openstreetmap.org/copyright",
+        "height": 21,
+        "axis": { "heading": 49.4, "basis": "infield", "strength": 1.43, "elongation": 1, "centre": [-122.332905, 47.591117] },
+        "ring": [
+            [-122.330843, 47.59228],
+            [-122.331382, 47.590448],
+            [-122.333677, 47.590452],
+            [-122.333678, 47.59047],
+            [-122.333819, 47.590456],
+            [-122.333945, 47.5905],
+            [-122.333997, 47.590554],
+            [-122.334013, 47.590618],
+            [-122.333989, 47.590681],
+            [-122.33393, 47.59073],
+            [-122.333978, 47.59073],
+            [-122.333975, 47.59216],
+            [-122.333739, 47.59216],
+            [-122.33374, 47.591759],
+            [-122.333776, 47.591759],
+            [-122.333776, 47.591748],
+            [-122.333683, 47.591723],
+            [-122.333451, 47.592099],
+            [-122.333388, 47.592119],
+            [-122.333409, 47.592138],
+            [-122.333293, 47.5922],
+            [-122.333231, 47.592154],
+            [-122.333131, 47.592213],
+            [-122.333256, 47.592215],
+            [-122.333251, 47.592271],
+        ],
+    },
 };

package/dist/strings.d.ts

@@ -516,6 +516,10 @@ export interface KyogijoWords {
         stadiumOpening: string;
         stadiumBuilding: string;
         stadiumNone: string;
+        /** A ballpark's stands: {seats} seats fitted inside the outline of {stadium}'s building; and how the pitch or the infield says the field lies. */
+        stadiumPark: string;
+        stadiumPitch: string;
+        stadiumInfield: string;
         /** A district: a plan of {count} real venues at their real positions, {mode}; and what `mode` says for the two kinds of plan, and the word before the credit. */
         district: string;
         districtNeighbours: string;

package/dist/strings.js

@@ -199,7 +199,7 @@ export const KYOGIJO_STRINGS = {
             },
         },
         scoreTitle: "{away} {awayScore}, {home} {homeScore}",
-        said: { home: "home", away: "away", won: "{name} won.", tied: "The game is level.", park: "The outfield fence follows the figures published for {park}.", officially: "Its official name is {name}.", ground: "The pitch follows the size published for {ground}.", groundDefault: "No pitch size is published for {ground}, so the pitch has the international size of 105 by 68 metres.", arenaRink: "{arena}, hockey rink", arenaCourt: "{arena}, basketball court", arenaRinkAbout: "an ice hockey rink, {length} by {width} feet ({lengthM} by {widthM} metres) with rounded corners, with its red and blue lines, face-off circles, creases and goal nets", arenaCourtAbout: "a basketball court, {length} by {width} feet ({lengthM} by {widthM} metres), with its keys, three-point lines, free-throw circles and the centre circle", arenaSize: "The size is the one published for {arena}.", arenaUnknown: "The article says the rink of {arena} was shorter than the NHL's but gives no size, so the NHL's is drawn.", real: "The stands are a plausible bowl of {seats} seats in {tiers} tiers, fitted inside the outline of the building of {arena} from OpenStreetMap ((c) OpenStreetMap contributors); it is not the arena's plan.", realBuilding: "The rink lies along the building's long axis, which is an inference, and the arrow points north.", realMapped: "The rink lies as OpenStreetMap maps the ice, and the arrow points north.", realNone: "The rink's orientation is not known, so it is drawn east-west with north at the top.", stadium: "The stands are a plausible bowl of {seats} seats in {tiers} bowls, fitted inside the outline of the building of {stadium} from OpenStreetMap ((c) OpenStreetMap contributors); it is not the stadium's plan.", stadiumOpening: "The field lies along the opening in the roof, which is the size of the field, and the arrow points north.", stadiumBuilding: "The field lies along the building's long axis, which is an inference, and the arrow points north.", stadiumNone: "The field's orientation is not known, so it is drawn east-west with north at the top.", district: "A plan of {count} real venues at their real positions and orientations, from the outlines OpenStreetMap maps; {mode}.", districtNeighbours: "it is fitted close round the buildings", districtCity: "it keeps the real distances, with a grid of kilometres and a scale", districtCredit: "Credit:", era: "The markings are those of the {season} season.", hammer: "{name} has the hammer.", ends: "By end, {name}: {list}.", total: "Total", wonPens: "{name} won {a}-{b} on penalties.", pens: "{a}-{b} pens", on: "Drawn as", sep: ", ", stop: ".", colon: ": ", gap: " " },
+        said: { home: "home", away: "away", won: "{name} won.", tied: "The game is level.", park: "The outfield fence follows the figures published for {park}.", officially: "Its official name is {name}.", ground: "The pitch follows the size published for {ground}.", groundDefault: "No pitch size is published for {ground}, so the pitch has the international size of 105 by 68 metres.", arenaRink: "{arena}, hockey rink", arenaCourt: "{arena}, basketball court", arenaRinkAbout: "an ice hockey rink, {length} by {width} feet ({lengthM} by {widthM} metres) with rounded corners, with its red and blue lines, face-off circles, creases and goal nets", arenaCourtAbout: "a basketball court, {length} by {width} feet ({lengthM} by {widthM} metres), with its keys, three-point lines, free-throw circles and the centre circle", arenaSize: "The size is the one published for {arena}.", arenaUnknown: "The article says the rink of {arena} was shorter than the NHL's but gives no size, so the NHL's is drawn.", real: "The stands are a plausible bowl of {seats} seats in {tiers} tiers, fitted inside the outline of the building of {arena} from OpenStreetMap ((c) OpenStreetMap contributors); it is not the arena's plan.", realBuilding: "The rink lies along the building's long axis, which is an inference, and the arrow points north.", realMapped: "The rink lies as OpenStreetMap maps the ice, and the arrow points north.", realNone: "The rink's orientation is not known, so it is drawn east-west with north at the top.", stadium: "The stands are a plausible bowl of {seats} seats in {tiers} bowls, fitted inside the outline of the building of {stadium} from OpenStreetMap ((c) OpenStreetMap contributors); it is not the stadium's plan.", stadiumOpening: "The field lies along the opening in the roof, which is the size of the field, and the arrow points north.", stadiumBuilding: "The field lies along the building's long axis, which is an inference, and the arrow points north.", stadiumNone: "The field's orientation is not known, so it is drawn east-west with north at the top.", stadiumPark: "The stands are the usual stands of a ballpark, each band as deep as its seats need, for {seats} seats, fitted inside the outline of the building of {stadium} from OpenStreetMap ((c) OpenStreetMap contributors); it is not the park's plan.", stadiumPitch: "The field lies as OpenStreetMap maps the pitch, and the arrow points north.", stadiumInfield: "The way home plate faces is worked out from the infield OpenStreetMap maps and the building's outline, and the arrow points north.", district: "A plan of {count} real venues at their real positions and orientations, from the outlines OpenStreetMap maps; {mode}.", districtNeighbours: "it is fitted close round the buildings", districtCity: "it keeps the real distances, with a grid of kilometres and a scale", districtCredit: "Credit:", era: "The markings are those of the {season} season.", hammer: "{name} has the hammer.", ends: "By end, {name}: {list}.", total: "Total", wonPens: "{name} won {a}-{b} on penalties.", pens: "{a}-{b} pens", on: "Drawn as", sep: ", ", stop: ".", colon: ": ", gap: " " },
         budo: {
             sides: { north: "north", south: "south", east: "east", west: "west" },
             judo: "a judo contest area of {contest} by {contest} metres in a safety area {safety} metres wide, laid with tatami of {tatami}",
@@ -758,7 +758,7 @@ export const KYOGIJO_STRINGS = {
             },
         },
         scoreTitle: "{away} {awayScore}、{home} {homeScore}",
-        said: { home: "ホーム", away: "アウェイ", won: "{name}の勝ちです。", tied: "同点です。", park: "外野フェンスは、{park}の公表されている距離をもとに描かれています。", officially: "正式名称は{name}です。", ground: "ピッチは、{ground}の公表されている広さをもとに描かれています。", groundDefault: "{ground}のピッチの広さは公表されていないため、国際標準の105×68mで描かれています。", arenaRink: "{arena}のアイスホッケーリンク", arenaCourt: "{arena}のバスケットボールコート", arenaRinkAbout: "アイスホッケーのリンク。{length}フィート（約{lengthM}m）×{width}フィート（約{widthM}m）で角が丸く、レッドライン、ブルーライン、フェイスオフサークル、クリース、ゴールがあります", arenaCourtAbout: "バスケットボールのコート。{length}フィート（約{lengthM}m）×{width}フィート（約{widthM}m）で、ペイントエリア、スリーポイントライン、フリースローサークル、センターサークルがあります", arenaSize: "広さは、{arena}の公表されている数値をもとに描かれています。", arenaUnknown: "{arena}のリンクはNHLの規格より短かったとされていますが、広さが示されていないため、NHLの規格で描かれています。", real: "スタンドは、OpenStreetMapの建物の輪郭（(c) OpenStreetMap contributors）の内側に収まるように、{arena}の{seats}席・{tiers}層を推定して描いたもので、アリーナの設計図ではありません。", realBuilding: "リンクは建物の長い軸に沿って置いており（推定）、矢印は北を指します。", realMapped: "リンクの向きはOpenStreetMapに記録された氷面のとおりで、矢印は北を指します。", realNone: "リンクの向きは分かっていないため、東西に置き、北を上にしています。", stadium: "{stadium}の建物の輪郭（OpenStreetMap、(c) OpenStreetMap contributors）の内側に、{seats}席・{tiers}層のスタンドを推定して描いています。スタジアムの設計図ではありません。", stadiumOpening: "フィールドは屋根の開口部（フィールドと同じ大きさ）に沿って置いており、矢印は北を指します。", stadiumBuilding: "フィールドは建物の長い軸に沿って置いており（推定）、矢印は北を指します。", stadiumNone: "フィールドの向きは分かっていないため、東西に置き、北を上にしています。", district: "OpenStreetMapの建物の輪郭をもとに、{count}か所の実在の会場を実際の位置と向きのとおりに並べた配置図です。{mode}。", districtNeighbours: "建物のすぐ近くまで寄せて描いています", districtCity: "実際の距離を保ち、1km方眼と縮尺を添えています", districtCredit: "出典：", era: "ラインやマークは{season}シーズンのものです。", hammer: "{name}がハンマー（最後の1投）を持っています。", ends: "{name}のエンドごとの得点：{list}。", total: "合計", wonPens: "{name}がPK戦を{a}-{b}で制しました。", pens: "PK戦 {a}-{b}", on: "図の内容", sep: "、", stop: "。", colon: "：", gap: "" },
+        said: { home: "ホーム", away: "アウェイ", won: "{name}の勝ちです。", tied: "同点です。", park: "外野フェンスは、{park}の公表されている距離をもとに描かれています。", officially: "正式名称は{name}です。", ground: "ピッチは、{ground}の公表されている広さをもとに描かれています。", groundDefault: "{ground}のピッチの広さは公表されていないため、国際標準の105×68mで描かれています。", arenaRink: "{arena}のアイスホッケーリンク", arenaCourt: "{arena}のバスケットボールコート", arenaRinkAbout: "アイスホッケーのリンク。{length}フィート（約{lengthM}m）×{width}フィート（約{widthM}m）で角が丸く、レッドライン、ブルーライン、フェイスオフサークル、クリース、ゴールがあります", arenaCourtAbout: "バスケットボールのコート。{length}フィート（約{lengthM}m）×{width}フィート（約{widthM}m）で、ペイントエリア、スリーポイントライン、フリースローサークル、センターサークルがあります", arenaSize: "広さは、{arena}の公表されている数値をもとに描かれています。", arenaUnknown: "{arena}のリンクはNHLの規格より短かったとされていますが、広さが示されていないため、NHLの規格で描かれています。", real: "スタンドは、OpenStreetMapの建物の輪郭（(c) OpenStreetMap contributors）の内側に収まるように、{arena}の{seats}席・{tiers}層を推定して描いたもので、アリーナの設計図ではありません。", realBuilding: "リンクは建物の長い軸に沿って置いており（推定）、矢印は北を指します。", realMapped: "リンクの向きはOpenStreetMapに記録された氷面のとおりで、矢印は北を指します。", realNone: "リンクの向きは分かっていないため、東西に置き、北を上にしています。", stadium: "{stadium}の建物の輪郭（OpenStreetMap、(c) OpenStreetMap contributors）の内側に、{seats}席・{tiers}層のスタンドを推定して描いています。スタジアムの設計図ではありません。", stadiumOpening: "フィールドは屋根の開口部（フィールドと同じ大きさ）に沿って置いており、矢印は北を指します。", stadiumBuilding: "フィールドは建物の長い軸に沿って置いており（推定）、矢印は北を指します。", stadiumNone: "フィールドの向きは分かっていないため、東西に置き、北を上にしています。", stadiumPark: "{stadium}の建物の輪郭（OpenStreetMap、(c) OpenStreetMap contributors）の内側に、{seats}席のスタンドを推定して描いています。球場の設計図ではありません。", stadiumPitch: "フィールドの向きはOpenStreetMapに記録されたピッチのとおりで、矢印は北を指します。", stadiumInfield: "ホームプレートの向きは、OpenStreetMapに記録された内野と建物の輪郭から推定しており、矢印は北を指します。", district: "OpenStreetMapの建物の輪郭をもとに、{count}か所の実在の会場を実際の位置と向きのとおりに並べた配置図です。{mode}。", districtNeighbours: "建物のすぐ近くまで寄せて描いています", districtCity: "実際の距離を保ち、1km方眼と縮尺を添えています", districtCredit: "出典：", era: "ラインやマークは{season}シーズンのものです。", hammer: "{name}がハンマー（最後の1投）を持っています。", ends: "{name}のエンドごとの得点：{list}。", total: "合計", wonPens: "{name}がPK戦を{a}-{b}で制しました。", pens: "PK戦 {a}-{b}", on: "図の内容", sep: "、", stop: "。", colon: "：", gap: "" },
         budo: {
             sides: { north: "北", south: "南", east: "東", west: "西" },
             judo: "柔道の試合場。試合場内は{contest}m四方、幅{safety}mの安全地帯があり、{tatami}の畳を敷いています",

package/dist/turn.dom.d.ts

@@ -1,6 +1,7 @@
 import { type TurnPreset, type TurnView } from "./turn.camera.ts";
 import { type TurnModel, type TurnSettings } from "./turn.model.ts";
 import type { ScoreOptions, SurfaceOptions } from "./types.ts";
+import type { VenueSettings } from "./venue.ts";
 /** What `mountKyogijoTurn` gives back. `O` is what `update` takes: the options of a drawing, or (for `mountMultiTurn`) of a tournament layout. */
 export interface KyogijoTurn<O = SurfaceOptions | ScoreOptions> {
     /** `3d`, or `flat` where the browser cannot draw the 3D view (or there is nothing to turn): the flat drawing is shown and the rest of this does nothing. */
@@ -13,8 +14,13 @@ export interface KyogijoTurn<O = SurfaceOptions | ScoreOptions> {
     preset(name: TurnPreset): void;
     /** Back to the opening view. */
     reset(): void;
-    /** Draw again with new options (a score that moved, a look that changed), keeping the view. */
-    update(options: O): void;
+    /**
+     * Draw again with new options (a score that moved, a look that changed), keeping the view and the auto-turn: the view goes on turning. `change` alters what the venue's walls and roof stand on (the settings `venue` was
+     * mounted with, the parts given), so that a page can switch them on and off without mounting the view again.
+     */
+    update(options: O, change?: {
+        venue?: VenueSettings;
+    }): void;
     /** Whether the auto-turn is running. */
     readonly playing: boolean;
     /** Start the auto-turn, a slow turn of the whole view. It gives whether it is running (a surface that cannot turn gives `false`). Nothing turns by itself until this, the Play button or Space starts it, unless `autoPlay` asked. */

package/dist/turn.dom.js

@@ -40,6 +40,8 @@ export function mountKyogijoTurn(host, options, settings = {}) {
 export function mountTurn(host, options, settings, build) {
     const doc = host.ownerDocument;
     const win = doc.defaultView;
+    /** The venue's settings as they are now: the mounted ones, altered by `update`. */
+    let venue = settings.venue;
     let model = build(options, settings);
     /** What names the four viewpoints: the model's own table (a tournament layout has one), else the sport's. */
     const sport = () => model.presets ?? model.options.sport;
@@ -61,8 +63,10 @@ export function mountTurn(host, options, settings, build) {
             play: () => false,
             pause: () => undefined,
             togglePlay: () => false,
-            update: (next) => {
-                model = build(next, settings);
+            update: (next, change) => {
+                if (change?.venue !== undefined)
+                    venue = { ...(typeof venue === "object" ? venue : {}), ...change.venue };
+                model = build(next, { ...settings, id: settings.id ?? model.id, venue });
                 flat(next);
             },
             svg: () => (alive ? host.querySelector("svg.kyogijo") : null),
@@ -436,10 +440,12 @@ export function mountTurn(host, options, settings, build) {
         },
         preset: toPreset,
         reset: toOpening,
-        update(next) {
+        update(next, change) {
             if (!alive)
                 return;
-            model = build(next, { ...settings, preset: undefined, view });
+            if (change?.venue !== undefined)
+                venue = { ...(typeof venue === "object" ? venue : {}), ...change.venue };
+            model = build(next, { ...settings, id: settings.id ?? model.id, venue, preset: undefined, view });
             view = clampView(view);
             opening = openingView(settings, sport());
             const layout = layoutOf(model, shown, stage.clientWidth || 960, stage.clientHeight || 600, settings.lens);

package/dist/venue.d.ts

@@ -8,6 +8,8 @@ export interface VenueSettings {
     roof?: boolean;
     /** A retractable roof (a real venue's: BC Place's) drawn open, the fabric gathered into its pod, instead of closed over the opening. Closed by default. */
     roofOpen?: boolean;
+    /** The walls of a real venue's building (`crowd: { real: true }`), raised on its outline: they follow `roof` where left out (a roof and walls together, as before), and `walls: true` with `roof` off raises the walls alone, `roof: true` with `walls: false` the roof alone. */
+    walls?: boolean;
     /** How finely the curves are cut: `low` a facet to each corner, `auto` (the default) three, `high` six; an oval is 12, 28 or 56 facets round. */
     detail?: Cut;
 }

package/dist/venue.js

@@ -116,16 +116,16 @@ export function standsVenueOf(stands, crowd, o, v, lift) {
         }
         // The low wall under the first row of a tier the walks do not lead to (a ballpark's wall seats stand on the fence, which the fence's own planes make).
         if (ring.tier !== "wall" && !chained.has(ring) && ring.height[0] > 0.5) {
-            for (const strip of strips) {
+            strips.forEach((strip, si) => {
                 for (let i = 0; i + 1 < strip.inner.length; i += 1) {
                     const [a, b] = [strip.inner[i], strip.inner[i + 1]];
                     if (Math.hypot(b[0] - a[0], b[1] - a[1]) < 0.5 || inCover([(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]))
                         continue;
                     const h = lift + ring.height[0];
-                    const w = wall(`${ring.id}-front-${i}`, "fascia", a[0], a[1], b[0], b[1], 0, h, `<rect class="u-fascia" width="${n(Math.hypot(b[0] - a[0], b[1] - a[1]))}" height="${n(h)}"/>`);
+                    const w = wall(`${ring.id}-front-${si === 0 ? "" : `s${si}-`}${i}`, "fascia", a[0], a[1], b[0], b[1], 0, h, `<rect class="u-fascia" width="${n(Math.hypot(b[0] - a[0], b[1] - a[1]))}" height="${n(h)}"/>`);
                     seatPlanes.push(shy(w, centre));
                 }
-            }
+            });
         }
     }
     // The walks between the tiers: a plane from the outer edge of one tier up to the first row of the next.
@@ -150,8 +150,9 @@ export function standsVenueOf(stands, crowd, o, v, lift) {
     if (wallSeats.length > 0)
         items.push({ id: "wall-seats", kind: "wall-seats", at: centre, height: topOf(wallSeats), planes: wallSeats });
     // The roof: a canopy over the back of the top tier, or a lid over it in a hall. A real venue has its own: the walls of its building and a roof of its kind over them.
-    if (stands.real !== undefined && v.roof === true)
-        items.push(...realBuilding(stands.real, topRing(stands), centre, lift, ARC_STEPS[cut].oval * 2, v.roofOpen === true));
+    const [walls, roof] = [v.walls ?? v.roof === true, v.roof === true];
+    if (stands.real !== undefined && (walls || roof))
+        items.push(...realBuilding(stands.real, topRing(stands), centre, lift, ARC_STEPS[cut].oval * 2, v.roofOpen === true, { walls, roof }));
     const top = v.roof === true && crowd.roof && stands.real === undefined ? topRing(stands) : undefined;
     if (top !== undefined) {
         const lid = INDOOR.includes(String(o.sport));

package/dist/venue.real.d.ts

@@ -8,10 +8,15 @@ export declare function saddleAt(real: Pick<RealShell, "footprint">, [x, y]: Pt)
 /** The height of the roof over a point of the building's edge, above the surface, in feet. */
 export declare const roofAt: (real: RealShell, p: Pt) => number;
 /**
- * The walls and the roof of a real venue. The hall is the building's outline cut to the bowl's wall and a margin (`RealShell.hall`): its rim is where a ray from the middle meets the one or the other first, in `steps`
+ * The walls and the roof of a real venue (`parts` says which are made). The hall is the building's outline cut to the bowl's wall and a margin (`RealShell.hall`): its rim is where a ray from the middle meets the one or the other first, in `steps`
  * rays. A wall stands on each stretch of the rim, up to the roof's height over it; the roof is a band from the rim in to the inner edge of the top tier (the middle stays open, as the 3D view's roofs are).
  */
-export declare function realBuilding(real: RealShell, top: StandRing | undefined, centre: readonly [number, number], lift: number, steps: number, open?: boolean): Items;
+export declare function realBuilding(real: RealShell, top: StandRing | undefined, centre: readonly [number, number], lift: number, steps: number, open?: boolean, parts?: {
+    walls: boolean;
+    roof: boolean;
+}): Items;
+/** How far a canopy's low edge, the field's side of it, stands under its high edge: the OpenStreetMap roof's `roof:height` is the rise, and the canopy rises to the back of the stands (ours: the sources do not say which way it slopes). */
+export declare const CANOPY_NOTE = "low over the field, high over the back of the stands";
 /** The pod in the middle of a cable roof's opening, as a share of the opening's size, and how thick it is, in feet (ours: the article says the fabric gathers into a pod above the video board, not how large it is). */
 export declare const POD: {
     readonly share: 0.24;