@johnmorrisdotca/kyogijo-stadiums 0.58.0 → 0.59.0

package/CHANGELOG.md

@@ -7,6 +7,12 @@ All notable changes to this project are written here. The format follows
 
 ## [Unreleased]
 
+## [0.59.0] - 2026-11-03
+
+### Fixed
+
+- **The stands clear the whole floor, centred (KYOGIJO-STADIUMS-44)** ([the stands and the crowd](./docs/crowd.md#the-venues)): with `crowd`, the bowl's opening was laid out from the playing surface's box alone, so the floor drawn round it ran into the first rows: a court's run-off at the corners (volleyball, sepak takraw, netball), a table tennis area at its ends, a rink's boards, and an athletics track's sprint straight, jumps' runways and pits beyond the oval. The opening is now fitted to everything the surface draws round its playing area (its view with no margin, and an outline where the floor is not a rectangle: the track with its straight and runways, a rink's rounded boards), clear of it all round, corners included, by 2 feet; a floor bigger than the sport's distances (table tennis) gets an opening of its own shape. The bench side's extra room is shared by the two sides, so the opening is centred on the floor and the bowl in the drawing (a soccer ground's touchlines are 23.7 feet from the first row on both sides, where they were 19.7 and 27.7), and the margin holds the roof's shade. The tunnel, the camera platform and the media's desks stay in the seats, the media's desks no longer run round a small opening's corners, and the benches stand between the floor and the first row only where the gap holds them. An artistic swimming area with a crowd keeps the margin the stands need along its sides (it gave them four tenths of it). The flat drawing and the 3D view share the one layout (`crowdStands`), which now gives the `floor` it was fitted to. In 3D, a table tennis table's raised floor (the drawing lifted to the table's height, with the ground the stands stand on) was sorted by its middle with the stands and drawn over the far ones, so from Low corner or Broadcast the bowl looked cut open round a small tile: the bowl is now always drawn over a raised floor, and the faint near stands at a low viewpoint are the walls giving way to the eye, as before. New tests walk every sport with a crowd, at every size and orientation, light and dark: no part of the floor's outline within 2 feet of a seat, nothing of the stands on the floor, the opening centred on the floor and the bowl centred in the drawing and wholly inside it; and in 3D, at every viewpoint, zoom and box, the eye outside the whole scene, nothing near the eye's plane, and no plane of the bowl under the floor. Pictures of a court, a track, a rink, a ring and a table tennis area in their stands are in the docs.
+
 ## [0.58.0] - 2026-11-03
 
 ### Added

package/catalogue.json

@@ -3,7 +3,7 @@
  "generatedAt": "2026-11-03",
  "package": {
   "name": "@johnmorrisdotca/kyogijo-stadiums",
-  "version": "0.58.0"
+  "version": "0.59.0"
  },
  "address": "https://johnmorrisdotca.github.io/kyogijo-stadiums/catalogue.json",
  "site": "https://johnmorrisdotca.github.io/kyogijo-stadiums/",

package/dist/athletics/plan.d.ts

@@ -42,6 +42,8 @@ export interface AthleticsPlan {
     box: MBox;
     /** Everything drawn: the box and what lies beyond it (the jump strip, the runways' ends, the straight). */
     extent: MBox;
+    /** What `extent` holds as points (the oval and what lies beyond it): what a crowd's stands clear. */
+    outline?: [number, number][];
     areas: Area[];
     shapes: Shape[];
     digits: Digits[];

package/dist/athletics/plan.js

@@ -224,13 +224,28 @@ export function athleticsPlan(o) {
     const box = { x0: -S / 2 - Rout, y0: -Rout, x1: S / 2 + Rout, y1: Rout };
     let extent = grow(box, 1);
     const edgeStraight = R + straight.lanes * straight.lane;
+    // What lies beyond the oval: the sprint straight, the jumps' strip, the javelin's runways.
+    const beyond = [];
     if (!indoor)
-        extent = union([extent, { x0: straight.x0, y0: -Rout, x1: straight.x1, y1: edgeStraight }]);
+        beyond.push({ x0: straight.x0, y0: -Rout, x1: straight.x1, y1: edgeStraight });
     if (events.includes("long-jump") || events.includes("triple-jump"))
-        extent = union([extent, jumpStrip()]);
-    if (events.includes("javelin-throw"))
-        extent = union([extent, ...inf.facilities.filter((f) => f.event === "javelin-throw").map((f) => f.box)].map((b) => ({ x0: Math.max(b.x0, -S / 2 - Rout - 6), y0: b.y0, x1: Math.min(b.x1, S / 2 + Rout + 6), y1: b.y1 })));
+        beyond.push(jumpStrip());
+    extent = union([extent, ...beyond]);
+    if (events.includes("javelin-throw")) {
+        const runways = inf.facilities.filter((f) => f.event === "javelin-throw").map((f) => f.box);
+        const cut = (b) => ({ x0: Math.max(b.x0, -S / 2 - Rout - 6), y0: b.y0, x1: Math.min(b.x1, S / 2 + Rout + 6), y1: b.y1 });
+        extent = union([extent, ...runways].map(cut));
+        beyond.push(...runways.map(cut));
+    }
     extent = grow(extent, 0);
+    const rim = Rout + 1;
+    const outline = [];
+    for (let i = 0; i <= 32; i += 1) {
+        const a = -Math.PI / 2 + (Math.PI * i) / 32;
+        outline.push([S / 2 + rim * Math.cos(a), rim * Math.sin(a)], [-S / 2 - rim * Math.cos(a), rim * Math.sin(a)]);
+    }
+    for (const b of beyond)
+        outline.push([b.x0, b.y0], [b.x1, b.y0], [b.x1, b.y1], [b.x0, b.y1]);
     const plan = {
         sport: "athletics",
         league: league.id,
@@ -243,6 +258,7 @@ export function athleticsPlan(o) {
         infield,
         box,
         extent,
+        outline,
         areas: parts.areas,
         shapes: parts.shapes,
         digits: parts.digits,

package/dist/catalogue.data.js

@@ -3,7 +3,7 @@ export const CATALOGUE_DATA = {
     "generatedAt": "2026-11-03",
     "package": {
         "name": "@johnmorrisdotca/kyogijo-stadiums",
-        "version": "0.58.0"
+        "version": "0.59.0"
     },
     "address": "https://johnmorrisdotca.github.io/kyogijo-stadiums/catalogue.json",
     "site": "https://johnmorrisdotca.github.io/kyogijo-stadiums/",

package/dist/crowd.d.ts

@@ -70,6 +70,14 @@ export interface CrowdStands {
     stadium?: "purpose" | "nfl" | "cfl";
     /** The playing surface, in the wide frame. */
     box: Box;
+    /**
+     * The floor round the playing surface, where the surface draws more than its box (a court's run-off, a track's sprint straight, runways and pits): its bounding box and its outline as points, in the wide frame.
+     * The first row of seats clears all of it by `FLOOR_CLEAR`, and the opening is centred on its box. Missing for a real venue's stands and a ballpark's, which are laid out from their own data.
+     */
+    floor?: {
+        box: Box;
+        points: Pt[];
+    };
     rings: StandRing[];
     /** Boxes where the stands are left out (the open end of a horseshoe, the ends of two sides). */
     covers: [x0: number, y0: number, x1: number, y1: number][];
@@ -310,10 +318,20 @@ export interface LayoutInput {
     };
     /** A real venue's stands in place of the sport's usual tiers (see `venueBowl`). */
     real?: RealBowl;
+    /**
+     * Everything the surface draws round its playing area, in the wide frame: the bounding box (the surface's own view with no margin) and, where the floor is not that rectangle (an athletics track, an oval
+     * ground), its outline as points. The opening of the stands is centred on it and clears it. Without it the floor is the box.
+     */
+    floor?: {
+        box: Box;
+        points?: readonly (readonly [number, number])[];
+    };
     /** The ballpark's fence as points on the field, for a ballpark (see `parkLayout`). */
     fence?: readonly Pt[];
     /** The foul lines' length at the poles and the backstop's distance, for a ballpark. */
     backstop?: number;
 }
+/** The room kept between the floor (everything the surface draws round its playing area) and the first row of seats, in feet. */
+export declare const FLOOR_CLEAR = 2;
 /** The layout of a sport's stands round its surface: rings, covers, sectors and gaps. For a ballpark see `parkLayout`. */
 export declare function layoutOf(input: LayoutInput): CrowdStands;

package/dist/crowd.js

@@ -330,6 +330,62 @@ function offsets(p, box, stadium) {
     const side = g.side + (f.width - box.h) / 2;
     return { left: end, right: end, top: side, bottom: side + g.bench };
 }
+/** The room kept between the floor (everything the surface draws round its playing area) and the first row of seats, in feet. */
+export const FLOOR_CLEAR = 2;
+/** A point inside a rounded rectangle or an ellipse of half sizes `hx`, `hy` about the origin, with `clear` to spare. */
+function insideOpening(ax, ay, hx, hy, r, oval, clear) {
+    const [w, h] = [hx - clear, hy - clear];
+    if (w <= 0 || h <= 0)
+        return false;
+    if (oval)
+        return sq(ax / w) + sq(ay / h) <= 1 + 1e-9;
+    const rr = Math.max(0, Math.min(r, hx, hy) - clear);
+    if (ax > w + 1e-9 || ay > h + 1e-9)
+        return false;
+    const kx = ax - (w - rr);
+    const ky = ay - (h - rr);
+    return kx <= 0 || ky <= 0 || sq(kx) + sq(ky) <= sq(rr) + 1e-9;
+}
+/** The first row's opening round a floor, centred on it (the bench room shared by both sides): the sport's distances, or the floor's own shape where they do not clear it, grown alike until its whole outline clears by `FLOOR_CLEAR`. */
+function openingOf(input) {
+    const { off, corner, oval, box } = input;
+    const floor = input.floor?.box ?? box;
+    const cx = floor.x + floor.w / 2;
+    const cy = floor.y + floor.h / 2;
+    let hx = Math.max(cx - box.x, box.x + box.w - cx) + (off.left + off.right) / 2;
+    let hy = Math.max(cy - box.y, box.y + box.h - cy) + (off.top + off.bottom) / 2;
+    // A floor the sport's distances do not clear (table tennis): the floor's own shape.
+    if (Math.min(hx - floor.w / 2, hy - floor.h / 2) < FLOOR_CLEAR) {
+        hx = floor.w / 2 + FLOOR_CLEAR;
+        hy = floor.h / 2 + FLOOR_CLEAR;
+    }
+    const given = input.floor?.points;
+    const points = given !== undefined && given.length > 0
+        ? given.map(([x, y]) => [x, y])
+        : oval
+            ? Array.from({ length: 64 }, (_, i) => [cx + (floor.w / 2) * Math.cos((i * Math.PI) / 32), cy + (floor.h / 2) * Math.sin((i * Math.PI) / 32)])
+            : [[floor.x, floor.y], [floor.x + floor.w, floor.y], [floor.x + floor.w, floor.y + floor.h], [floor.x, floor.y + floor.h]];
+    // A sampled curve: a little to spare.
+    const clear = FLOOR_CLEAR + (given !== undefined || oval ? 0.5 : 0);
+    const fits = (d) => points.every(([x, y]) => insideOpening(Math.abs(x - cx), Math.abs(y - cy), hx + d, hy + d, corner, oval, clear));
+    if (!fits(0)) {
+        let lo = 0;
+        let hi = 4;
+        while (!fits(hi) && hi < 4096)
+            hi *= 2;
+        for (let i = 0; i < 40; i += 1) {
+            const mid = (lo + hi) / 2;
+            if (fits(mid))
+                hi = mid;
+            else
+                lo = mid;
+        }
+        hx += hi;
+        hy += hi;
+    }
+    const round = (v) => Math.round(v * 1e6) / 1e6;
+    return { off: { left: round(box.x - (cx - hx)), right: round(cx + hx - box.x - box.w), top: round(box.y - (cy - hy)), bottom: round(cy + hy - box.y - box.h) }, cx, cy, floor, points };
+}
 /** The layout of a sport's stands round its surface: rings, covers, sectors and gaps. For a ballpark see `parkLayout`. */
 export function layoutOf(input) {
     const { sport, box } = input;
@@ -342,15 +398,16 @@ export function layoutOf(input) {
     const stadium = sport === "soccer" && input.real === undefined ? host ?? "purpose" : undefined;
     const p = stadium === "nfl" || stadium === "cfl" ? { ...PROFILES[stadium], shape: base.shape, away: base.away } : base;
     const shape = input.real !== undefined ? "bowl" : crowd.shape ?? p.shape;
-    const off = input.real?.off ?? offsets(base, box, stadium ?? "purpose");
-    const cx = box.x + box.w / 2;
-    const cy = box.y + box.h / 2;
+    const fit = input.real === undefined ? openingOf({ off: offsets(base, box, stadium ?? "purpose"), corner: p.corner, oval: base.oval === true, box, floor: input.floor }) : undefined;
+    const off = input.real?.off ?? fit?.off ?? offsets(base, box, stadium ?? "purpose");
+    const cx = fit?.cx ?? box.x + box.w / 2;
+    const cy = fit?.cy ?? box.y + box.h / 2;
     const rings = input.real === undefined ? [] : input.real.rings.map((ring) => ({ ...ring }));
     const reachOf = input.real === undefined ? { left: 0, right: 0, top: 0, bottom: 0 } : { ...input.real.reach };
     for (const t of input.real === undefined ? p.tiers : []) {
         const at = (k) => {
             if (base.oval === true)
-                return { kind: "ellipse", cx, cy, rx: box.w / 2 + (off.left + off.right) / 2 + k, ry: box.h / 2 + (off.top + off.bottom) / 2 + k };
+                return { kind: "ellipse", cx, cy, rx: (box.w + off.left + off.right) / 2 + k, ry: (box.h + off.top + off.bottom) / 2 + k };
             return { kind: "rrect", x0: box.x - off.left - k, y0: box.y - off.top - k, x1: box.x + box.w + off.right + k, y1: box.y + box.h + off.bottom + k, r: p.corner + k };
         };
         const region = at(t.to);
@@ -379,17 +436,18 @@ export function layoutOf(input) {
     const covers = [];
     const x0 = box.x - off.left;
     const x1 = box.x + box.w + off.right;
-    const yTop = last === undefined ? box.y : box.y - reachOf.top - 4;
-    const yBot = last === undefined ? box.y + box.h : box.y + box.h + reachOf.bottom + 4;
+    // The covers reach past the roof's shade (9 feet beyond the upper tier) too.
+    const yTop = last === undefined ? box.y : box.y - reachOf.top - 10;
+    const yBot = last === undefined ? box.y + box.h : box.y + box.h + reachOf.bottom + 10;
     if (shape === "horseshoe") {
         // The open end: everything beyond the surface's end line and the gap that is kept clear.
         if (crowd.open === "left")
-            covers.push([box.x - reachOf.left - 4, yTop, x0 + p.corner * 0.5, yBot]);
+            covers.push([box.x - reachOf.left - 10, yTop, x0 + p.corner * 0.5, yBot]);
         else
-            covers.push([x1 - p.corner * 0.5, yTop, box.x + box.w + reachOf.right + 4, yBot]);
+            covers.push([x1 - p.corner * 0.5, yTop, box.x + box.w + reachOf.right + 10, yBot]);
     }
     else if (shape === "sides") {
-        covers.push([box.x - reachOf.left - 4, yTop, x0 + p.corner * 0.5, yBot], [x1 - p.corner * 0.5, yTop, box.x + box.w + reachOf.right + 4, yBot]);
+        covers.push([box.x - reachOf.left - 10, yTop, x0 + p.corner * 0.5, yBot], [x1 - p.corner * 0.5, yTop, box.x + box.w + reachOf.right + 10, yBot]);
     }
     const concourses = [];
     rings.forEach((ring, i) => {
@@ -398,6 +456,8 @@ export function layoutOf(input) {
             concourses.push({ region: ring.hole, hole: before.region });
     });
     const stands = { sport, shape, box, rings, covers, concourses, sectors: [], gaps: [], reach: reachOf, seats: rings.reduce((n, r) => n + r.seats, 0) };
+    if (fit !== undefined)
+        stands.floor = { box: fit.floor, points: fit.points };
     if (input.real !== undefined)
         stands.real = input.real.shell;
     if (input.real?.closedSectors !== undefined)
@@ -490,21 +550,31 @@ export function layoutOf(input) {
             }
         }
         if (crowd.gaps && shape !== "grandstand") {
-            const bottom = box.y + box.h;
-            const mid = box.x + box.w / 2;
+            // Nothing on the floor: the benches stand between the floor and the first row.
+            const edge = box.y + box.h + off.bottom;
+            const floorEdge = Math.max(box.y + box.h, fit === undefined ? -Infinity : fit.floor.y + fit.floor.h);
+            const mid = cx;
             // A tunnel through the lower stands at the middle of the bench side, the camera platform above them, and the benches in the gap.
-            stands.gaps.push({ kind: "tunnel", box: [mid - 6, bottom + off.bottom - 1, mid + 6, bottom + off.bottom + lowerRing.to + 1] });
+            stands.gaps.push({ kind: "tunnel", box: [mid - 6, edge, mid + 6, edge + lowerRing.to + 1] });
             const media = rings[rings.length - 1];
             if (media !== undefined && media.tier === "upper")
-                stands.gaps.push({ kind: "camera", box: [mid - 22, bottom + off.bottom + media.from + 3, mid + 22, bottom + off.bottom + media.from + 13] });
-            if (off.bottom - off.top >= 4 || sport === "soccer" || sport === "nfl" || sport === "cfl" || sport === "ifaf" || sport === "rugby" || sport === "gaelic") {
+                stands.gaps.push({ kind: "camera", box: [mid - 22, edge + media.from + 3, mid + 22, edge + media.from + 13] });
+            if (base.bench >= 4 || sport === "soccer" || sport === "nfl" || sport === "cfl" || sport === "ifaf" || sport === "rugby" || sport === "gaelic") {
                 const benchLen = Math.min(34, box.w * 0.12);
-                for (const s of [-1, 1]) {
-                    const bx = mid + s * (box.w * 0.1 + benchLen / 2 + 4);
-                    stands.gaps.push({ kind: "bench", box: [bx - benchLen / 2, bottom + 2.5, bx + benchLen / 2, bottom + 2.5 + Math.min(5, off.bottom * 0.3)] });
+                const depth = Math.min(5, off.bottom * 0.3);
+                if (floorEdge + 2.5 + depth <= edge - 1) {
+                    for (const s of [-1, 1]) {
+                        const bx = box.x + box.w / 2 + s * (box.w * 0.1 + benchLen / 2 + 4);
+                        stands.gaps.push({ kind: "bench", box: [bx - benchLen / 2, floorEdge + 2.5, bx + benchLen / 2, floorEdge + 2.5 + depth] });
+                    }
                 }
             }
-            stands.gaps.push({ kind: "media", box: [mid - 55, bottom + off.bottom + 2, mid + 55, bottom + off.bottom + 6] });
+            // The media's desks: along the straight of that side only.
+            const hole = lowerRing.hole;
+            const straight = hole?.kind === "rrect" ? (hole.x1 - hole.x0) / 2 - Math.min(hole.r, (hole.x1 - hole.x0) / 2, (hole.y1 - hole.y0) / 2) : 55;
+            const half = Math.min(55, straight);
+            if (half >= 8)
+                stands.gaps.push({ kind: "media", box: [mid - half, edge + 2, mid + half, edge + 6] });
         }
     }
     return stands;

package/dist/draw.js

@@ -436,7 +436,7 @@ function realStadiumOf(o, sport, real) {
     return stadium !== undefined && stadium.configs[config] !== undefined && (stadiumKind(stadium) === "park") === (config === "mlb") ? { stadium, config } : undefined;
 }
 /** The stands round a surface, laid out from its box (or, for a ballpark, from its fence). */
-function standsFor(o, surface, crowd) {
+function standsFor(o, surface, crowd, floor) {
     const { sport } = chooseLeague(o);
     const awaySide = resolveHomeSide({ ...o, sport }) === "left" ? "right" : "left";
     if (sport === "mlb") {
@@ -469,7 +469,19 @@ function standsFor(o, surface, crowd) {
     // A dojo's crowd sits in its gallery, from the room's balcony data (in feet here); the arenas (the Budokan, the Kokugikan) keep their bowls.
     const hall = sport === "dojo" ? dojoGallery(o) : undefined;
     const gallery = hall === undefined ? undefined : { offset: hall.offset / 0.3048, depth: hall.depth / 0.3048, height: [hall.height[0] / 0.3048, hall.height[1] / 0.3048], rows: hall.rows, aisles: hall.aisles };
-    return crowdLayout({ sport, box, crowd, awaySide, ground: o.ground, arena: o.budo?.hall === "budokan", ...(gallery === undefined ? {} : { gallery }) });
+    return crowdLayout({ sport, box, crowd, awaySide, ground: o.ground, arena: o.budo?.hall === "budokan", ...(gallery === undefined ? {} : { gallery }), ...(floor === undefined ? {} : { floor }) });
+}
+/** A surface's floor with no margin (its view, and its outline where it has one); none for a close-up. */
+function floorOf(probe) {
+    if (probe.whole !== undefined)
+        return undefined;
+    const view = wideView(probe);
+    if (probe.floor === undefined)
+        return { box: view };
+    const xs = [view.x, view.x + view.w, ...probe.floor.map((p) => p[0])];
+    const ys = [view.y, view.y + view.h, ...probe.floor.map((p) => p[1])];
+    const [x0, y0] = [Math.min(...xs), Math.min(...ys)];
+    return { box: { x: x0, y: y0, w: Math.max(...xs) - x0, h: Math.max(...ys) - y0 }, points: probe.floor };
 }
 /** True when the drawing is asked to be small: `detail: "simple"` or a `width` under 480 pixels. */
 const smallDrawing = (o) => {
@@ -493,17 +505,20 @@ function venueFrame(o, crowd, surface) {
 /** A surface with the stands and the crowd round it: the ground is made as wide as the stands need, then the stands are laid on it under the surface. */
 function buildCrowded(o, portrait, id, score, scored, extra, crowd) {
     let margin = extra.margin;
+    // The floor the stands' opening clears and is centred on.
+    const probe = buildWhole({ ...o, margin: 0 }, portrait, id, score, scored, { ...extra, margin: undefined });
+    const floor = floorOf(probe);
     if (!(typeof o.margin === "number" && Number.isFinite(o.margin) && o.margin >= 0)) {
         // How much ground the stands need beyond what the surface has with none, then the surface is made again with it.
-        const probe = buildWhole({ ...o, margin: 0 }, portrait, id, score, scored, { ...extra, margin: undefined });
-        const stands = standsFor(o, probe, crowd);
+        const stands = standsFor(o, probe, crowd, floor);
         const view = wideView(probe);
         const have = { left: stands.box.x - view.x, right: view.x + view.w - stands.box.x - stands.box.w, top: stands.box.y - view.y, bottom: view.y + view.h - stands.box.y - stands.box.h };
         const need = Math.max(stands.reach.left - have.left, stands.reach.right - have.right, stands.reach.top - have.top, stands.reach.bottom - have.bottom);
-        margin = Math.max(margin ?? 0, need + 6);
+        // (and the roof's shade, 9 feet beyond the upper tier)
+        margin = Math.max(margin ?? 0, need + (crowd.roof ? 10 : 6));
     }
     const surface = buildWhole(o, portrait, id, score, scored, { ...extra, margin });
-    const stands = standsFor(o, surface, crowd);
+    const stands = standsFor(o, surface, crowd, floor);
     const seats = stands.seats;
     const ground = heldGround(o.ground)?.capacity;
     const fine = crowd.detail === "fine" || (crowd.detail === "auto" && !smallDrawing(o));
@@ -1220,5 +1235,5 @@ export function crowdStands(o) {
     if (crowd === undefined)
         return undefined;
     const probe = buildWhole({ ...o, margin: 0 }, false, drawingId(o), false, false, { features: undefined });
-    return standsFor(o, probe, crowd);
+    return standsFor(o, probe, crowd, floorOf(probe));
 }

package/dist/surfaces/artistic.js

@@ -59,7 +59,9 @@ export function artistic(o, plan, ctx = {}) {
     }
     const top = -jy + 0.4;
     const bottom = sy + start.depth + 0.4 - W;
-    const view0 = { x: -m, y: -feet(top) - m * 0.4, w: feet(L) + 2 * m, h: feet(W) + feet(top + bottom) + m * 0.8 };
+    // The deck is narrower along the sides than at the ends; a margin that is asked for (the ground the stands of a crowd stand on) is the same all round.
+    const across = o.margin === undefined ? m * 0.4 : m;
+    const view0 = { x: -m, y: -feet(top) - across, w: feet(L) + 2 * m, h: feet(W) + feet(top + bottom) + 2 * across };
     base = (ctx.bare === true ? "" : deckMarkup(o, ids, plan.deck, view0.x, view0.y, view0.w, view0.h)) + base + deck;
     const Lf = feet(L);
     const Wf = feet(W);

package/dist/surfaces/athletics.js

@@ -96,6 +96,8 @@ export function athleticsSurface(o, plan, embedded, margin) {
         onColour: false,
     };
     surface.box = { x: 0, y: 0, w: W, h: H };
+    if (plan.outline !== undefined && sv === undefined)
+        surface.floor = plan.outline.map(([x, y]) => [(x - ox) * K, (y - oy) * K]);
     surface.lineRef = { width: thick, feet: K };
     const ranges = {};
     for (const [name, r] of Object.entries(plan.ranges))

package/dist/surfaces/hockey.js

@@ -2,7 +2,7 @@ import { el, num } from "../format.js";
 import { rulesFor } from "../eras.js";
 import { NHL } from "../geometry.js";
 import { NHL_RINK } from "../leagues/hockey.js";
-import { atEnds, edges, ft, quarterTurn, roundedRect } from "./surface.js";
+import { atEnds, edges, ft, quarterTurn, roundedOutline, roundedRect } from "./surface.js";
 /** Where the boards' curve is at a distance x from the end: the y at which it meets a line across the rink. The corner's radius is the NHL's unless given. */
 export function boardsY(x, radius = NHL.cornerRadius) {
     const r = radius;
@@ -128,6 +128,8 @@ export function hockey(o, era, rink = NHL_RINK) {
     };
     surface.lineRef = { width: thin, feet: 1 };
     surface.box = { x: 0, y: 0, w: L, h: W };
+    // The floor the stands of a crowd clear: the boards round the rounded corners, not the apron's square corners.
+    surface.floor = roundedOutline(-bw, -bw, L + 2 * bw, W + 2 * bw, r + bw);
     surface.centreRadius = rink.circleRadius;
     surface.anchors = { kind: "hockey", length: L, width: W, blueLine, goalLine: g, cornerRadius: r, net: net_ };
     // The zones of the ice: from the end boards to a blue line, and between the blue lines.

package/dist/surfaces/surface.d.ts

@@ -153,6 +153,11 @@ export interface Surface {
         width: number;
         feet: number;
     };
+    /**
+     * For a surface whose floor is not the rectangle of its view (an athletics track, its sprint straight and runways): the outline of everything it draws round its playing area, as points in the wide frame
+     * in feet. The stands of a crowd clear it.
+     */
+    floor?: (readonly [number, number])[];
     /** For a surface with a crowd: the margin it was drawn with, which holds the stands. */
     crowdMargin?: number;
     /** A real stadium of more than one configuration laid out in the venue's own frame: where the middle of its field is in the surface's frame (the surface is shifted to lie there), and the ground, building, stands and crowd under it, in the venue's frame. */
@@ -254,6 +259,8 @@ export declare function quarterTurn(view: {
 };
 /** A box from its edges: the left, the top, the right and the bottom. */
 export declare const edges: (x0: number, y0: number, x1: number, y1: number) => Box;
+/** A rounded rectangle's outline as points (each corner in 12 steps), for a surface's `floor`. */
+export declare function roundedOutline(x: number, y: number, w: number, h: number, r: number): [number, number][];
 /** A range that has an end: its box at the left end and at the right, made by a function of the end. */
 export declare const atEnds: (box: (end: "left" | "right") => Box) => {
     left: Box;

package/dist/surfaces/surface.js

@@ -45,5 +45,14 @@ export function quarterTurn(view) {
 }
 /** A box from its edges: the left, the top, the right and the bottom. */
 export const edges = (x0, y0, x1, y1) => ({ x: Math.min(x0, x1), y: Math.min(y0, y1), w: Math.abs(x1 - x0), h: Math.abs(y1 - y0) });
+/** A rounded rectangle's outline as points (each corner in 12 steps), for a surface's `floor`. */
+export function roundedOutline(x, y, w, h, r) {
+    const rr = Math.max(0, Math.min(r, w / 2, h / 2));
+    const out = [];
+    for (const [cx, cy, a0] of [[x + w - rr, y + rr, -90], [x + w - rr, y + h - rr, 0], [x + rr, y + h - rr, 90], [x + rr, y + rr, 180]])
+        for (let i = 0; i <= 12; i += 1)
+            out.push([cx + rr * Math.cos(((a0 + i * 7.5) * Math.PI) / 180), cy + rr * Math.sin(((a0 + i * 7.5) * Math.PI) / 180)]);
+    return out;
+}
 /** A range that has an end: its box at the left end and at the right, made by a function of the end. */
 export const atEnds = (box) => ({ left: box("left"), right: box("right") });

package/dist/turn.markup.js

@@ -56,6 +56,8 @@ export function groupRanks(groups, yaw) {
     return rank;
 }
 const RAD = Math.PI / 180;
+/** The things of a venue's bowl: they stand on the ground round the surface, never under a raised floor. */
+const BOWL = new Set(["stands", "wall-seats", "gallery", "roof", "ribbon-boards", "hung-board"]);
 const prepared = new WeakMap();
 function prepare(model) {
     const known = prepared.get(model.planes);
@@ -79,7 +81,8 @@ function prepare(model) {
         const zs = [p.o[2], p.o[2] + p.u[2], p.o[2] + p.v[2], p.o[2] + p.u[2] + p.v[2]];
         mid.push([(p.o[0] + (p.u[0] + p.v[0]) / 2 - centre[0]) * s, (p.o[1] + (p.u[1] + p.v[1]) / 2 - centre[1]) * s, (p.o[2] + (p.u[2] + p.v[2]) / 2) * s, Math.min(...zs) * s, Math.max(...zs) * s]);
     }
-    const made = { planes: model.planes, scale: s, centre, base, mid };
+    const ofBowl = new Set(model.uprights.items.filter((item) => BOWL.has(item.kind)).flatMap((item) => item.planes));
+    const made = { planes: model.planes, scale: s, centre, base, mid, bowl: model.planes.map((p) => ofBowl.has(p)) };
     prepared.set(model.planes, made);
     return made;
 }
@@ -159,6 +162,14 @@ export function layoutOf(model, view, width, height, lens, cull = false, raster
     order.length = 0;
     for (let i = 0, j = 0; i < own.length || j < apart.length;)
         order.push(j >= apart.length || (i < own.length && own[i].depth <= apart[j].depth) ? own[i++] : apart[j++]);
+    // A raised floor (a table's top) carries the ground the bowl stands on, so it is sorted by its middle among the surface's own things only: the parts of the bowl that are farther than its middle
+    // come after it, still in their own order, or the floor would be drawn over the far stands.
+    if (raised) {
+        const at = order.findIndex((one) => one.i === 0);
+        const far = order.slice(0, at).filter((one) => known.bowl[one.i - 1]);
+        if (far.length > 0)
+            order.splice(0, at + 1, ...order.slice(0, at).filter((one) => !known.bowl[one.i - 1]), order[at], ...far);
+    }
     const stack = new Array(count + 1).fill(0);
     stack[0] = 1;
     order.forEach((one, rank) => {

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.58.0";
+export declare const VERSION = "0.59.0";

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.58.0";
+export const VERSION = "0.59.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johnmorrisdotca/kyogijo-stadiums",
-  "version": "0.58.0",
+  "version": "0.59.0",
   "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",