@johnmorrisdotca/kyogijo-stadiums 0.40.2 → 0.43.0

package/CHANGELOG.md

@@ -7,6 +7,62 @@ All notable changes to this project are written here. The format follows
 
 ## [Unreleased]
 
+## [0.43.0] - 2026-10-22
+
+### Fixed
+
+- **A see-through building's walls now fade by the side the eye is on, at every turn and tilt** (`Plane.fadeSide`): the Kodokan's near walls gave way only when the eye was low, and at some angles and tilts a near wall was drawn opaque over the dojo. Every wall between the eye and the room is now clear, a wall on the far side stays whole behind it, and a test turns the view in steps of 15 degrees at six tilts and finds no wall over the dojo's floor that is not clear. The roof is clearer too.
+- **The district page's seven presets pushed the crowd bar off the first screen on a phone** (the new preset made the chips wrap into one more row): on a narrow screen the chips are 44 pixels high with a smaller gap, so that the bar and the plan stay in view.
+- **Auto-turn could not be kept stopped on the district, stadiums, venues and halls pages**: pressing the button to stop the turn worked, but the pointer coming back over the view turned it again by hover. A reader who has used the Auto-turn button (or the Space key) is left alone by the pointer for the rest of the page; the button toggles every time. A new test presses it on each page, with and without yaw, pitch and zoom in the address, by mouse, keyboard and tap.
+
+### Added
+
+- **The Kodokan in the Tokyo district** ([the district page](./docs/district.md#the-kodokan-the-great-dojo-in-the-air)): `"kodokan"` is a venue of a district. Its main dojo (the great dojo, on the 7th floor, 420 mats, four contest areas at once, a gallery of about 900 on the 8th) is drawn in the air on its real floor, 31.9 metres up, in Project PLATEAU's building (8 storeys, 43.1 metres, its real outline), with the package's judo dojo inside: the four areas, the gallery, the seat of honour. No source gives the floor's shape or the room's place in the building: the floor is a square of 420 jō and the room is put where it stands farthest from the walls (ours, and said). `building: "xray" | "solid" | "none"` draws the building with walls that give way to the eye as it looks in (the default), whole, or not at all. The building is the venue's own, so the surrounding `context` leaves its copy out. A district with the Kodokan carries PLATEAU's credit without any context. New in the Tokyo district of the demo: a Kodokan choice, a Kodokan building choice kept in the address (`building=solid`, `building=none`), and a preset "Tokyo Dome City and the Kodokan". A picture of the dojo in the docs.
+- A member of a district can stand on a floor above the ground (`DistrictMember.elevation`, in feet): its planes are lifted, its floor is drawn in the air as a plane of its own and the ground under it is left bare in 3D.
+- **Downtown Vancouver among its streets** ([the page](./docs/district.md#among-the-streets-of-downtown-vancouver)): `context: [VANCOUVER_CENTRE]` (new entry `@johnmorrisdotca/kyogijo-stadiums/osm`) draws the carriageways, viaducts, SkyTrain guideway, sidewalks and paths flat under BC Place and Rogers Arena, and the buildings round them flat and, for the biggest 130, standing in 3D, with the heights OpenStreetMap maps (else its levels, else 10 metres, ours). The district's `context` takes a `streets` layer beside the `buildings` one and a `landmark` height of its own. OpenStreetMap, ODbL 1.0, kept apart from the PLATEAU data of Tokyo; `pnpm osm-context` makes it from the raw answer the walkable mask is made from.
+- **BC Place's 36 masts**, each 47.5 metres over the rim and leaning out, two crossed strips to a mast (STRUCTURE magazine's count and height, cited; the lean is ours), and the walls in two bands, a podium, a ledge and glazing, for BC Place and Rogers Arena (ours).
+- **Rogers Arena's roof closed in the middle by a cap with a long skylight** along the rink (ours, from the brief).
+- **The gates of a venue** ([the page](./docs/gates.md)): `venueGates("bc-place")` gives eight gates, one of them Gate G on the south side (Wikipedia's), and `venueGates("rogers-arena")` four on the Pat Quinn Way side and at the north-west, each a point on the building's outline with the way it faces, a name in English and Japanese and how it is known (`documented` or `plausible`); `gates: true` on a district marks them on the plan and the 3D floor. The data the crowd's walk in and out will use for its queues.
+- **The district page** has Surrounding buildings and streets for Vancouver (on by default), Retractable roof open (3D, for BC Place and T-Mobile Park, kept in the address as `roofopen=1`) and Gates (`gates=1`).
+
+### Changed
+
+- **The demo's browser tests run in four shards in CI** (`demo (1/4)` to `demo (4/4)`, each building the demo and playing a quarter of the tests in the three projects), and a test that fails on the runner is played once more (`retries: 1` in CI only, the report saying "flaky" for one that passed the second time): the job took 45 to 95 minutes on one runner.
+
+## [0.42.1] - 2026-10-22
+
+Not published on its own; shipped in 0.43.0.
+
+### Fixed
+
+- The README no longer carries the grey "Renamed" box about the package's old name (the 0.4.0 entry below keeps the history).
+- **The demo's 3D views keep the camera when the choice changes** (the district, stadiums, venues and layouts pages): another venue or district, another stadium or configuration, another layout, the roof, or the flat view and back used to open the view afresh on its viewpoint, taking away the turn, tilt and zoom the reader had chosen and stopping the auto-turn. The view is now opened where the last one was (turn, tilt, zoom, and Play if it was turning) and only the frame it fits changes. A turn made by hand is in the address as `yaw`, `pitch` and `zoom` (under the home page's `f` prefix for its featured arena), and an address that names them opens on them; a viewpoint chosen from the list or the view's own buttons takes them out again and says itself. A box that is not the viewpoint (the boards, the labels, the language) no longer sends the view back to the viewpoint, and the district and stadiums pages now write `viewpoint=` for every viewpoint but their own default, overhead (a reload used to lose a chosen low corner).
+
+## [0.42.0] - 2026-10-22
+
+Not published on its own; shipped in 0.43.0.
+
+### Added
+
+- **A district among its buildings, from Project PLATEAU** ([the district page](./docs/district.md#among-its-buildings-project-plateau)): `drawDistrict`, `planDistrict` and `buildDistrictTurn` take `context: [TOKYO_DOME_CITY]` (new entry `@johnmorrisdotca/kyogijo-stadiums/plateau`), the 734 buildings within 500 metres of the middle of Tokyo Dome City from the Ministry of Land, Infrastructure, Transport and Tourism's 3D city model of Bunkyo ward (2025 edition). They lie flat on the floor in four tones by height, and the 130 biggest and tallest stand in the 3D view at their real heights, walls lit by the way they face and hip roofs where the model has them: Tokyo Dome Hotel at 155 metres, Bunkyo Civic Center at about 139. The frame takes in the streets round the venues (150 metres) and grows to any landmark of 100 metres or more within 400. A building that is a venue's own (the Dome's stands and roof) is left out; the building Korakuen Hall stands in is a ghost. The data is cut down at build time (`pnpm plateau:fetch` reads the ward's CityGML by range requests, `pnpm plateau` writes `src/plateau.data.ts`: 40 KB, 16 KB gzipped) and nothing is read at run time; the raw fields are in `data-sources/plateau/2026-10-22/`. A district that does not ask is drawn as before and carries none of it. The credit (PLATEAU's site policy: free, commercial use included, compatible with CC BY 4.0; credited, and said to be edited) is in each description in English and in Japanese and in `NOTICE.md`. The data file is one frame with separate layers (`ContextArea.layers`), so trees and land cover can be laid beside the buildings.
+- **A Surrounding buildings choice on the district page**, on for Tokyo Dome City (`context=0` in the address turns it off), and a 3D picture of the district among its buildings in the docs.
+- The three links John sent (jeantimex/tokyo, mkturkcan/valdrada and a Tokyo Tower model on Printables) in [the references](./docs/references.md), with what each may be used for.
+
+### Changed
+
+- A plane of the 3D view can belong to no building (`APART`): the view stacks such planes by depth among themselves and weaves them into the buildings' (which keep their building-by-building order), so a district's surrounding blocks need no group of their own.
+
+## [0.41.0] - 2026-10-22
+
+Not published on its own; shipped in 0.42.0.
+
+### Added
+
+- **The crowd outside the venue** ([the page](./docs/outside.md)): `outside: { level: 0 | 25 | 50 | 75 | 100 }` on a [district](./docs/district.md) puts that share of the venues' seats' worth of people on the sidewalks, plazas, parks, platforms and grounds round them, in 2D (`mountDistrict`, new) and in the 3D turn (`mountDistrictTurn`, whose view has `setOutside(level)` and `outsideCost()`), never on a carriageway, a railway, water or a building. The crowd is one ordered list, so a level is a prefix of it (nobody moves when the level does), each venue's share is exact to a person at every level and the same options give the same list (`outsideCrowd`, `outsideCount`). It is drawn with no element for a person: two typed arrays, one loop and one `putImageData` on one canvas, laid over the plan or on the 3D floor, where the floor's own matrix carries it round; a district seen whole shows density and a near view shows each person, and nothing is painted again when the view turns. Measured at 100 percent for BC Place and Rogers Arena together (73,371 people): a paint of 2 to 17 ms on a level change (the first about twice that), 0.3 ms more of the main thread a frame while the view turns, 60 frames a second with it as without, and 250 ms once for the mask and the crowd.
+- **The walkable mask of Vancouver** (BC Place and Rogers Arena, one mask shared): made from OpenStreetMap's own answer (Overpass, ODbL 1.0, kept raw in `data-sources/walk/2026-10-22/`, credited "(c) OpenStreetMap contributors") by `pnpm walk:fetch` and `pnpm walk` (`scripts/walk-rules.mjs` says what a person may stand on and what stops a crowd) into `src/walk.data.ts`, apart from the CC0 data. `src/outside.raw.test.js` holds all 73,371 people to the raw answer. Only Vancouver has a mask; every other venue comes in a later release, and so do the entrances and the walk in and out.
+- **A bar of the five levels** on the demo's [district page](https://johnmorrisdotca.github.io/kyogijo-stadiums/district.html?outside=50), over the plan and the 3D view, kept in the address (`outside=50`), in English and Japanese, with the number of people said in words.
+- `pnpm outside:cost` prints the cost of a crowd; `DistrictPlan.origin` is the point the plan's metres are measured from.
+
 ## [0.40.2] - 2026-10-21
 
 ### Fixed

package/NOTICE.md

@@ -47,6 +47,9 @@ picture or code of the sources is copied; each source is named here so that the
 | `venues`: each venue's seats for ice hockey, number of seating tiers and kind of roof (`VENUE_DATA`, `src/venues.data.ts`) | The item of Wikidata (the capacity P1083 and the sport it applies to P641) and the English Wikipedia article of each arena, at the revision cited below, in `data-sources/venues/2026-10-20/` as read; the facts are numbers and words of our own, with what was read in a few words | Wikidata's data is CC0; the facts read from the articles are facts, with the articles credited here (CC BY-SA 4.0) |
 | `stadiums`: the outline of each stadium's building, the roof OpenStreetMap maps over it (its heights, the opening in it or its canopies), the pitches or the infield, and how the field lies, worked out from the opening, the pitches or the infield and the outline (`STADIUM_OSM`, `src/stadiums.osm.data.ts`) | OpenStreetMap, through the Overpass API: the closed way tagged with the stadium's Wikidata item and the multipolygon of its roof (BC Place), or the way or relation of the building, the roof parts, the pitches, the infield or the grass of the field named in `scripts/stadiums.data.json` (Lumen Field, T-Mobile Park, Tokyo Dome, Korakuen Hall, Koshien Stadium), read on 2026-10-20, with the raw answers kept in `data-sources/stadiums/2026-10-20/`; the outline is simplified to a metre, and the way the field lies is worked out from the opening, the pitches or the infield (`smallestBox`, `src/venues.geo.ts`; a ballpark's way out to centre field is the one of four where its fence lies inside the outline, or the heading and home plate at which its published fence lies nearest the mapped grass of the field (Koshien Stadium), or, where nothing maps it, not known, and the heading is the one in which fence and stands fit the outline best (Tokyo Dome)) | 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 drawing made from it is a produced work and carries the credit (`VENUE_ATTRIBUTION`) |
 | `stadiums`: each stadium's seats for each configuration, number of seating bowls, kind of roof and the size of its opening (`STADIUM_DATA`, `src/stadiums.data.ts`) | The item of Wikidata (the capacity P1083, the coordinates P625 and the labels in English and Japanese that name a hall) and the English Wikipedia article of each stadium, at the revision cited below, and the Japanese article of the three stadiums of Japan, at the revision cited in [NOTICE.ja.md](./NOTICE.ja.md#実在のスタジアム), in `data-sources/stadiums/2026-10-20/` as read; the facts are numbers and words of our own, with what was read in a few words (and, for a fact leaning on a sentence, the phrase the archive must hold) | Wikidata's data is CC0; the facts read from the articles are facts, with the articles credited here (CC BY-SA 4.0) |
+| `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 |
+| `district`: the Kodokan (`KODOKAN`, `src/kodokan.ts`, `src/kodokan.data.ts`): its building's outline (simplified to 0.3 metres), height (43.1 metres) and storeys (8), and where the main dojo's room lies in it | The building is Project PLATEAU's, as the `plateau` row above (the same credit, `PLATEAU_ATTRIBUTION`; the building's id in the file is in `src/kodokan.data.ts`); OpenStreetMap's way 170598646 (8 levels) was read on 2026-10-22 as a check that it is the same building, and nothing of it is copied. The main dojo is on the 7th floor with 420 mats, four contests at once, a gallery of about 900 on the 8th, in a building of eight floors and a basement: the Kodokan's own page (facilities), English Wikipedia (the article as last edited on 2026-04-20) and the IJF's article "Kodokan: an institution, a legendary place and a training venue", read on 2026-10-22; facts, no text copied | PLATEAU's terms as above for the building; facts for the rest. The shape of the floor, the room's place in the building, the wood (none) and the height of the 7th floor are ours, and the pages say so |
 | `atlas`: the clubs that played in each park, ground and arena (`tenants`: the club, its Wikidata item, its league, the years) | The occupants (P466) and home venues (P115) Wikidata lists for each place, with the start (P580) and end (P582) times of each statement, and the clubs' labels in English and Japanese, sports (P641) and leagues (P118), read with the Wikidata API and query service by `scripts/fetch-tenants.mjs` into `scripts/tenants.wikidata.json`; and the `tenants` line of the infobox of each place's English Wikipedia article, at the revision that `source.wikipedia` names for each club (155 articles, read on 2026-10-13) | Facts. Wikidata's data is CC0 (https://creativecommons.org/publicdomain/zero/1.0/), and the articles are CC BY-SA 4.0 as above; the names of clubs and the years are facts, no text, table or image of an article is used. Which clubs are tenants, and the league each is filed under, are our reading, in docs/atlas.md ("Tenants") |
 | `parks`: the walls, quirks, backstop, warning track, dugouts and extra points of a ballpark (`walls`, `quirks`, `backstop_ft`, `track_ft`, `dugouts`, `labels`) | The infobox and the text of the same English article of each park, at the same revision as its fence (the Japanese article for the heights of the walls of the parks of Japan): the height of the wall along a stretch of the fence and the seasons it stood, the hill, overhang, poles, bullpens, ivy and basket the text describes with figures, the infobox's backstop distance, the warning track's width, the sides of the dugouts, and the further distances the text gives (Wrigley Field's wells, Sportsman's Park's and Milwaukee County Stadium's markers). The stretch each figure covers and the angle of each extra point are our reading of the article's words | Facts. The articles are CC BY-SA 4.0 (https://creativecommons.org/licenses/by-sa/4.0/); none of their text, tables or images is used |
 | `parks`: the coordinates of each ballpark (`lat`, `lon`) and the years it opened and closed (`opened`, `closed`) | The item's coordinate location (P625), its date of official opening or inception (P1619, P571) and of official closure or dissolution (P3999, P576), read with the Wikidata API by `scripts/fetch-park-coordinates.mjs` and checked by `scripts/check-parks.mjs` (ES CON Field's opening, 2023, is read from its article) | Wikidata's data is CC0 (https://creativecommons.org/publicdomain/zero/1.0/) |
@@ -463,6 +466,20 @@ BC Place, Lumen Field, T-Mobile Park, Tokyo Dome, Korakuen Hall and Koshien Stad
 | Korakuen Hall | Q4389857 | way/45977418 | Korakuen Hall, 1372211318 |
 | Koshien Stadium | Q959811 | relation/9845926 | Koshien Stadium, 1374217766 |
 
+## The context's and the gates' sources
+
+Downtown Vancouver's buildings and streets (`VANCOUVER_CENTRE`, `src/osm.context.data.ts`) are OpenStreetMap's, ODbL 1.0, (c) OpenStreetMap contributors, made by `pnpm osm-context` from the same raw answer as the walkable mask (`data-sources/walk/2026-10-22/osm-vancouver.json`): each building's outline simplified to 60 centimetres with the height OpenStreetMap maps (else its levels at 3.2 metres, else 10 metres, which is ours) and each street as a line with a width; no name, id or tag is copied. It is kept in its own file, apart from every CC0 and CC BY-SA file and from the PLATEAU data of Tokyo.
+
+BC Place's masts (`scripts/stadiums.data.json`, `roof.masts`: 36, 47.5 metres) are a fact read from STRUCTURE magazine's article on the roof (https://www.structuremag.org/article/bc-place-revitalization/, 2026-10-22); its words are not kept. The gates (`src/gates.ts`) are ours, placed on OpenStreetMap's outlines; the one fact is that BC Place has a Gate G on the south side, from the English Wikipedia article (revision 1372065649, CC BY-SA 4.0, our own words).
+
+## The walkable masks' sources
+
+The ground round the venues of a district, read on 2026-10-22 (`pnpm walk:fetch`; the file is `data-sources/walk/2026-10-22/osm-<district>.json`, as Overpass returned it, with the query and the time of OpenStreetMap's data) and made into `src/walk.data.ts` by `pnpm walk`. It is OpenStreetMap's, ODbL 1.0, (c) OpenStreetMap contributors, and lives in that file alone. Nothing of Wikidata or Wikipedia is in it.
+
+| District | Venues | Radius | OpenStreetMap data of |
+| --- | --- | --- | --- |
+| `vancouver` | BC Place, Rogers Arena | 350 metres | 2026-10-22T07:58:28Z |
+
 ## The World Cups' articles
 
 The grounds each World Cup used, and where its final was played, were read from the venue section of the tournament's English Wikipedia article at the revision named (32 tournaments), by the same address. FIFA's own pages are not used.

package/README.md

@@ -13,8 +13,6 @@ The surfaces of forty-three sports, from football and curling to the budō and t
 
 <p align="center"><a href="https://johnmorrisdotca.github.io/kyogijo-stadiums/"><strong>Open the demo →</strong></a> · <a href="https://johnmorrisdotca.github.io/kyogijo-stadiums/docs/">Documentation</a> · <a href="https://johnmorrisdotca.github.io/kyogijo-stadiums/docs/gallery.html">Gallery</a> · <a href="./docs/compare.md">How it compares</a> · <a href="https://johnmorrisdotca.github.io/kyogijo-stadiums/api.html">API reference</a></p>
 
-> **Renamed.** Previously `@johnmorrisdotca/kyogijo`; renamed in 0.4.0 to `@johnmorrisdotca/kyogijo-stadiums`. The product is still Kyogijo Stadiums (競技場); only the package and the repository names changed. See the [changelog](./CHANGELOG.md).
-
 <table align="center">
 <tr>
 <td align="center" valign="top">
@@ -163,7 +161,7 @@ console.log(svg.startsWith("<svg"), svg.includes("USA 3, Canada 2"));
 | `./geometry`, `./frames`, `./layers`, `./charts`, `./replay` | The dimensions in any unit; the providers' frames; data layers; charts; tracking data played on a surface. |
 | `./athletics`, `./budo`, `./skating` | The athletics stadium, the budō (areas, dohyō, kyūdōjō, the dojo builder `drawDojo`, the 82 kimarite) and the skating rinks: plans, races and charts. |
 | `./parks`, `./grounds`, `./arenas`, `./atlas`, `./eras`, `./leagues`, `./events` | The ballparks, grounds, arenas, every place, a season's markings, each league's rulebook, the special games. |
-| `./venues`, `./stadiums`, `./district` | Real arenas and stadiums in their buildings' outlines; districts of venues on one plan. |
+| `./venues`, `./stadiums`, `./district`, `./plateau` | Real arenas and stadiums in their buildings' outlines; districts on one plan, among PLATEAU's buildings. |
 | `./turn` | A surface as a 3D view that turns, with the net, basket, goal or posts standing on it. |
 | `./scene`, `./canvas`, `./d3`, `./plot`, `./geojson`, `./png` | The drawing as data, on a canvas, in d3, as an Observable Plot mark, as GeoJSON, as a PNG (the optional peer `@resvg/resvg-js`). |
 | `./multi`, `./judging`, `./layouts` | `drawMulti` (several surfaces for one event, [docs](./docs/multi.md), [demo](https://johnmorrisdotca.github.io/kyogijo-stadiums/halls.html)); `drawJudging` (who judges where, [docs](./docs/judging.md)); `drawGrid` (small multiples, backgrounds). |

package/dist/context.d.ts

@@ -0,0 +1,141 @@
+import { type LonLat } from "./venues.geo.ts";
+import { type Plane, type Upright } from "./turn.kit.ts";
+import type { Pt } from "./crowd.ts";
+/** One layer of an area's data: its rows, and where they came from and under what terms, since a layer has a source of its own (buildings from PLATEAU; trees and land cover from another). */
+export interface ContextLayer {
+    /** What it was made from: the dataset and its page. */
+    source: string;
+    /** The day the source was read. */
+    read: string;
+    licence: string;
+    /** The credit that goes with a drawing made from this layer, in English and in Japanese. */
+    attribution: {
+        en: string;
+        ja: string;
+    };
+    /** The layer's rows, each a list of whole numbers in grid steps of the area's frame (the row format is the layer's own, said at its name in `ContextArea.layers`). */
+    rows: readonly (readonly number[])[];
+}
+/**
+ * An area of context round a district: ONE coordinate frame (the origin, the grid step and the radius, in metres east and north of the origin) and separate layers laid in it. Today there is one layer, `buildings`; trees and land
+ * cover are added beside it later as layers of their own, each with its own source and licence, with no change to the frame or to the layers that are there. A layer a caller does not ask for or an area lacks is simply not drawn.
+ * The row of a `buildings` layer: the height and the rise of the roof (0 for a flat one) in grid steps, then the first point (east, north) and each step to the next, in grid steps from the origin.
+ */
+export interface ContextArea {
+    key: string;
+    name: {
+        en: string;
+        ja: string;
+    };
+    /** The middle of the area, `[longitude, latitude]`: the point the rows' coordinates are measured from. */
+    origin: readonly [number, number];
+    /** How far from the middle the data reaches, in metres. */
+    radius: number;
+    /** The step the coordinates and the heights are counted in, in metres (a half). */
+    grid: number;
+    /** A building this tall, in metres, is a landmark that the plan's frame grows to take in; `CONTEXT_LANDMARK` when missing. A city of many tall buildings (Vancouver's downtown) sets it above them, so that the frame stays round the venues. */
+    landmark?: number;
+    layers: {
+        buildings?: ContextLayer;
+        streets?: ContextLayer;
+        trees?: ContextLayer;
+        landCover?: ContextLayer;
+    };
+}
+/** One building as the district holds it: its outline in feet in the district's frame (x to the right, y down the page), its height and the rise of its roof in feet. */
+export interface ContextBlock {
+    /** A name for the building that is the same on every run: the area's key and its place in the area's list. */
+    id: string;
+    ring: Pt[];
+    /** The height of its top above the ground, in feet. */
+    height: number;
+    /** How far a pitched roof rises over its eaves, in feet: 0 for a flat roof. */
+    rise: number;
+    /** Its ground area, in square feet. */
+    area: number;
+    /** A venue stands in this building (Korakuen Hall's building, which would hide it): it is drawn as a ghost. */
+    ghost: boolean;
+    /** The middle a see-through building's walls give way from, in feet: the venue raised in it (the Kodokan's main dojo). Set only by `shellBlock`. */
+    xray?: Pt;
+    /** Whether the building lies wholly inside the plan's frame: only such a building stands up in the 3D view, one the frame cuts is a part of the floor. */
+    whole: boolean;
+}
+/** One street of the `streets` layer as the district holds it: its kind (0 a carriageway at street level, 1 a carriageway on a viaduct or a bridge, 2 a railway, 3 a sidewalk or a path), its width in feet and its line in feet in the district's frame. */
+export interface ContextStreet {
+    kind: 0 | 1 | 2 | 3;
+    width: number;
+    points: Pt[];
+}
+/** What a district's context is: the buildings kept, and how many were left out because they are a venue's own. */
+export interface ContextPlan {
+    blocks: ContextBlock[];
+    /** The streets, from a `streets` layer: drawn flat on the floor, under the buildings. */
+    streets?: ContextStreet[];
+    /** The buildings of the model that are a venue (the Dome's own parts), left out: the venue draws them. */
+    owned: number;
+    /** The credits of the areas used, in each language. */
+    attribution: {
+        en: string[];
+        ja: string[];
+    };
+}
+/** How many buildings are raised as blocks in the 3D view (the biggest and the tallest of those on the plan): the rest are the floor's own, flat. Every block is a few elements of the page. */
+export declare const CONTEXT_BLOCKS = 130;
+/** Feet of the plan's frame beyond the venues' buildings that a district with context shows, so that the streets round them are in it: 150 metres. */
+export declare const CONTEXT_REACH: number;
+/** A building this tall, in metres, is a landmark: the plan's frame grows to take it in when it stands within `CONTEXT_LANDMARK_REACH` metres of the venues' buildings (Tokyo Dome Hotel, 155 metres, 370 metres from Korakuen Hall). */
+export declare const CONTEXT_LANDMARK = 100;
+export declare const CONTEXT_LANDMARK_REACH = 400;
+/** The heights, in metres, that divide the buildings into four tones: low, middle, high and tall. */
+export declare const CONTEXT_TONES: readonly number[];
+/** A building of an area, decoded: its outline in metres east and north of the area's origin, its height and the rise of its roof in metres. */
+export declare function decodeBuilding(area: Pick<ContextArea, "grid">, row: readonly number[]): {
+    ring: Pt[];
+    height: number;
+    rise: number;
+};
+/** A street of a `streets` layer, decoded: its line in metres east and north of the area's origin. The row is the kind, the width in grid steps, then the first point and each step to the next in grid steps. */
+export declare function decodeStreet(area: Pick<ContextArea, "grid">, row: readonly number[]): Pt[];
+/**
+ * The box a district with context is framed to, in feet in the district's frame: the venues' box widened by `CONTEXT_REACH` on every side, and grown to take in every landmark (a building of `CONTEXT_LANDMARK` metres or more) that stands within
+ * `CONTEXT_LANDMARK_REACH` metres of the venues' box, with a margin of its own. `box` is the venues' own.
+ */
+export declare function contextFrame(areas: readonly ContextArea[], origin: LonLat, turn: number, box: {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}): {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+/** A venue as the context needs it: its building's outline in the district's frame. */
+export interface ContextVenue {
+    footprint: readonly Pt[];
+    /** The footprint is a building the venue draws itself (the Kodokan's, with its dojo in the air in it): the building of the model that is the same is the venue's, left out. */
+    shell?: boolean;
+}
+/**
+ * The buildings of some areas placed in a district: turned as the plan is, kept where they stand in the frame, and sorted into the venues' own (a building most of which lies inside a venue's outline is the venue's: it is left out, the
+ * venue draws it) and the ghosts (a building that holds a venue inside it). `origin` is the district's own origin (`[longitude, latitude]`), `turn` the degrees the map is turned, `frame` the plan's box in feet.
+ */
+export declare function placeContext(areas: readonly ContextArea[], origin: LonLat, turn: number, frame: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}, venues: readonly ContextVenue[]): ContextPlan;
+/** The tone (0 low to 3 tall) of a building of `feet` height. */
+export declare const toneOf: (feet: number) => number;
+/** The streets flat on the floor, under the buildings: a path for each kind and width (a foot), widest and lowest kinds first, so that a sidewalk lies over the carriageway beside it and a viaduct's deck over the street under it. */
+export declare function streetsFloor(streets: readonly ContextStreet[]): string;
+/** The buildings flat on the floor of a district: one path for each tone, and one for the ghosts, drawn under the venues. Empty for a district with no context. */
+export declare function contextFloor(plan: ContextPlan): string;
+/** One building as the planes of a block: its walls up to the eaves, and over them a flat roof, or a hip roof where it has a pitched one. A ghost's planes are always mostly cut away, so that a venue inside it shows. */
+export declare function blockPlanes(b: ContextBlock, prefix: string): Plane[];
+/** The blocks of the 3D view: the `most` buildings that matter most (the tallest and widest, by height times the side of their ground), each a few planes, in the order the plan lists them. */
+export declare function contextUprights(plan: ContextPlan, most?: number): Upright[];
+/** The building a raised venue stands in as a block: its outline in feet, its height, `xray` the middle its walls give way from (or none for a solid one). */
+export declare function shellBlock(key: string, ring: readonly Pt[], height: number, xray: Pt | undefined): ContextBlock;

package/dist/context.js

@@ -0,0 +1,290 @@
+// The buildings round a district, drawn low in detail so that a district stands in its streets and not on a bare grid: each is the outline of its roof edge, a height and, for some, a pitched roof, cut down at build time from
+// Project PLATEAU's 3D city model (`scripts/build-plateau.mjs`, `plateau.data.ts`). Nothing here reads a tile or makes a request: an area is plain data a caller passes in (`context: [TOKYO_DOME_CITY]`), so a page that does not
+// ask for one carries none. This file places an area's buildings in a district's frame, takes out the ones that are a venue's own (a venue is drawn from its own outline and shell), and draws the rest: flat on the district's
+// floor, shaded by height, and the biggest and tallest as blocks standing on it in the 3D view. Pure: data in, markup and planes out.
+import { FEET_PER_METRE } from "./geometry.js";
+import { boxOf, hullOf, inside, metresFrom } from "./venues.geo.js";
+import { n, shy, wall } from "./turn.kit.js";
+import { pointList, raked } from "./venue.geom.js";
+/** How many buildings are raised as blocks in the 3D view (the biggest and the tallest of those on the plan): the rest are the floor's own, flat. Every block is a few elements of the page. */
+export const CONTEXT_BLOCKS = 130;
+/** Feet of the plan's frame beyond the venues' buildings that a district with context shows, so that the streets round them are in it: 150 metres. */
+export const CONTEXT_REACH = 150 * FEET_PER_METRE;
+/** A building this tall, in metres, is a landmark: the plan's frame grows to take it in when it stands within `CONTEXT_LANDMARK_REACH` metres of the venues' buildings (Tokyo Dome Hotel, 155 metres, 370 metres from Korakuen Hall). */
+export const CONTEXT_LANDMARK = 100;
+export const CONTEXT_LANDMARK_REACH = 400;
+/** The heights, in metres, that divide the buildings into four tones: low, middle, high and tall. */
+export const CONTEXT_TONES = [15, 45, 100];
+const RAD = Math.PI / 180;
+const rotate = ([x, y], degrees) => [x * Math.cos(degrees * RAD) - y * Math.sin(degrees * RAD), x * Math.sin(degrees * RAD) + y * Math.cos(degrees * RAD)];
+const centroid = (ring) => [ring.reduce((s, p) => s + p[0], 0) / ring.length, ring.reduce((s, p) => s + p[1], 0) / ring.length];
+/** The signed area of a ring: positive going clockwise on a page with y down. */
+const signedArea = (ring) => ring.reduce((s, [x, y], i) => s + (x * ring[(i + 1) % ring.length][1] - ring[(i + 1) % ring.length][0] * y), 0) / 2;
+/** A building of an area, decoded: its outline in metres east and north of the area's origin, its height and the rise of its roof in metres. */
+export function decodeBuilding(area, row) {
+    const g = area.grid;
+    const ring = [];
+    let [x, y] = [row[2], row[3]];
+    ring.push([x * g, y * g]);
+    for (let i = 4; i + 1 < row.length; i += 2) {
+        x += row[i];
+        y += row[i + 1];
+        ring.push([x * g, y * g]);
+    }
+    return { ring, height: row[0] * g, rise: row[1] * g };
+}
+/** A street of a `streets` layer, decoded: its line in metres east and north of the area's origin. The row is the kind, the width in grid steps, then the first point and each step to the next in grid steps. */
+export function decodeStreet(area, row) {
+    const g = area.grid;
+    const line = [];
+    let [x, y] = [row[2], row[3]];
+    line.push([x * g, y * g]);
+    for (let i = 4; i + 1 < row.length; i += 2) {
+        x += row[i];
+        y += row[i + 1];
+        line.push([x * g, y * g]);
+    }
+    return line;
+}
+/**
+ * The box a district with context is framed to, in feet in the district's frame: the venues' box widened by `CONTEXT_REACH` on every side, and grown to take in every landmark (a building of `CONTEXT_LANDMARK` metres or more) that stands within
+ * `CONTEXT_LANDMARK_REACH` metres of the venues' box, with a margin of its own. `box` is the venues' own.
+ */
+export function contextFrame(areas, origin, turn, box) {
+    let frame = { x0: box.x0 - CONTEXT_REACH, y0: box.y0 - CONTEXT_REACH, x1: box.x1 + CONTEXT_REACH, y1: box.y1 + CONTEXT_REACH };
+    const far = CONTEXT_LANDMARK_REACH * FEET_PER_METRE;
+    const near = { x0: box.x0 - far, y0: box.y0 - far, x1: box.x1 + far, y1: box.y1 + far };
+    for (const area of areas) {
+        const [east, north] = metresFrom(origin, [area.origin])[0];
+        for (const row of area.layers.buildings?.rows ?? []) {
+            if (row[0] * area.grid < (area.landmark ?? CONTEXT_LANDMARK))
+                continue;
+            const b = decodeBuilding(area, row);
+            const ring = b.ring.map(([e, nn]) => rotate([(e + east) * FEET_PER_METRE, -(nn + north) * FEET_PER_METRE], turn));
+            const at = boxOf(ring);
+            if (at.x1 < near.x0 || at.x0 > near.x1 || at.y1 < near.y0 || at.y0 > near.y1)
+                continue;
+            const m = 30 * FEET_PER_METRE;
+            frame = { x0: Math.min(frame.x0, at.x0 - m), y0: Math.min(frame.y0, at.y0 - m), x1: Math.max(frame.x1, at.x1 + m), y1: Math.max(frame.y1, at.y1 + m) };
+        }
+    }
+    return frame;
+}
+/**
+ * The buildings of some areas placed in a district: turned as the plan is, kept where they stand in the frame, and sorted into the venues' own (a building most of which lies inside a venue's outline is the venue's: it is left out, the
+ * venue draws it) and the ghosts (a building that holds a venue inside it). `origin` is the district's own origin (`[longitude, latitude]`), `turn` the degrees the map is turned, `frame` the plan's box in feet.
+ */
+export function placeContext(areas, origin, turn, frame, venues) {
+    const blocks = [];
+    let owned = 0;
+    const hulls = venues.map((v) => hullOf([...v.footprint]));
+    const [fx0, fy0, fx1, fy1] = [frame.x, frame.y, frame.x + frame.w, frame.y + frame.h];
+    for (const area of areas) {
+        const [east, north] = metresFrom(origin, [area.origin])[0];
+        (area.layers.buildings?.rows ?? []).forEach((row, index) => {
+            const b = decodeBuilding(area, row);
+            const ring = b.ring.map(([e, nn]) => rotate([(e + east) * FEET_PER_METRE, -(nn + north) * FEET_PER_METRE], turn));
+            const box = boxOf(ring);
+            // Wholly outside the frame: not drawn at all.
+            if (box.x1 < fx0 || box.x0 > fx1 || box.y1 < fy0 || box.y0 > fy1)
+                return;
+            const middle = centroid(ring);
+            const share = (poly) => ring.filter((p) => inside(poly, p)).length / ring.length;
+            // A venue inside the building (its middle and at least half of its outline's points): the building is a ghost round it.
+            const holds = venues.some((v) => v.shell !== true && inside(ring, centroid(v.footprint)) && v.footprint.filter((p) => inside(ring, p)).length * 2 >= v.footprint.length);
+            if (!holds && hulls.some((hull) => inside(hull, middle) || share(hull) >= 0.7)) {
+                owned += 1;
+                return;
+            }
+            blocks.push({ id: `${area.key}-${index}`, ring, height: b.height * FEET_PER_METRE, rise: b.rise * FEET_PER_METRE, area: Math.abs(signedArea(ring)), ghost: holds, whole: box.x0 >= fx0 && box.x1 <= fx1 && box.y0 >= fy0 && box.y1 <= fy1 });
+        });
+    }
+    // The streets of the areas: each a line with a width, kept where it reaches into the frame.
+    const streets = [];
+    for (const area of areas) {
+        const [east, north] = metresFrom(origin, [area.origin])[0];
+        for (const row of area.layers.streets?.rows ?? []) {
+            const points = decodeStreet(area, row).map(([e, nn]) => rotate([(e + east) * FEET_PER_METRE, -(nn + north) * FEET_PER_METRE], turn));
+            const box = boxOf(points);
+            if (box.x1 < fx0 || box.x0 > fx1 || box.y1 < fy0 || box.y0 > fy1)
+                continue;
+            streets.push({ kind: row[0], width: row[1] * area.grid * FEET_PER_METRE, points });
+        }
+    }
+    const layers = areas.flatMap((a) => Object.values(a.layers));
+    return { blocks, streets, owned, attribution: { en: [...new Set(layers.map((l) => l.attribution.en))], ja: [...new Set(layers.map((l) => l.attribution.ja))] } };
+}
+/** The tone (0 low to 3 tall) of a building of `feet` height. */
+export const toneOf = (feet) => CONTEXT_TONES.filter((m) => feet / FEET_PER_METRE >= m).length;
+const num = (value) => String(Math.round(value * 100) / 100);
+/** The streets flat on the floor, under the buildings: a path for each kind and width (a foot), widest and lowest kinds first, so that a sidewalk lies over the carriageway beside it and a viaduct's deck over the street under it. */
+export function streetsFloor(streets) {
+    if (streets.length === 0)
+        return "";
+    const groups = new Map();
+    for (const s of streets) {
+        const key = `${s.kind} ${Math.max(1, Math.round(s.width))}`;
+        const list = groups.get(key) ?? [];
+        list.push(`M${s.points.map(([x, y]) => `${num(x)} ${num(y)}`).join("L")}`);
+        groups.set(key, list);
+    }
+    // Under: street-level carriageways, then railways, then sidewalks and paths, then viaducts (which cross over the rest).
+    const order = [0, 2, 3, 1];
+    const keys = [...groups.keys()].sort((a, b) => order.indexOf(Number(a.split(" ")[0])) - order.indexOf(Number(b.split(" ")[0])) || Number(b.split(" ")[1]) - Number(a.split(" ")[1]));
+    return `<g class="ky-dist-streets" aria-hidden="true" fill="none">${keys.map((key) => `<path class="ky-dist-street ky-dist-street-${key.split(" ")[0]}" stroke-width="${key.split(" ")[1]}" d="${groups.get(key).join("")}"/>`).join("")}</g>`;
+}
+/** The buildings flat on the floor of a district: one path for each tone, and one for the ghosts, drawn under the venues. Empty for a district with no context. */
+export function contextFloor(plan) {
+    const roads = streetsFloor(plan.streets ?? []);
+    if (plan.blocks.length === 0)
+        return roads;
+    const paths = [[], [], [], [], []];
+    for (const b of plan.blocks)
+        paths[b.ghost ? 4 : toneOf(b.height)].push(`M${b.ring.map(([x, y]) => `${num(x)} ${num(y)}`).join("L")}Z`);
+    const classes = ["ky-dist-b0", "ky-dist-b1", "ky-dist-b2", "ky-dist-b3", "ky-dist-ghost"];
+    return `${roads}<g class="ky-dist-context" aria-hidden="true">${paths.map((d, i) => (d.length === 0 ? "" : `<path class="ky-dist-block ${classes[i]}" d="${d.join("")}"/>`)).join("")}</g>`;
+}
+// ---- The blocks of the 3D view. ----
+/** How much a building matters to the view: tall and wide first. */
+const weight = (b) => b.height * Math.sqrt(b.area);
+/** The principal axis of a ring, as a unit direction, and the extent of the ring along it and across it, from its middle. */
+function axisOf(ring) {
+    const [mx, my] = centroid(ring);
+    let [sxx, sxy, syy] = [0, 0, 0];
+    for (const [x, y] of ring) {
+        sxx += (x - mx) ** 2;
+        sxy += (x - mx) * (y - my);
+        syy += (y - my) ** 2;
+    }
+    const angle = 0.5 * Math.atan2(2 * sxy, sxx - syy);
+    const along = [Math.cos(angle), Math.sin(angle)];
+    const across = [-along[1], along[0]];
+    const ts = ring.map(([x, y]) => (x - mx) * along[0] + (y - my) * along[1]);
+    const ss = ring.map(([x, y]) => (x - mx) * across[0] + (y - my) * across[1]);
+    return { along, t0: Math.min(...ts), t1: Math.max(...ts), s0: Math.min(...ss), s1: Math.max(...ss) };
+}
+/** Whether a ring is convex (either way round). */
+const convex = (ring) => {
+    let sign = 0;
+    for (let i = 0; i < ring.length; i += 1) {
+        const [a, b, c] = [ring[i], ring[(i + 1) % ring.length], ring[(i + 2) % ring.length]];
+        const k = (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0]);
+        if (Math.abs(k) < 1e-9)
+            continue;
+        if (sign === 0)
+            sign = Math.sign(k);
+        else if (Math.sign(k) !== sign)
+            return false;
+    }
+    return true;
+};
+/** The plane a set of points with heights lies nearest to (least squares), as a slope. */
+function slopeThrough(points) {
+    const m = points.length;
+    const [mx, my, mz] = [points.reduce((s, p) => s + p[0], 0) / m, points.reduce((s, p) => s + p[1], 0) / m, points.reduce((s, p) => s + p[2], 0) / m];
+    let [sxx, sxy, syy, sxz, syz] = [0, 0, 0, 0, 0];
+    for (const [x, y, z] of points) {
+        sxx += (x - mx) ** 2;
+        sxy += (x - mx) * (y - my);
+        syy += (y - my) ** 2;
+        sxz += (x - mx) * (z - mz);
+        syz += (y - my) * (z - mz);
+    }
+    const det = sxx * syy - sxy * sxy;
+    const [gx, gy] = Math.abs(det) < 1e-9 ? [0, 0] : [(sxz * syy - syz * sxy) / det, (syz * sxx - sxz * sxy) / det];
+    return { x0: mx, y0: my, z0: mz, gx, gy };
+}
+/** The faces of a hip roof over a ring: from each edge of the ring (at the eaves) up to a ridge along the ring's long axis (at the top). A face is a quad or a triangle. */
+function hipFaces(ring, eave, top) {
+    const { along, t0, t1, s0, s1 } = axisOf(ring);
+    const [mx, my] = centroid(ring);
+    const across = [-along[1], along[0]];
+    const half = (s1 - s0) / 2;
+    const sm = (s0 + s1) / 2;
+    const tm = (t0 + t1) / 2;
+    // The ridge runs between t0 + half and t1 - half (a point at the middle where the ring is no longer than it is wide).
+    const [r0, r1] = t1 - t0 > 2 * half ? [t0 + half, t1 - half] : [tm, tm];
+    const at = (t) => [mx + along[0] * t + across[0] * sm, my + along[1] * t + across[1] * sm];
+    const nearest = (p) => at(Math.max(r0, Math.min(r1, (p[0] - mx) * along[0] + (p[1] - my) * along[1])));
+    const faces = [];
+    ring.forEach((a, i) => {
+        const b = ring[(i + 1) % ring.length];
+        const [ra, rb] = [nearest(a), nearest(b)];
+        const poly = [a, b];
+        const heights = [eave, eave];
+        if (Math.hypot(rb[0] - b[0], rb[1] - b[1]) > 1e-6) {
+            poly.push(rb);
+            heights.push(top);
+        }
+        if (Math.hypot(ra[0] - rb[0], ra[1] - rb[1]) > 1e-6) {
+            poly.push(ra);
+            heights.push(top);
+        }
+        if (poly.length >= 3)
+            faces.push({ poly, heights });
+    });
+    return faces;
+}
+/** The light on a wall by the way it faces on the district's plan: three tones, from the side the light comes from (up the page and to the left) to the side in shadow. */
+const sideOf = (a, b, wound) => {
+    const [dx, dy] = [b[0] - a[0], b[1] - a[1]];
+    const long = Math.hypot(dx, dy) || 1;
+    // On a page with y down, the outward normal of a ring wound clockwise is to the left of the walk from a to b, of one wound counter-clockwise to the right.
+    const [nx, ny] = wound > 0 ? [dy / long, -dx / long] : [-dy / long, dx / long];
+    const lit = nx * -0.45 + ny * -0.55;
+    return lit > 0.25 ? 0 : lit > -0.2 ? 1 : 2;
+};
+const SIDES = ["u-block-a", "u-block-b", "u-block-c"];
+/** One building as the planes of a block: its walls up to the eaves, and over them a flat roof, or a hip roof where it has a pitched one. A ghost's planes are always mostly cut away, so that a venue inside it shows. */
+export function blockPlanes(b, prefix) {
+    const planes = [];
+    const wound = signedArea(b.ring);
+    const pitched = b.rise > 3 && b.ring.length <= 8 && convex(b.ring);
+    const eave = pitched ? Math.max(b.height - b.rise, 3) : b.height;
+    const ghost = (p) => (b.ghost ? { ...p, shy: [0, 0], fadeAt: -10, fadeTo: 0.16 } : p);
+    // A see-through building: each wall gives way as the eye comes round to its side and looks in, to a trace of itself, and the roof is always nearly clear.
+    const xray = b.xray;
+    const wall1 = (p) => (xray === undefined ? ghost(p) : { ...shy(p, xray), fadeTo: 0.06, fadeSide: true });
+    const roof1 = (p) => (xray === undefined ? ghost(p) : { ...p, shy: [0, 0], fadeAt: -10, fadeTo: 0.1 });
+    b.ring.forEach((p, i) => {
+        const q = b.ring[(i + 1) % b.ring.length];
+        const long = Math.hypot(q[0] - p[0], q[1] - p[1]);
+        if (long < 3)
+            return;
+        planes.push(wall1(wall(`${prefix}w${i}`, "block", p[0], p[1], q[0], q[1], 0, eave, `<rect class="u-block ${SIDES[sideOf(p, q, wound)]}" width="${n(long)}" height="${n(eave)}"/>`)));
+    });
+    const roof = (id, poly, slope, along) => {
+        const p = raked(id, "block", poly, slope, along, (corners) => `<polygon class="u-block-roof" points="${pointList(corners)}"/>`);
+        if (p !== undefined)
+            planes.push(roof1(p));
+    };
+    if (!pitched) {
+        roof(`${prefix}top`, b.ring, { x0: b.ring[0][0], y0: b.ring[0][1], z0: b.height, gx: 0, gy: 0 }, [1, 0]);
+        return planes;
+    }
+    hipFaces(b.ring, eave, b.height).forEach((face, i) => {
+        const [p, q] = face.poly;
+        const long = Math.hypot(q[0] - p[0], q[1] - p[1]) || 1;
+        roof(`${prefix}r${i}`, face.poly, slopeThrough(face.poly.map((pt, k) => [pt[0], pt[1], face.heights[k]])), [(q[0] - p[0]) / long, (q[1] - p[1]) / long]);
+    });
+    return planes;
+}
+/** The blocks of the 3D view: the `most` buildings that matter most (the tallest and widest, by height times the side of their ground), each a few planes, in the order the plan lists them. */
+export function contextUprights(plan, most = CONTEXT_BLOCKS) {
+    const wanted = new Set(plan.blocks.filter((b) => b.whole).sort((a, b) => weight(b) - weight(a) || (a.id < b.id ? -1 : 1)).slice(0, Math.max(0, most)).map((b) => b.id));
+    const items = [];
+    for (const b of plan.blocks) {
+        if (!wanted.has(b.id))
+            continue;
+        const planes = blockPlanes(b, `c-${b.id}-`);
+        if (planes.length === 0)
+            continue;
+        const [x, y] = centroid(b.ring);
+        items.push({ id: `c-${b.id}`, kind: "blocks", at: [x, y], height: b.height, planes });
+    }
+    return items;
+}
+/** The building a raised venue stands in as a block: its outline in feet, its height, `xray` the middle its walls give way from (or none for a solid one). */
+export function shellBlock(key, ring, height, xray) {
+    return { id: `shell-${key}`, ring: [...ring], height, rise: 0, area: Math.abs(signedArea(ring)), ghost: false, whole: true, ...(xray === undefined ? {} : { xray }) };
+}

package/dist/crowd.d.ts

@@ -151,6 +151,15 @@ export interface RealShell {
         rise: number;
         opening: Pt[];
     };
+    /** The height of the building's podium, a lower band of its walls under the concourse levels, in feet; the walls are drawn in two bands where a venue has one (ours where the sources do not say). */
+    podium?: number;
+    /** A `fixed` roof closed in the middle by a cap with a long skylight along the surface's long side (Rogers Arena's): ours, from the brief. */
+    skylight?: boolean;
+    /** A `cable` roof's masts round its rim: how many, and how high they rise over the rim, in feet. */
+    masts?: {
+        count: number;
+        height: number;
+    };
     /** The height of the roof's lowest edge above the surface, in feet. */
     edge: number;
 }

package/dist/district-entry.d.ts

@@ -2,4 +2,18 @@ export { DISTRICT_IDS, DISTRICT_MARGIN, DISTRICT_MODES, KYOGIJO_DISTRICT_STYLE,
 export type { DistrictMember, DistrictMode, DistrictOptions, DistrictPlaced, DistrictPlan, DistrictVenueInput } from "./district.ts";
 export { buildDistrictTurn, districtPresets, districtTurnMarkup, mountDistrictTurn } from "./district.turn.ts";
 export type { DistrictTurnSettings } from "./district.turn.ts";
+export type { ContextArea } from "./context.ts";
+export { KODOKAN, KODOKAN_DOJO, KODOKAN_FLOOR_HEIGHT, KODOKAN_ROOM_HEIGHT, kodokanMember } from "./kodokan.ts";
 export { VENUE_ATTRIBUTION } from "./venues.ts";
+export { mountDistrict } from "./district.dom.ts";
+export type { KyogijoDistrict } from "./district.dom.ts";
+export { OUTSIDE_DENSITY, OUTSIDE_LEVELS, OUTSIDE_REACH, OUTSIDE_VENUES, hasOutside, isOutsideLevel, outsideCount, outsideCrowd, outsideLevelOf } from "./outside.ts";
+export type { OutsideCrowd, OutsideLevel, OutsideOptions } from "./outside.ts";
+export { PERSON_METRES, frameOf, rasterOutside } from "./outside.paint.ts";
+export type { OutsideFrame, OutsideStats } from "./outside.paint.ts";
+export { OUTSIDE_ROOM } from "./district.ts";
+export { WALK_CELL, WALK_IDS, walkMask, walkable } from "./walk.ts";
+export type { WalkData, WalkMask } from "./walk.ts";
+export { GATE_FACTS, GATE_VENUES, gateName, venueGates } from "./gates.ts";
+export type { Gate, GateBasis, GateFact } from "./gates.ts";
+export type { DistrictGate } from "./district.ts";

package/dist/district-entry.js

@@ -1,4 +1,13 @@
 // A district: several real venues of one city on one plan at their real relative positions and orientations (OpenStreetMap, ODbL 1.0), in 2D and in 3D, tight round neighbours or at the real distances of a city.
 export { DISTRICT_IDS, DISTRICT_MARGIN, DISTRICT_MODES, KYOGIJO_DISTRICT_STYLE, describeDistrict, districtId, districtMember, drawDistrict, isDistrictId, metresText, planDistrict, scaleOf, unknownVenues } from "./district.js";
 export { buildDistrictTurn, districtPresets, districtTurnMarkup, mountDistrictTurn } from "./district.turn.js";
+export { KODOKAN, KODOKAN_DOJO, KODOKAN_FLOOR_HEIGHT, KODOKAN_ROOM_HEIGHT, kodokanMember } from "./kodokan.js";
 export { VENUE_ATTRIBUTION } from "./venues.js";
+export { mountDistrict } from "./district.dom.js";
+// The crowd outside the venues, on ground people may stand on (OpenStreetMap, ODbL 1.0), at 0, 25, 50, 75 or 100 percent of the seats.
+export { OUTSIDE_DENSITY, OUTSIDE_LEVELS, OUTSIDE_REACH, OUTSIDE_VENUES, hasOutside, isOutsideLevel, outsideCount, outsideCrowd, outsideLevelOf } from "./outside.js";
+export { PERSON_METRES, frameOf, rasterOutside } from "./outside.paint.js";
+export { OUTSIDE_ROOM } from "./district.js";
+export { WALK_CELL, WALK_IDS, walkMask, walkable } from "./walk.js";
+// The gates of a venue: where the crowd goes in, on the building's outline, with the way each faces and how it is known.
+export { GATE_FACTS, GATE_VENUES, gateName, venueGates } from "./gates.js";