@johnmorrisdotca/kyogijo-stadiums 0.57.0 → 0.59.0

package/CHANGELOG.md

@@ -7,6 +7,20 @@ 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
+
+- **Las Vegas: the Strip Circuit, T-Mobile Arena and the Strip's landmarks on one ground (KYOGIJO-STADIUMS-30)** ([districts](./docs/district.md#las-vegas-a-circuit-on-the-ground-and-the-strips-landmarks)): a district's `circuit` option lays a circuit on its ground with the venues, turned as it lies, its pit building and turns' numbers standing in 3D (`circuitPointIn` maps a point of the circuit's plan into the district's, for a race on it); a circuit alone is a district too. A new area of context, `LAS_VEGAS` (`las-vegas`, OpenStreetMap, ODbL), 1.9 km round the lap and the arena: the Strip's buildings and towers at their mapped heights, the streets and the water, and four landmarks by shapes of their own at published sizes, named in English and Japanese (`ContextArea.landmarks`, `landmarks.ts`): the Sphere a dome, the High Roller a wheel, the jets of the Fountains of Bellagio, and Caesars Palace's name over its tallest building. `areaKeysFor` and `loadAreasFor` take the circuit; the lean district reads the circuits with `loadCircuits()` (`CIRCUIT_INDEX` names them). Held to 2,100 planes in 3D (under Seattle's three venues) and 2,565 KB for the demo's page. The demo's district page has the preset "Las Vegas: the Strip Circuit, T-Mobile Arena and the Sphere".
+- **A race on the Strip (KYOGIJO-STADIUMS-30)** ([a race on the Strip](./docs/district.md#a-race-on-the-strip)): the circuits' race runs on a district's ground, its twenty made-up cars on the Strip Circuit among T-Mobile Arena, the hotels, the Sphere, the High Roller and the Fountains of Bellagio, flat or in 3D, with the race clock, the speeds, the slider and the timing board. `drawDistrictRace` draws a moment and `mountDistrictRace` plays it in a page (a feed's race too, as `settings.race`); the race's view in a page takes the scene it is drawn in (`mountRaceIn`, `RaceScene`), and the cars are put on the district's ground with `circuitPointIn`. The demo's district page has **Race** beside the view when a circuit is chosen, kept in the address, and the circuits page's link to the district takes the race along. The lean district reads the race with the circuits (`loadCircuits`).
+- Fixed: a 3D view in `auto` quality times its frames in the view's one shared animation frame: a district's view that turned or played a race while its quality was being chosen asked for two frames a frame.
+
 ## [0.57.0] - 2026-11-03
 
 ### Changed

package/NOTICE.md

@@ -52,6 +52,8 @@ picture or code of the sources is copied; each source is named here so that the
 | `walk`: the ground a crowd outside a district's venues may stand on and what stops it (`WALK_DATA`, `src/walk.data.ts`): paths and sidewalks, plazas, squares, parks and platforms, and carriageways, cycle tracks, railways, water and buildings, as lines with a width and as rings | OpenStreetMap, through the Overpass API: every way and relation of the highways, buildings, railways, water, squares, parks and platforms within 350 metres of the district's venues, read on 2026-10-22, with the raw answer kept in `data-sources/walk/2026-10-22/`; laid flat in metres, simplified to 30 centimetres and written in quarter-metres, by the rules of `scripts/walk-rules.mjs` (no name, id or tag is copied) | ODbL 1.0, (c) OpenStreetMap contributors (https://www.openstreetmap.org/copyright): a derived database, kept in its own file and offered under the ODbL; a crowd or a drawing made from it is a produced work and carries the credit (`VENUE_ATTRIBUTION`) |
 | `plateau`: the buildings round Tokyo Dome City (`TOKYO_DOME_CITY`, `src/plateau.data.ts`): each building's roof-edge outline simplified to 0.6 metres on a half-metre grid, its height and, for a pitched LOD2 roof, the rise of the roof | Project PLATEAU, the Ministry of Land, Infrastructure, Transport and Tourism's (MLIT) 3D city model of Bunkyo ward, 2025 edition (product specification 5.0, CityGML, https://www.geospatial.jp/ckan/dataset/plateau-13105-bunkyo-ku-2025), read on 2026-10-22: the buildings within 500 metres of the middle of the district, with the raw fields kept in `data-sources/plateau/2026-10-22/` (`pnpm plateau:fetch`, `pnpm plateau`) | PLATEAU Site Policy (https://www.mlit.go.jp/plateau/site-policy/), clause 3: free use, commercial use included, compatible with CC BY 4.0 and the Public Data License 1.0; the source is credited and the data says it was edited and not made by MLIT (`PLATEAU_ATTRIBUTION`: "Project PLATEAU, Ministry of Land, Infrastructure, Transport and Tourism (MLIT), https://www.mlit.go.jp/plateau/ (3D city model of Bunkyo ward, 2025 edition), simplified and edited by Kyogijo Stadiums; not made by MLIT"); the copyright of a ward's data belongs to its local government. Kept in its own file, apart from the OpenStreetMap data (ODbL) and the CC0 files |
 | `cityctx`: the surroundings of the venues of Seattle (`SEATTLE_SODO`, `SEATTLE_CENTER`, `SEATTLE_CITY`) and the land cover and trees round Vancouver's (`VANCOUVER_NATURE`), in `src/cityctx.data.ts`: buildings (outline, height, for a pitched roof its rise), streets, railways, sidewalks and paths as lines with a width, water, green and wood outlines, and single trees | OpenStreetMap, through the Overpass API: the buildings (with their `height` and `building:levels`), the highways and railways, the tree nodes and rows within the radius of each area, read on 2026-10-22, the raw answers kept in `data-sources/cityctx/2026-10-22/` (`pnpm cityctx:fetch`, `pnpm cityctx:vox`, `pnpm cityctx`); laid flat in metres, simplified and put on a grid of half a metre (two metres for Seattle's city view) | OpenStreetMap's data is ODbL 1.0 (https://opendatacommons.org/licenses/odbl/1-0/), credited "(c) OpenStreetMap contributors, ODbL 1.0, openstreetmap.org/copyright"; the file is a derived database kept in its own file, apart from the CC0 files and from PLATEAU's data |
+| `cityctx`: the surroundings of the Las Vegas Strip Circuit and T-Mobile Arena (`LAS_VEGAS`, `src/cityctx.las-vegas.data.ts`): the buildings and the tall parts of buildings that matter from far, the streets and railways, the water, and four landmarks' outlines (the Sphere way/976405284, the High Roller way/402543930, the Fountains of Bellagio relation/19511963, Caesars Palace way/495449303) | OpenStreetMap, through the Overpass API (every building and every part of a building with a `height` or `building:levels`, the highways, railways, water and parks, and the landmarks' elements), read on 2026-11-03 and kept in `data-sources/cityctx/2026-11-03/` (`pnpm cityctx:fetch`, `pnpm cityctx`) | ODbL 1.0, (c) OpenStreetMap contributors; a derived database kept apart from the CC0 files |
+| `cityctx`: the landmarks' names and sizes (`LAS_VEGAS.landmarks`) | Wikidata's labels in English and Japanese and its heights (P2048) of Q60749353 (Sphere), Q892103 (High Roller), Q2735117 (Fountains of Bellagio) and Q569978 (Caesars Palace); the widths and the fountains' height from the English Wikipedia articles "Sphere (venue)" (revision 1382276386), "High Roller (Ferris wheel)" (1344683153) and "Fountains of Bellagio" (1381701116), kept as evidence in `data-sources/cityctx/2026-11-03/landmarks-las-vegas.json`; two Japanese names are ours (`スフィア`, `ベラージオの噴水`) | Wikidata is CC0; the figures read from the articles are facts, in our own words (the articles are CC BY-SA 4.0) |
 | `cityctx`: the surroundings of New York's venues (`NYC_MIDTOWN`, `NYC_BRONX`, `NYC_FLUSHING`, `NYC_BROOKLYN`), of the Meadowlands (`MEADOWLANDS`), of Belmont Park (`BELMONT_PARK`) and of Montreal's (`MONTREAL_DOWNTOWN`, `MONTREAL_OLYMPIC`, `MONTREAL_CITY`), one file each (`src/cityctx.<area>.data.ts`): buildings, streets, railways, sidewalks and paths, water, green and wood outlines, and single trees | OpenStreetMap, through the Overpass API (the buildings with their `height` and `building:levels`, the highways, railways, water and parks, the tree nodes and rows), read on 2026-10-30 and kept in `data-sources/cityctx/2026-10-30/` (`pnpm cityctx:fetch`, `pnpm cityctx`); the water, wetland, park, grass and wood outlines are OpenStreetMap's as mapped (VoxCity is not used for these areas) | OpenStreetMap's data is ODbL 1.0, credited "(c) OpenStreetMap contributors, ODbL 1.0, openstreetmap.org/copyright"; each file is a derived database kept apart from the CC0 files and from PLATEAU's data |
 | `cityctx`: the heights of New York's buildings | The City of New York's Building Footprints (NYC Open Data, dataset 5zhs-2jue, Office of Technology and Innovation: the outline, the roof height above the ground in feet and the construction year of each building), read through the portal's API on 2026-10-30 and kept in `data-sources/cityctx/2026-10-30/nyc-footprints-*.json`; the roof height is used where a footprint matches an OpenStreetMap building, and a footprint OpenStreetMap lacks is a building of its own | A public data set of the City under its Open Data Law (Administrative Code 23-502: made available without registration, licence requirement or restriction on use, the City being able to ask a third party that publishes it to name its source and version and to say what it changed); the City gives no warranty of the data's accuracy (the credit says it): the credit names the data set, the date read and that it was edited |
 | `cityctx`: Vancouver's trees | The City of Vancouver's open data, "Public trees" (place and diameter), read through the portal's API on 2026-10-22 and kept in `data-sources/cityctx/2026-10-22/` | The Open Government Licence - Vancouver (https://opendata.vancouver.ca/pages/licence/): free to use, with the City credited, in each layer, in English and in Japanese |

package/README.md

@@ -254,7 +254,7 @@ console.log(svg.startsWith("<svg"), svg.includes("USA 3, Canada 2"));
 - **A catalogue of venues**: every venue drawn today, the ones being built and the ones wanted (every NBA, MLB, NFL, CFL and NHL venue of the season, world soccer, cricket, rugby, the Olympics, Formula One and more), with ids, names in English and Japanese and Wikidata items, as a [JSON file](https://johnmorrisdotca.github.io/kyogijo-stadiums/catalogue.json) and a typed entry. [The catalogue](./docs/catalogue.md).
 - **Real venues**: arenas and stadiums in the outline of their buildings, districts of several venues on one plan, the crowd in the stands and outside. [Ballparks](./docs/ballparks.md), [venues](./docs/venues.md), [districts](./docs/district.md).
 - **A 3D view** of any surface or venue that turns by mouse, touch or keys, with the roof and the walls to switch and a quality level for every device. [The 3D view](./docs/turn.md), [quality](./docs/quality.md).
-- **Circuits**: a famous race track as OpenStreetMap maps it, the Las Vegas Strip Circuit first, with its turns numbered and its pit building standing in 3D, and a simulated race on it: twenty made-up cars over a full race distance, with a race clock, a timing board and 1×, 10× and 60×. [Circuits](./docs/circuits.md#a-race).
+- **Circuits**: a famous race track as OpenStreetMap maps it, the Las Vegas Strip Circuit first, with its turns numbered and its pit building standing in 3D, and a simulated race on it: twenty made-up cars over a full race distance, with a race clock, a timing board and 1×, 10× and 60×; on a district's ground beside T-Mobile Arena among the Strip, with the Sphere, the High Roller and the Fountains of Bellagio, where the race runs too. [Circuits](./docs/circuits.md#a-race), [Las Vegas](./docs/district.md#las-vegas-a-circuit-on-the-ground-and-the-strips-landmarks), [a race on the Strip](./docs/district.md#a-race-on-the-strip).
 - **Bring your own race feed**: a race plays from a feed you choose, read by your own browser from an address, pasted or from a file, and followed while it is live: kyogijo's open race timeline or OpenF1-style lap rows, with our made-up sample feed first. [The race feed](./docs/race-feed.md), [Where to find a feed](./docs/where-to-find-a-feed.md).
 - **Tournaments**: several surfaces on one floor, who judges where, boards laid over a surface. [Layouts](./docs/multi.md), [judging](./docs/judging.md), [boards](./docs/boards.md).
 - **Data on a surface**: points, heat maps, shot and pass charts, team shapes and a replay, flat or in 3D with the players standing on the ice, in 48 providers' coordinate frames. [Layers](./docs/layers.md), [frames](./docs/frames.md), [replay](./docs/replay.md), [an example game](./docs/example-games.md).

package/catalogue.json

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

package/dist/areas.d.ts

@@ -9,6 +9,11 @@ export declare const CITYCTX_VENUES: Readonly<{
 export declare const CITYCTX_DETAIL: Readonly<Record<string, readonly string[]>>;
 /** The most patches of New York's surroundings a choice of venues takes: more than this many venues of the city are too far apart for patches of detail round each. */
 export declare const MOST_DETAIL_AREAS = 2;
+/** The venues and the circuits each area of a circuit's surroundings is drawn round: Las Vegas's (the Strip Circuit, T-Mobile Arena and the Strip between them, with the Sphere, the High Roller and the Fountains of Bellagio). */
+export declare const CIRCUIT_AREAS: Readonly<Record<string, {
+    venues: readonly string[];
+    circuits: readonly string[];
+}>>;
 /** The venues of Tokyo Dome City, round which Project PLATEAU's buildings are drawn (the Kodokan stands a little way off, inside the area). */
 export declare const TOKYO_VENUES: readonly string[];
 /** The key of every area there is data for, in the order a district draws them: each is one file. */
@@ -16,7 +21,7 @@ export declare const AREA_KEYS: readonly string[];
 /**
  * The keys of the areas that go with some venues, in the order to draw them: downtown Vancouver's buildings and streets and its water, green and trees for BC Place and Rogers Arena; Seattle's SoDo for Lumen Field and
  * T-Mobile Park, Seattle Center's for Climate Pledge Arena, and the city's own for a district that holds venues of both (they are three kilometres apart, so the detail of either would be a speck); Tokyo Dome City's for
- * Tokyo Dome, Korakuen Hall and the Kodokan, which take it before any other. A venue of none of these has no area.
+ * Tokyo Dome, Korakuen Hall and the Kodokan, which take it before any other; Las Vegas's for T-Mobile Arena and for the Las Vegas Strip Circuit (`circuit`, a district's circuit). A venue of none of these has no area.
  * @example
  * ```ts
  * import { areaKeysFor } from "@johnmorrisdotca/kyogijo-stadiums/areas";
@@ -24,7 +29,7 @@ export declare const AREA_KEYS: readonly string[];
  * // [ 'vancouver', 'vancouver-nature' ]
  * ```
  */
-export declare function areaKeysFor(venues: readonly string[]): string[];
+export declare function areaKeysFor(venues: readonly string[], circuit?: string): string[];
 /**
  * One area by its key (`AREA_KEYS`), read from its own file the first time and kept after: asking again gives the same promise. A key that is not an area rejects, naming the keys there are.
  * @example
@@ -47,4 +52,4 @@ export declare function loadArea(key: string): Promise<ContextArea>;
  * console.log(plan.context?.attribution.en.length);
  * ```
  */
-export declare function loadAreasFor(venues: readonly string[]): Promise<ContextArea[]>;
+export declare function loadAreasFor(venues: readonly string[], circuit?: string): Promise<ContextArea[]>;

package/dist/areas.js

@@ -17,10 +17,14 @@ export const CITYCTX_DETAIL = Object.freeze({
 });
 /** The most patches of New York's surroundings a choice of venues takes: more than this many venues of the city are too far apart for patches of detail round each. */
 export const MOST_DETAIL_AREAS = 2;
+/** The venues and the circuits each area of a circuit's surroundings is drawn round: Las Vegas's (the Strip Circuit, T-Mobile Arena and the Strip between them, with the Sphere, the High Roller and the Fountains of Bellagio). */
+export const CIRCUIT_AREAS = Object.freeze({
+    "las-vegas": { venues: ["t-mobile-arena"], circuits: ["las-vegas"] },
+});
 /** The venues of Tokyo Dome City, round which Project PLATEAU's buildings are drawn (the Kodokan stands a little way off, inside the area). */
 export const TOKYO_VENUES = Object.freeze(["tokyo-dome", "korakuen-hall", "kodokan"]);
 /** The key of every area there is data for, in the order a district draws them: each is one file. */
-export const AREA_KEYS = Object.freeze(["vancouver", "vancouver-nature", "seattle-sodo", "seattle-center", "seattle-city", "tokyo-dome-city", "nyc-midtown", "nyc-bronx", "nyc-flushing", "nyc-brooklyn", "meadowlands", "belmont-park", "montreal-downtown", "montreal-olympic", "montreal-city"]);
+export const AREA_KEYS = Object.freeze(["vancouver", "vancouver-nature", "seattle-sodo", "seattle-center", "seattle-city", "tokyo-dome-city", "nyc-midtown", "nyc-bronx", "nyc-flushing", "nyc-brooklyn", "meadowlands", "belmont-park", "montreal-downtown", "montreal-olympic", "montreal-city", "las-vegas"]);
 /** Each area's loader: the one `import()` of the one file that holds it. */
 const LOADERS = {
     "vancouver": async () => (await import("./osm.context.data.js")).VANCOUVER_CENTRE,
@@ -38,11 +42,12 @@ const LOADERS = {
     "montreal-downtown": async () => (await import("./cityctx.montreal-downtown.data.js")).MONTREAL_DOWNTOWN,
     "montreal-olympic": async () => (await import("./cityctx.montreal-olympic.data.js")).MONTREAL_OLYMPIC,
     "montreal-city": async () => (await import("./cityctx.montreal-city.data.js")).MONTREAL_CITY,
+    "las-vegas": async () => (await import("./cityctx.las-vegas.data.js")).LAS_VEGAS,
 };
 /**
  * The keys of the areas that go with some venues, in the order to draw them: downtown Vancouver's buildings and streets and its water, green and trees for BC Place and Rogers Arena; Seattle's SoDo for Lumen Field and
  * T-Mobile Park, Seattle Center's for Climate Pledge Arena, and the city's own for a district that holds venues of both (they are three kilometres apart, so the detail of either would be a speck); Tokyo Dome City's for
- * Tokyo Dome, Korakuen Hall and the Kodokan, which take it before any other. A venue of none of these has no area.
+ * Tokyo Dome, Korakuen Hall and the Kodokan, which take it before any other; Las Vegas's for T-Mobile Arena and for the Las Vegas Strip Circuit (`circuit`, a district's circuit). A venue of none of these has no area.
  * @example
  * ```ts
  * import { areaKeysFor } from "@johnmorrisdotca/kyogijo-stadiums/areas";
@@ -50,12 +55,16 @@ const LOADERS = {
  * // [ 'vancouver', 'vancouver-nature' ]
  * ```
  */
-export function areaKeysFor(venues) {
+export function areaKeysFor(venues, circuit) {
     const ids = new Set(venues.map((key) => key.split(":")[0]));
     const has = (list) => list.some((id) => ids.has(id));
     if (has(TOKYO_VENUES))
         return ["tokyo-dome-city"];
     const keys = [];
+    // A circuit's surroundings, for the circuit or a venue beside it (T-Mobile Arena, by the Las Vegas Strip Circuit).
+    for (const [key, round] of Object.entries(CIRCUIT_AREAS))
+        if (has(round.venues) || (circuit !== undefined && round.circuits.includes(circuit)))
+            keys.push(key);
     // Montreal's two venues stand six kilometres apart: together they take the city between them, each alone its own surroundings. New York's and New Jersey's venues are in different boroughs and states: each shown takes its own.
     const montreal = ["montreal-downtown", "montreal-olympic"].filter((key) => has(CITYCTX_DETAIL[key]));
     if (montreal.length === 2)
@@ -114,6 +123,6 @@ export function loadArea(key) {
  * console.log(plan.context?.attribution.en.length);
  * ```
  */
-export function loadAreasFor(venues) {
-    return Promise.all(areaKeysFor(venues).map(loadArea));
+export function loadAreasFor(venues, circuit) {
+    return Promise.all(areaKeysFor(venues, circuit).map(loadArea));
 }

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.57.0"
+        "version": "0.59.0"
     },
     "address": "https://johnmorrisdotca.github.io/kyogijo-stadiums/catalogue.json",
     "site": "https://johnmorrisdotca.github.io/kyogijo-stadiums/",

package/dist/circuits-entry.d.ts

@@ -3,7 +3,7 @@ export { CIRCUITS, CIRCUIT_ATTRIBUTION, CIRCUIT_IDS, circuitById, circuitPlan }
 export type { CircuitPlan, PlanTurn } from "./circuits.ts";
 export { circuitDrawing, circuitTable, circuitText, drawCircuit } from "./circuits.draw.ts";
 export type { CircuitDrawing } from "./circuits.draw.ts";
-export { CIRCUIT_MARKER, CIRCUIT_PLANES_MAX, CIRCUIT_PRESETS, buildCircuitTurn, circuitTurnMarkup, mountCircuitTurn } from "./circuits.turn.ts";
+export { CIRCUIT_MARKER, CIRCUIT_PLANES_MAX, CIRCUIT_PRESETS, buildCircuitTurn, circuitTurnMarkup, circuitUprights, mountCircuitTurn } from "./circuits.turn.ts";
 export { KYOGIJO_CIRCUIT_STYLE } from "./circuits.style.ts";
 export { CIRCUIT_WORDS } from "./circuits.words.ts";
 export type { CircuitWords } from "./circuits.words.ts";

package/dist/circuits-entry.js

@@ -3,7 +3,7 @@
 import "./strings.js";
 export { CIRCUITS, CIRCUIT_ATTRIBUTION, CIRCUIT_IDS, circuitById, circuitPlan } from "./circuits.js";
 export { circuitDrawing, circuitTable, circuitText, drawCircuit } from "./circuits.draw.js";
-export { CIRCUIT_MARKER, CIRCUIT_PLANES_MAX, CIRCUIT_PRESETS, buildCircuitTurn, circuitTurnMarkup, mountCircuitTurn } from "./circuits.turn.js";
+export { CIRCUIT_MARKER, CIRCUIT_PLANES_MAX, CIRCUIT_PRESETS, buildCircuitTurn, circuitTurnMarkup, circuitUprights, mountCircuitTurn } from "./circuits.turn.js";
 export { KYOGIJO_CIRCUIT_STYLE } from "./circuits.style.js";
 export { CIRCUIT_WORDS } from "./circuits.words.js";
 export { lineLength } from "./circuits.geo.js";

package/dist/circuits.draw.js

@@ -164,7 +164,8 @@ export function circuitDrawing(options) {
     const { title, description } = circuitText(plan, language);
     const r = 13 * k;
     const placed = badgesOf(plan, r, k);
-    let body = el("rect", { class: "ky-ci-ground", x: viewBox.x, y: viewBox.y, width: viewBox.w, height: viewBox.h });
+    const framed = options.frame !== false;
+    let body = framed ? el("rect", { class: "ky-ci-ground", x: viewBox.x, y: viewBox.y, width: viewBox.w, height: viewBox.h }) : "";
     body += el("path", { class: "ky-ci-area", d: path(plan.area, true), "stroke-width": num(1.2 * k) });
     if (plan.building !== undefined)
         body += el("path", { class: "ky-ci-building", d: path(plan.building.ring, true), "stroke-width": num(1.2 * k), "data-height": num(plan.building.height / FT) });
@@ -200,9 +201,11 @@ export function circuitDrawing(options) {
         body += el("text", { class: "ky-ci-name", x: viewBox.x + pad * 0.6, y: viewBox.y + 36 * k, "font-size": num(26 * k) }, esc(circuit.names[language]));
         body += el("text", { class: "ky-ci-facts", x: viewBox.x + pad * 0.6, y: viewBox.y + 60 * k, "font-size": num(16 * k) }, esc(fill(words.facts, { km: km(circuit.length.value, language), turns: circuit.corners.value })));
     }
-    body += northArrow([viewBox.x + viewBox.w - pad * 0.6 - 20 * k, viewBox.y + (label ? 44 * k : pad)], plan.north, 40 * k, words.northArrow);
-    body += scaleBar([viewBox.x + pad * 0.6, viewBox.y + viewBox.h - 14 * k], viewBox.w, k, words.metres);
-    body += el("text", { class: "ky-ci-credit", x: viewBox.x + viewBox.w - pad * 0.6, y: viewBox.y + viewBox.h - 14 * k, "font-size": num(11 * k), "text-anchor": "end" }, esc(CIRCUIT_ATTRIBUTION));
+    if (framed) {
+        body += northArrow([viewBox.x + viewBox.w - pad * 0.6 - 20 * k, viewBox.y + (label ? 44 * k : pad)], plan.north, 40 * k, words.northArrow);
+        body += scaleBar([viewBox.x + pad * 0.6, viewBox.y + viewBox.h - 14 * k], viewBox.w, k, words.metres);
+        body += el("text", { class: "ky-ci-credit", x: viewBox.x + viewBox.w - pad * 0.6, y: viewBox.y + viewBox.h - 14 * k, "font-size": num(11 * k), "text-anchor": "end" }, esc(CIRCUIT_ATTRIBUTION));
+    }
     const titleId = `${gid}-t`;
     const descId = `${gid}-d`;
     const css = options.css === "none" ? "" : `<style>${KYOGIJO_CIRCUIT_STYLE}</style>`;

package/dist/circuits.held.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/circuits.held.js

@@ -0,0 +1,13 @@
+// Every circuit, and the race on one, held for a district (`district.circuit.ts`): importing this fills the table a district reads a circuit from. The `district` entry imports it; the lean district reads it with `loadCircuits()`. A bundler keeps it for its
+// effect: package.json lists it in `sideEffects`.
+import { circuitDrawing } from "./circuits.draw.js";
+import { carRadius, carsMarkup } from "./circuits.race.draw.js";
+import { mountRaceIn } from "./circuits.race.dom.js";
+import { raceAt } from "./circuits.race.moment.js";
+import { simulateRace } from "./circuits.race.js";
+import { RACE_WORDS } from "./circuits.race.words.js";
+import { circuitOf, circuitPlan } from "./circuits.js";
+import { circuitUprights } from "./circuits.turn.js";
+import { CIRCUIT_WORDS } from "./circuits.words.js";
+import { holdCircuits } from "./district.circuit.js";
+holdCircuits({ circuitOf, circuitPlan, circuitDrawing, circuitUprights, words: CIRCUIT_WORDS, race: { simulateRace, raceAt, carsMarkup, carRadius, mountRaceIn, words: RACE_WORDS } });

package/dist/circuits.index.d.ts

@@ -0,0 +1,15 @@
+/** Every circuit's key and its names in English and Japanese (Wikidata's labels), in the order of `CIRCUITS`. */
+export declare const CIRCUIT_INDEX: Readonly<Record<string, {
+    en: string;
+    ja: string;
+}>>;
+/**
+ * Read the circuits for the lean district (`district-lean`), which carries none until it is asked: after this a district's `circuit` option can name any of them. The `district` entry has them already. Asking again gives the same promise.
+ * @example
+ * ```ts no-run
+ * import { loadCircuits, planDistrict } from "@johnmorrisdotca/kyogijo-stadiums/district-lean";
+ * await loadCircuits();
+ * planDistrict({ venues: [], circuit: "las-vegas" });
+ * ```
+ */
+export declare function loadCircuits(): Promise<void>;

package/dist/circuits.index.js

@@ -0,0 +1,28 @@
+// The circuits by key and name, without their data: what a page lists to choose from before it reads any circuit (the district's page lists them beside the venues), and `loadCircuits`, which reads them all for a lean district.
+// A test holds this list to `CIRCUITS`.
+/** Every circuit's key and its names in English and Japanese (Wikidata's labels), in the order of `CIRCUITS`. */
+export const CIRCUIT_INDEX = Object.freeze({
+    "las-vegas": { en: "Las Vegas Strip Circuit", ja: "ラスベガス・ストリップ・サーキット" },
+});
+let loading;
+/**
+ * Read the circuits for the lean district (`district-lean`), which carries none until it is asked: after this a district's `circuit` option can name any of them. The `district` entry has them already. Asking again gives the same promise.
+ * @example
+ * ```ts no-run
+ * import { loadCircuits, planDistrict } from "@johnmorrisdotca/kyogijo-stadiums/district-lean";
+ * await loadCircuits();
+ * planDistrict({ venues: [], circuit: "las-vegas" });
+ * ```
+ */
+export function loadCircuits() {
+    if (loading === undefined) {
+        const read = async () => {
+            await import("./circuits.held.js");
+        };
+        loading = read().catch((error) => {
+            loading = undefined;
+            throw error;
+        });
+    }
+    return loading;
+}

package/dist/circuits.race.dom.d.ts

@@ -1,8 +1,10 @@
 import { type RaceMoment } from "./circuits.race.moment.ts";
 import { type CircuitRace, type RaceOptions } from "./circuits.race.ts";
 import type { CircuitOptions } from "./circuits.types.ts";
+import type { Pt } from "./crowd.ts";
 import { type KyogijoTurn } from "./turn.dom.ts";
-import type { TurnSettings } from "./turn.model.ts";
+import type { TurnModel, TurnSettings } from "./turn.model.ts";
+import type { Language } from "./types.ts";
 /** The speeds the controls offer: real time, ten times and sixty times (a minute of the race a second). */
 export declare const RACE_SPEEDS: readonly number[];
 /** What a race's view is drawn from: the circuit's options and the race's. */
@@ -37,12 +39,26 @@ export interface RaceState {
     speed: number;
     motion: "smooth" | "step";
 }
-/** What `mountCircuitRace` gives back. */
-export interface KyogijoRace {
+/**
+ * Where a race is drawn: the circuit's own drawing and 3D view (`mountCircuitRace`), or another scene the circuit lies in, a district's ground among its venues (`mountDistrictRace`). The cars are placed in the circuit's own plan
+ * (`raceAt`); `point` says where such a point is in the scene.
+ */
+export interface RaceScene<O, V> {
+    /** The scene's flat drawing at a moment, its cars as the `.ky-ci-car` groups of `carMarkup`: the race given when it came from a feed, else the simulation the options make. */
+    flat(options: O, t: number, given: CircuitRace | undefined): string;
+    /** The options the 3D view is mounted and updated with. */
+    view(options: O): V;
+    /** The 3D view's model. */
+    build(options: V, settings: TurnSettings): TurnModel;
+    /** Where a point of the circuit's plan lies in the scene: the same point for the circuit's own drawing. */
+    point(options: O): (p: Pt) => Pt;
+}
+/** What `mountCircuitRace` gives back (and `mountDistrictRace`, with a district's options and 3D view). */
+export interface KyogijoRace<O = RaceViewOptions, V = CircuitOptions> {
     /** The race it plays. */
     readonly race: CircuitRace;
     /** The 3D view, when the race is on one. */
-    readonly turn: KyogijoTurn<CircuitOptions> | undefined;
+    readonly turn: KyogijoTurn<V> | undefined;
     state(): RaceState;
     /** The race at the clock's time: the standings, the lap, the fastest lap. */
     moment(): RaceMoment;
@@ -55,7 +71,7 @@ export interface KyogijoRace {
     nextLap(): void;
     setSpeed(speed: number): void;
     /** Draw again with new options (the language, the theme): the clock and the race stay where they are. A new circuit, seed, laps or cars is a new race: mount it again. */
-    update(options: RaceViewOptions): void;
+    update(options: O): void;
     /** Play another race in the same view (a feed that came in again while a race is followed): the clock stays where it is, held to the new race's end, and stays playing or paused. */
     replace(race: CircuitRace): void;
     destroy(): void;
@@ -71,3 +87,7 @@ export interface KyogijoRace {
  * ```
  */
 export declare function mountCircuitRace(host: HTMLElement, initial: RaceViewOptions, settings?: RaceViewSettings): KyogijoRace;
+/** A race in a page, drawn in a scene: what `mountCircuitRace` does on the circuit's own drawing, and `mountDistrictRace` on a district's ground. */
+export declare function mountRaceIn<O extends RaceOptions & {
+    language?: Language;
+}, V>(host: HTMLElement, initial: O, scene: RaceScene<O, V>, settings?: RaceViewSettings): KyogijoRace<O, V>;

package/dist/circuits.race.dom.js

@@ -11,6 +11,13 @@ import { fill } from "./strings.core.js";
 import { mountTurn } from "./turn.dom.js";
 /** The speeds the controls offer: real time, ten times and sixty times (a minute of the race a second). */
 export const RACE_SPEEDS = Object.freeze([1, 10, 60]);
+/** The circuit's own scene. */
+const CIRCUIT_SCENE = {
+    flat: (options, t, given) => raceDrawing({ ...options, t }, given).svg,
+    view: (options) => options,
+    build: buildCircuitTurn,
+    point: () => (p) => p,
+};
 const ICONS = { play: "M8 5v14l11-7z", pause: "M6 5h4v14H6zM14 5h4v14h-4z", next: "M6 5l8.5 7L6 19zM16 5h2v14h-2z" };
 const icon = (d) => `<svg viewBox="0 0 24 24" width="22" height="22" aria-hidden="true" focusable="false" fill="currentColor"><path d="${d}"/></svg>`;
 /** The plane of a car standing in a 3D view: a disc that faces the eye, its lower edge on the floor over its place. */
@@ -26,8 +33,13 @@ const carPlane = (id, x, y, d, svg) => ({ id: `car-${id}`, kind: "player", o: [x
  * ```
  */
 export function mountCircuitRace(host, initial, settings = {}) {
+    return mountRaceIn(host, initial, CIRCUIT_SCENE, settings);
+}
+/** A race in a page, drawn in a scene: what `mountCircuitRace` does on the circuit's own drawing, and `mountDistrictRace` on a district's ground. */
+export function mountRaceIn(host, initial, scene, settings = {}) {
     const doc = host.ownerDocument;
     let options = { ...initial };
+    let place = scene.point(options);
     let language = options.language === "ja" ? "ja" : "en";
     let race = settings.race ?? simulateRace(options);
     let fromFeed = settings.race !== undefined;
@@ -101,7 +113,7 @@ export function mountCircuitRace(host, initial, settings = {}) {
         }
     };
     const drawFlat = () => {
-        stage.innerHTML = raceDrawing({ ...options, t: state.t }, fromFeed ? race : undefined).svg;
+        stage.innerHTML = scene.flat(options, state.t, fromFeed ? race : undefined);
         bindFlat();
     };
     /** The model of the 3D view with a disc for each car at the clock's time. */
@@ -113,7 +125,8 @@ export function mountCircuitRace(host, initial, settings = {}) {
         planes.clear();
         for (const line of [...moment.standings].sort((a, b) => a.index - b.index)) {
             const svg = carMarkup({ ...line, at: [r, r] }, r * 0.9, language).replace(/ role="img"[^>]*?aria-label="[^"]*"/, "");
-            planes.set(line.car.id, carPlane(line.car.id, line.at[0], line.at[1], disc, svg));
+            const at = place(line.at);
+            planes.set(line.car.id, carPlane(line.car.id, at[0], at[1], disc, svg));
         }
         return { ...model, planes: [...model.planes, ...planes.values()] };
     };
@@ -130,7 +143,7 @@ export function mountCircuitRace(host, initial, settings = {}) {
         if (settings.view === "3d") {
             const holder = doc.createElement("div");
             stage.replaceChildren(holder);
-            turn = mountTurn(holder, options, settings.turn ?? {}, buildCircuitTurn, false, (lent) => {
+            turn = mountTurn(holder, scene.view(options), settings.turn ?? {}, scene.build, false, (lent) => {
                 inner = lent;
             });
             if (inner !== undefined) {
@@ -209,15 +222,16 @@ export function mountCircuitRace(host, initial, settings = {}) {
             const car = cars.get(line.car.id);
             if (car === undefined)
                 continue;
+            const p = place(line.at);
             if (inner !== undefined) {
                 const plane = planes.get(line.car.id);
-                if (plane !== undefined && (plane.o[0] !== line.at[0] - disc / 2 || plane.o[1] !== line.at[1])) {
-                    plane.o = [line.at[0] - disc / 2, line.at[1], disc];
+                if (plane !== undefined && (plane.o[0] !== p[0] - disc / 2 || plane.o[1] !== p[1])) {
+                    plane.o = [p[0] - disc / 2, p[1], disc];
                     moved = true;
                 }
             }
             else {
-                const at = `translate(${num(line.at[0])} ${num(line.at[1])})`;
+                const at = `translate(${num(p[0])} ${num(p[1])})`;
                 if (car.at !== at) {
                     car.at = at;
                     car.el?.setAttribute("transform", at);
@@ -375,8 +389,9 @@ export function mountCircuitRace(host, initial, settings = {}) {
         update(next) {
             options = { ...next, circuit: options.circuit, seed: options.seed, laps: options.laps, cars: options.cars };
             language = options.language === "ja" ? "ja" : "en";
+            place = scene.point(options);
             if (turn !== undefined)
-                turn.update(options);
+                turn.update(scene.view(options));
             else
                 drawFlat();
             buildBoard();

package/dist/circuits.race.draw.d.ts

@@ -55,5 +55,5 @@ export declare function drawRace(options: RaceDrawOptions): string;
  * ```
  */
 export declare function raceBoard(moment: RaceMoment, language?: Language): string;
-/** The rules of a race: the cars on the drawing, the clock, the controls and the board. Scoped to `.ky-race` and the drawing's cars, in the page's own colours. */
+/** The rules of a race: the cars on the drawing, the clock, the controls and the board. Scoped to `.ky-race` and the cars of a circuit's or a district's drawing, in the page's own colours. */
 export declare const RACE_STYLE: string;

package/dist/circuits.race.draw.js

@@ -123,11 +123,11 @@ export function raceBoard(moment, language = "en") {
     });
     return `<table class="ky-race-board"><caption>${esc(w.caption)}</caption>${head}<tbody>${rows.join("")}</tbody></table>`;
 }
-/** The rules of a race: the cars on the drawing, the clock, the controls and the board. Scoped to `.ky-race` and the drawing's cars, in the page's own colours. */
+/** The rules of a race: the cars on the drawing, the clock, the controls and the board. Scoped to `.ky-race` and the cars of a circuit's or a district's drawing, in the page's own colours. */
 export const RACE_STYLE = `
-.ky-circuit .ky-ci-car-dot,.ky-turn .ky-ci-car-dot{stroke:var(--ky-ci-ground,#fff)}
-.ky-circuit .ky-ci-car-n,.ky-turn .ky-ci-car-n{font-family:var(--ky-font,system-ui,sans-serif);font-weight:800;text-anchor:middle;font-variant-numeric:tabular-nums}
-.ky-circuit .ky-ci-car[data-status=out]{opacity:.45}
+.ky-circuit .ky-ci-car-dot,.ky-district .ky-ci-car-dot,.ky-turn .ky-ci-car-dot{stroke:var(--ky-ci-ground,#fff)}
+.ky-circuit .ky-ci-car-n,.ky-district .ky-ci-car-n,.ky-turn .ky-ci-car-n{font-family:var(--ky-font,system-ui,sans-serif);font-weight:800;text-anchor:middle;font-variant-numeric:tabular-nums}
+.ky-circuit .ky-ci-car[data-status=out],.ky-district .ky-ci-car[data-status=out]{opacity:.45}
 .ky-race{display:block;color:inherit}
 .ky-race .ky-race-bar{display:flex;flex-wrap:wrap;align-items:center;gap:.5rem;margin-top:.5rem}
 .ky-race .ky-race-bar button{box-sizing:border-box;min-width:44px;min-height:44px;margin:0;padding:0 .7rem;border:1px solid currentColor;border-radius:8px;background:transparent;color:inherit;font:inherit;font-weight:700;cursor:pointer}

package/dist/circuits.turn.d.ts

@@ -1,6 +1,8 @@
+import { type CircuitDrawing } from "./circuits.draw.ts";
 import type { CircuitOptions } from "./circuits.types.ts";
 import { type PresetTable } from "./turn.camera.ts";
 import { type KyogijoTurn } from "./turn.dom.ts";
+import { type Upright } from "./turn.kit.ts";
 import { type TurnModel, type TurnSettings } from "./turn.model.ts";
 /**
  * The four viewpoints of a circuit: straight down, the main camera high over the long side of the lap, the end-on view along it and the low corner. A lap is kilometres across and flat, so the eye is kept higher than
@@ -14,6 +16,12 @@ export declare const CIRCUIT_MARKER: Readonly<{
 }>;
 /** The most planes a circuit's 3D view may have: its markers (three planes each), its pit building and nothing else. A test holds every circuit to it. */
 export declare const CIRCUIT_PLANES_MAX = 120;
+/**
+ * What stands up on a circuit's floor, in its plan's frame (feet): the pit building at its mapped height and each turn's number on a post over its badge's place beside the bend, the marker turned to face the eye and leaning
+ * back to be read square on. `drawn` is the circuit's drawing (its badges are where the markers stand) and `thin` the width of a post. The 3D view of the circuit stands these, and a district with the circuit stands them where
+ * it puts the circuit.
+ */
+export declare function circuitUprights(drawn: CircuitDrawing, thin: number): Upright[];
 /**
  * A circuit as a 3D model: its drawing as the floor, the pit building standing on it at its mapped height, and a marker with each turn's number on a post over its bend. `settings.uprights: false` is the floor alone.
  * A `TurnModel` like any other: `turnMarkupOf` and `mountCircuitTurn` make a view of it.

package/dist/circuits.turn.js

@@ -23,6 +23,34 @@ export const CIRCUIT_PRESETS = { overhead: TURN_PRESETS.overhead, broadcast: { y
 export const CIRCUIT_MARKER = Object.freeze({ size: 30, post: 22 });
 /** The most planes a circuit's 3D view may have: its markers (three planes each), its pit building and nothing else. A test holds every circuit to it. */
 export const CIRCUIT_PLANES_MAX = 120;
+/**
+ * What stands up on a circuit's floor, in its plan's frame (feet): the pit building at its mapped height and each turn's number on a post over its badge's place beside the bend, the marker turned to face the eye and leaning
+ * back to be read square on. `drawn` is the circuit's drawing (its badges are where the markers stand) and `thin` the width of a post. The 3D view of the circuit stands these, and a district with the circuit stands them where
+ * it puts the circuit.
+ */
+export function circuitUprights(drawn, thin) {
+    const plan = drawn.plan;
+    const k = drawn.k;
+    const items = [];
+    if (plan.building !== undefined) {
+        const planes = blockPlanes(shellBlock("pit", plan.building.ring, plan.building.height, undefined), "pit-");
+        const [cx, cy] = plan.building.ring.reduce((s, p) => [s[0] + p[0] / plan.building.ring.length, s[1] + p[1] / plan.building.ring.length], [0, 0]);
+        items.push({ id: "pit-building", kind: "blocks", at: [cx, cy], height: plan.building.height, planes });
+    }
+    const size = CIRCUIT_MARKER.size * k;
+    const top = CIRCUIT_MARKER.post * k;
+    const marks = [];
+    for (const b of drawn.badges) {
+        const [x, y] = b.at;
+        const r = size / 2;
+        const svg = `<circle class="u-ci-badge" cx="${num(r)}" cy="${num(r)}" r="${num(r * 0.94)}" stroke-width="${num(r * 0.1)}"/><text class="u-ci-badge-n" x="${num(r)}" y="${num(r + r * 0.4)}" font-size="${num(r * (b.n >= 10 ? 1.05 : 1.25))}">${b.n}</text>`;
+        marks.push({ ...plane(`turn-${b.n}`, "sign", [x - r, y, top + size], [size, 0, 0], [0, 0, -size], svg), billboard: true, lean: true });
+        marks.push(...pole(`turn-${b.n}-post`, "pole", x, y, 0, top, thin, "u-pole"));
+    }
+    if (marks.length > 0)
+        items.push({ id: "turns", kind: "flags", at: [(plan.box.x0 + plan.box.x1) / 2, (plan.box.y0 + plan.box.y1) / 2], height: top + size, planes: marks });
+    return items;
+}
 /**
  * A circuit as a 3D model: its drawing as the floor, the pit building standing on it at its mapped height, and a marker with each turn's number on a post over its bend. `settings.uprights: false` is the floor alone.
  * A `TurnModel` like any other: `turnMarkupOf` and `mountCircuitTurn` make a view of it.
@@ -37,27 +65,7 @@ export function buildCircuitTurn(options, settings = {}) {
     const drawn = circuitDrawing({ ...options, id: `${id}-floor`, label: false, turns: !standUp });
     const plan = drawn.plan;
     const { x: vx, y: vy, w: vw, h: vh } = drawn.viewBox;
-    const k = drawn.k;
-    const items = [];
-    if (standUp && plan.building !== undefined) {
-        const planes = blockPlanes(shellBlock("pit", plan.building.ring, plan.building.height, undefined), "pit-");
-        const [cx, cy] = plan.building.ring.reduce((s, p) => [s[0] + p[0] / plan.building.ring.length, s[1] + p[1] / plan.building.ring.length], [0, 0]);
-        items.push({ id: "pit-building", kind: "blocks", at: [cx, cy], height: plan.building.height, planes });
-    }
-    if (standUp) {
-        // Each turn's number on a post, over the badge's place beside the bend; the marker turns to face the eye and leans back to be read square on, and lies flat seen from above.
-        const size = CIRCUIT_MARKER.size * k;
-        const top = CIRCUIT_MARKER.post * k;
-        const marks = [];
-        for (const b of drawn.badges) {
-            const [x, y] = b.at;
-            const r = size / 2;
-            const svg = `<circle class="u-ci-badge" cx="${num(r)}" cy="${num(r)}" r="${num(r * 0.94)}" stroke-width="${num(r * 0.1)}"/><text class="u-ci-badge-n" x="${num(r)}" y="${num(r + r * 0.4)}" font-size="${num(r * (b.n >= 10 ? 1.05 : 1.25))}">${b.n}</text>`;
-            marks.push({ ...plane(`turn-${b.n}`, "sign", [x - r, y, top + size], [size, 0, 0], [0, 0, -size], svg), billboard: true, lean: true });
-            marks.push(...pole(`turn-${b.n}-post`, "pole", x, y, 0, top, thinnest(vw, vh), "u-pole"));
-        }
-        items.push({ id: "turns", kind: "flags", at: [(plan.box.x0 + plan.box.x1) / 2, (plan.box.y0 + plan.box.y1) / 2], height: top + size, planes: marks });
-    }
+    const items = standUp ? circuitUprights(drawn, thinnest(vw, vh)) : [];
     const area = plan.box;
     const uprights = { items, lift: 0, thin: thinnest(vw, vh), area };
     const planes = planesOf(uprights);

package/dist/circuits.types.d.ts

@@ -112,6 +112,8 @@ export interface CircuitOptions {
     turns?: boolean;
     /** The arrows that show which way the lap runs: `true` (the default) or `false`. */
     arrows?: boolean;
+    /** `false` leaves out the drawing's frame (its ground, the north arrow, the scale bar and the credit): for a drawing laid inside another that has its own (a district). `true` when missing. */
+    frame?: boolean;
     /** The prefix of the ids inside the drawing, for a page with more than one; a hash of the options when missing. */
     id?: string;
     /** More classes on the root. */