@johnmorrisdotca/kyogijo-stadiums 0.40.1 → 0.43.0

package/dist/district.turn.js

@@ -2,8 +2,9 @@
 // (`buildTurn`: the stands, the walls and the roof, the goals and posts of its field), its planes are turned about the middle of its surface and moved to where the plan puts it, and the floor is the district's flat
 // plan drawn with each venue's building only. The model it makes is a `TurnModel`, so the camera, the controls, the pointer, the auto-turn and the steady fit of every other 3D view are this one's; its
 // buildings are stacked building by building (`Plane.group`), the far one first, so that a roof never shows through a nearer building.
-import { describeDistrict, districtId, drawDistrict, drawMember, planDistrict, surfaceCentre } from "./district.js";
-import { n, plane } from "./turn.kit.js";
+import { describeDistrict, districtId, drawDistrict, drawMember, nestedDrawing, planDistrict, surfaceCentre } from "./district.js";
+import { blockPlanes, contextUprights, shellBlock } from "./context.js";
+import { APART, n, plane } from "./turn.kit.js";
 import { TURN_PRESETS, wrap } from "./turn.camera.js";
 import { mountTurn } from "./turn.dom.js";
 import { turnMarkupOf } from "./turn.markup.js";
@@ -11,6 +12,7 @@ import { buildTurn, lightingOf, openingView, sceneBox, WORLD_PX } from "./turn.m
 import { planesOf } from "./uprights.js";
 import { FEET_PER_METRE } from "./geometry.js";
 import { hullOf } from "./venues.geo.js";
+import { hasOutside, outsideCrowd, outsideLevelOf } from "./outside.js";
 /** The four viewpoints of a district, turned with the map: the main camera looks from the south over the district (north at the top of the page), the end-on view from the west and the low corner from the south-west. */
 export function districtPresets(plan) {
     const turn = plan.turn;
@@ -27,7 +29,7 @@ const rot = ([x, y], degrees) => {
     return [x * Math.cos(a) - y * Math.sin(a), x * Math.sin(a) + y * Math.cos(a)];
 };
 /** A plane of a venue's own frame (its surface's middle at `centre`) put in the district's: turned by the venue's angle about that middle and moved to where the plan puts it. */
-function placeInDistrict(p, placed, centre, prefix, group) {
+function placeInDistrict(p, placed, centre, prefix, group, lift = 0) {
     const at = (x, y) => {
         const [rx, ry] = rot([x - centre[0], y - centre[1]], placed.angle);
         return [rx + placed.at[0], ry + placed.at[1]];
@@ -36,7 +38,7 @@ function placeInDistrict(p, placed, centre, prefix, group) {
     const [ox, oy] = at(p.o[0], p.o[1]);
     const [ux, uy] = dir(p.u[0], p.u[1]);
     const [vx, vy] = dir(p.v[0], p.v[1]);
-    const moved = { ...p, id: `${prefix}${p.id}`, o: [ox, oy, p.o[2]], u: [ux, uy, p.u[2]], v: [vx, vy, p.v[2]], group };
+    const moved = { ...p, id: `${prefix}${p.id}`, o: [ox, oy, p.o[2] + lift], u: [ux, uy, p.u[2]], v: [vx, vy, p.v[2]], group };
     if (p.shy !== undefined)
         moved.shy = dir(p.shy[0], p.shy[1]);
     if (p.crop === true) {
@@ -77,19 +79,39 @@ export function buildDistrictTurn(options, settings = {}) {
         const model = buildTurn({ ...member.options, language, ...(options.theme === undefined ? {} : { theme: options.theme }), id: `${base}-m${i}` }, { ...settings, id: memberId, venue: { roof: true, ...(typeof settings.venue === "object" ? settings.venue : {}) }, preset: undefined, view: undefined });
         const centre = surfaceCentre(member.options);
         const prefix = `m${i}-`;
+        // A venue on an upper floor (the Kodokan's main dojo) stands that high over the ground, on a floor drawn in the air; the ground under it is left bare.
+        const lift = placed.member.elevation ?? 0;
         for (const item of model.uprights.items) {
-            const planes = item.planes.filter((p) => p.kind !== "ground").map((p) => placeInDistrict(p, placed, centre, prefix, i));
+            const planes = item.planes.filter((p) => p.kind !== "ground").map((p) => placeInDistrict(p, placed, centre, prefix, i, lift));
             if (planes.length > 0) {
                 const [ax, ay] = item.at;
                 const [rx, ry] = rot([ax - centre[0], ay - centre[1]], placed.angle);
-                items.push({ ...item, id: `${prefix}${item.id}`, at: [rx + placed.at[0], ry + placed.at[1]], planes });
+                items.push({ ...item, id: `${prefix}${item.id}`, at: [rx + placed.at[0], ry + placed.at[1]], height: item.height + lift, planes });
             }
         }
+        if (lift > 0) {
+            const { markup, box, styles } = nestedDrawing(drawMember(member, { ...options, id: base }, i, base, { floor: true }));
+            for (const block of styles)
+                if (!defs.includes(block))
+                    defs.push(block);
+            const floor = plane("floor", "floor", [box.x, box.y, 0], [box.w, 0, 0], [0, box.h, 0], `<g transform="translate(${n(-box.x)} ${n(-box.y)})">${markup}</g>`);
+            items.push({ id: `${prefix}floor`, kind: "deck", at: placed.at, height: lift, planes: [placeInDistrict(floor, placed, centre, prefix, i, lift)] });
+        }
+        // The building it stands in: see-through (its walls give way to the eye) or solid, in the venue's group so that it is stacked with it.
+        if (member.shell !== undefined && options.building !== "none") {
+            const block = shellBlock(member.key, placed.footprint, member.shell.height, options.building === "solid" ? undefined : placed.at);
+            const planes = blockPlanes(block, `${prefix}shell-`).map((p) => ({ ...p, group: i }));
+            items.push({ id: `${prefix}shell`, kind: "blocks", at: placed.at, height: member.shell.height, planes });
+        }
         if (model.defs !== "")
             defs.push(model.defs);
         if (crowdStyle === "" && model.crowdStyle !== "")
             crowdStyle = model.crowdStyle;
     });
+    // The buildings round the venues stand apart from them: each block's planes are of no venue's group.
+    if (plan.context !== undefined)
+        for (const item of contextUprights(plan.context))
+            items.push({ ...item, planes: item.planes.map((p) => ({ ...p, group: APART })) });
     if (labels) {
         const size = Math.max(plan.view.w, plan.view.h) * (plan.mode === "city" ? 0.016 : 0.022);
         plan.members.forEach((placed, i) => {
@@ -136,6 +158,8 @@ export function buildDistrictTurn(options, settings = {}) {
         lens: 12,
         flat: drawDistrict(options, plan),
         groups: plan.members.map((p) => ({ hull: hullOf(p.footprint) })),
+        // The crowd outside, when the district asks for one and has a mask to put it on: the mount paints it on a canvas on the floor.
+        ...(options.outside !== undefined && hasOutside(plan) ? { outside: { level: outsideLevelOf(options), crowd: () => outsideCrowd(plan), viewBox: { x: view.x, y: view.y, w: view.w, h: view.h } } } : {}),
     };
 }
 /**

package/dist/draw.js

@@ -457,8 +457,13 @@ function standsFor(o, surface, crowd) {
         return crowdLayout({ sport, box, crowd: crowd.awayEnd === "auto" ? { ...crowd, awayEnd: "none" } : crowd, awaySide, real: venueBowl(venue, box) });
     // A football field or a soccer pitch in a real stadium: its building and a bowl of the configuration's seats.
     const real = realStadiumOf(o, sport, crowd.real);
-    if (real !== undefined)
-        return crowdLayout({ sport, box, crowd: crowd.awayEnd === "auto" ? { ...crowd, awayEnd: "none" } : crowd, awaySide, real: stadiumBowl(real.stadium, real.config, box) });
+    if (real !== undefined) {
+        const stands = (at) => crowdLayout({ sport, box: at, crowd: crowd.awayEnd === "auto" ? { ...crowd, awayEnd: "none" } : crowd, awaySide, real: stadiumBowl(real.stadium, real.config, at) });
+        if (!venueFrame(o, crowd, surface))
+            return stands(box);
+        // In the venue's frame the middle of the field is the origin, so the same building, bowl and crowd are laid out whichever field is in it.
+        return { ...stands({ x: -box.w / 2, y: -box.h / 2, w: box.w, h: box.h }), shift: [box.x + box.w / 2, box.y + box.h / 2] };
+    }
     // A dojo's crowd sits in its gallery, from the room's balcony data (in feet here); the arenas (the Budokan, the Kokugikan) keep their bowls.
     const hall = sport === "dojo" ? dojoGallery(o) : undefined;
     const gallery = hall === undefined ? undefined : { offset: hall.offset / 0.3048, depth: hall.depth / 0.3048, height: [hall.height[0] / 0.3048, hall.height[1] / 0.3048], rows: hall.rows, aisles: hall.aisles };
@@ -476,6 +481,13 @@ function stadiumHasConfigs(o, crowd) {
     const real = realStadiumOf(o, chooseLeague(o).sport, crowd.real);
     return real !== undefined && stadiumKind(real.stadium) === "stadium" && stadiumConfigs(real.stadium).length > 1;
 }
+/**
+ * Whether a stadium of more than one configuration is laid out in the venue's own frame: its field is placed in it, and the building, the bowl, the crowd and the view are the same numbers whichever field it is. Not for a portrait drawing,
+ * a cropped one, or one that asks for annotations, a situation, a pageant or the pointer, which are worked out in the surface's own frame.
+ */
+function venueFrame(o, crowd, surface) {
+    return surface.turn === undefined && o.range === undefined && o.situation === undefined && o.pageant === undefined && o.pointer !== true && !annotated(o) && stadiumHasConfigs(o, crowd);
+}
 /** A surface with the stands and the crowd round it: the ground is made as wide as the stands need, then the stands are laid on it under the surface. */
 function buildCrowded(o, portrait, id, score, scored, extra, crowd) {
     let margin = extra.margin;
@@ -490,13 +502,6 @@ function buildCrowded(o, portrait, id, score, scored, extra, crowd) {
     }
     const surface = buildWhole(o, portrait, id, score, scored, { ...extra, margin });
     const stands = standsFor(o, surface, crowd);
-    // A stadium that stages more than one field is framed by its building, once, whichever field is drawn: the view is the building's with a small margin, about the middle of the field.
-    const field = stands.box;
-    if (surface.turn === undefined && o.range === undefined && stadiumHasConfigs(o, crowd)) {
-        const [cx, cy] = [field.x + field.w / 2, field.y + field.h / 2];
-        const [left, right, top, bottom] = [field.w / 2 + stands.reach.left, field.w / 2 + stands.reach.right, field.h / 2 + stands.reach.top, field.h / 2 + stands.reach.bottom].map((d) => d + VENUE_PAD);
-        surface.view = { x: cx - left, y: cy - top, w: left + right, h: top + bottom };
-    }
     const seats = stands.seats;
     const ground = groundById(o.ground)?.capacity;
     const fine = crowd.detail === "fine" || (crowd.detail === "auto" && !smallDrawing(o));
@@ -505,6 +510,22 @@ function buildCrowded(o, portrait, id, score, scored, extra, crowd) {
     // A gallery is empty unless the options say how full: its seats are the detail.
     const taken = stands.gallery === true && crowd.density === undefined && crowd.attendance === undefined ? 0 : densityOf(crowd, seats, ground);
     const drawn = drawCrowd(stands, { id, crowd, density: taken, fine, ground: bg, team: teamColors(o) });
+    if (stands.shift !== undefined) {
+        // A stadium of more than one configuration: the ground, the building, the stands and the crowd are laid in the venue's own frame (the middle of the field at the origin), under a surface that is shifted to lie in it, and the view is the
+        // building's with a little ground round it: the same frame, the same numbers, the same crowd whichever field is drawn. What stands over the field comes back to the surface's frame.
+        const [sx, sy] = stands.shift;
+        const { reach, box } = stands;
+        const [left, right, top, bottom] = [box.w / 2 + reach.left, box.w / 2 + reach.right, box.h / 2 + reach.top, box.h / 2 + reach.bottom].map((d) => Math.round((d + VENUE_PAD) * 100) / 100);
+        const view = { x: -left, y: -top, w: left + right, h: top + bottom };
+        const apron = first.replace(/\sx="[^"]*"/, ` x="${view.x - 1}"`).replace(/\sy="[^"]*"/, ` y="${view.y - 1}"`).replace(/\swidth="[^"]*"/, ` width="${view.w + 2}"`).replace(/\sheight="[^"]*"/, ` height="${view.h + 2}"`);
+        surface.venue = { shift: [sx, sy], under: apron + drawn.markup };
+        surface.base = surface.base.slice(first.length);
+        surface.view = view;
+        surface.defs += drawn.defs;
+        surface.lines += drawn.over === "" ? "" : el("g", { transform: `translate(${sx.toFixed(4)} ${sy.toFixed(4)})` }, drawn.over);
+        surface.crowdMargin = margin;
+        return surface;
+    }
     surface.base = first + drawn.markup + surface.base.slice(first.length);
     surface.defs += drawn.defs;
     surface.lines += drawn.over;
@@ -1011,8 +1032,10 @@ function drawnKyogijo(o) {
         if (lines !== undefined)
             surface.lines = restyleLines(surface.lines, lines);
         // A ground (a pattern, a colour or a photograph) is laid on the apron, under the surface.
-        const ground = laidOn(surface.base, o.background, id);
-        grounded = ground.base !== surface.base;
+        // A stadium laid out in the venue's frame has its ground, building and stands under the surface, which is shifted to lie in it.
+        const venue = surface.venue;
+        const ground = laidOn(venue === undefined ? surface.base : venue.under, o.background, id);
+        grounded = ground.base !== (venue === undefined ? surface.base : venue.under);
         defs = surface.defs + ground.defs;
         // The situation: a tint under the lines, and the rest over them and the data (cut with the surface when it is cropped).
         const sit = situation === undefined
@@ -1026,7 +1049,7 @@ function drawnKyogijo(o) {
                 strip: stripped && sized === "compact",
             });
         const cutSit = (markup) => (markup !== "" && surface.defs.includes(`id="${id}-rg"`) ? el("g", { "clip-path": `url(#${id}-rg)` }, markup) : markup);
-        let inner = ground.base + (sit === undefined ? "" : cutSit(sit.under));
+        let inner = (venue === undefined ? ground.base : surface.base) + (sit === undefined ? "" : cutSit(sit.under));
         if (sit !== undefined)
             defs += sit.defs;
         let teams = "";
@@ -1110,7 +1133,8 @@ function drawnKyogijo(o) {
             else
                 inner += plateMarkup(surface.plate, left, right, { competition: o.competition, foot: foot === "" ? undefined : foot }, { turned: surface.turned, parts, surfaceSport: sport });
         }
-        const group = el("g", { class: "ky-surface-group", transform: surface.turn, part: parts ? "surface" : undefined, ...(o.pointer === true ? fieldAttributes({ ...o, sport }) : {}) }, inner);
+        const field = el("g", { class: "ky-surface-group", transform: venue === undefined ? surface.turn : `translate(${(-venue.shift[0]).toFixed(4)} ${(-venue.shift[1]).toFixed(4)})`, part: parts ? "surface" : undefined, ...(o.pointer === true ? fieldAttributes({ ...o, sport }) : {}) }, inner);
+        const group = venue === undefined ? field : ground.base + field;
         const v = surface.view;
         if (isScore(o) && left !== undefined && right !== undefined && sized === "compact") {
             const badge = badgeMarkup(left, right, { sport, status, parts, id, situation: situation === undefined ? undefined : badgeSituation(situation, language) });

package/dist/gates.d.ts

@@ -0,0 +1,56 @@
+import { type LonLat } from "./venues.geo.ts";
+/** How a gate is known: `documented` is what a source cited with it says; `plausible` is ours. */
+export type GateBasis = "documented" | "plausible";
+/** What is said of a venue's gate: the way it faces, and what is read from where. */
+export interface GateFact {
+    /** A key that is the same on every run: `south`, `south-west-corner`. */
+    id: string;
+    /** The bearing of the gate's outward normal, degrees clockwise from north, 0 to under 360. */
+    bearing: number;
+    /** The name where a source gives one (`Gate G`); a plain description of where it is otherwise. */
+    name?: {
+        en: string;
+        ja: string;
+    };
+    basis: GateBasis;
+    read: string;
+}
+/** A gate, placed on a venue's outline. */
+export interface Gate {
+    /** `bc-place:south`: the venue's id and the gate's. */
+    key: string;
+    venue: string;
+    id: string;
+    name: {
+        en: string;
+        ja: string;
+    };
+    /** Where it stands on the outline, `[longitude, latitude]`. */
+    at: LonLat;
+    /** The bearing of its outward normal, degrees clockwise from north: the way a queue at it runs. */
+    bearing: number;
+    basis: GateBasis;
+    read: string;
+}
+/**
+ * The facts of each venue's gates. BC Place: the English Wikipedia article (revision 1372065649) says a tear in the old roof was "close to Gate G on the south side where the roof meets the top of the concrete bowl", so there is a
+ * Gate G on the south side (documented); the other seven are ours, one to each side of the building, on the street sides the brief names (Pacific Boulevard to the south, Robson and Beatty Streets). Rogers Arena: the brief's corner
+ * entrance plazas on the Pat Quinn Way side, the south front and the two south corners, and one at the north-west, all ours.
+ */
+export declare const GATE_FACTS: Readonly<Record<string, readonly GateFact[]>>;
+/** The ids of the venues that have gates. */
+export declare const GATE_VENUES: readonly string[];
+/** The name of a gate in a language: the source's where there is one, else its side (`South-west gate`). */
+export declare function gateName(fact: GateFact, language: "en" | "ja"): string;
+/**
+ * The gates of a venue (`bc-place`, `rogers-arena`), each on the building's outline where a ray from the middle of the surface at its bearing meets it; empty for a venue with none. A gate whose ray misses the outline is left out
+ * (none does for the venues here: a test holds it).
+ * @example
+ * ```ts
+ * import { venueGates } from "@johnmorrisdotca/kyogijo-stadiums/district";
+ * const gates = venueGates("bc-place");
+ * console.log(gates.length, gates.filter((g) => g.basis === "documented").map((g) => g.name.en).join(", "));
+ * // 8 Gate G
+ * ```
+ */
+export declare function venueGates(id: string): Gate[];

package/dist/gates.js

@@ -0,0 +1,95 @@
+// The gates of a real venue: where the crowd goes in. A gate is a point on the building's outline (OpenStreetMap's, ODbL 1.0) with the way it faces (the bearing of its outward normal, degrees clockwise from north), a name in English
+// and Japanese, and how it is known: `documented` where a source cited with it says it, `plausible` where it is ours (a gate on each street side, put where a ray from the middle of the surface at the bearing meets the outline).
+// The data is the gates' list of facts (`GATE_FACTS`, with what each cites); the positions are worked out from the outline, so a venue whose outline changes keeps its gates on it. This is the data the crowd's timelapse will use
+// for queues and entrances: where people stand in a line, which way the line runs (away from the gate along its bearing) and where the walkable ground starts. Pure: ids in, gates out.
+import { stadiumById } from "./stadiums.js";
+import { venueById } from "./venues.js";
+import { lonLatFrom, metresFrom } from "./venues.geo.js";
+const WIND = [
+    { en: "north", ja: "北" },
+    { en: "north-east", ja: "北東" },
+    { en: "east", ja: "東" },
+    { en: "south-east", ja: "南東" },
+    { en: "south", ja: "南" },
+    { en: "south-west", ja: "南西" },
+    { en: "west", ja: "西" },
+    { en: "north-west", ja: "北西" },
+];
+const ours = (reason) => `ours: ${reason}`;
+/** A gate on each of the eight sides of a building: ours, the sources say that a stadium has gates and not where each is. */
+const SIDES = (venue) => WIND.map((_, i) => ({ id: WIND[i].en, bearing: i * 45, basis: "plausible", read: ours(`one gate on each of the eight sides of ${venue}'s building: the sources say that it has gates round the bowl and not where each is`) }));
+/**
+ * The facts of each venue's gates. BC Place: the English Wikipedia article (revision 1372065649) says a tear in the old roof was "close to Gate G on the south side where the roof meets the top of the concrete bowl", so there is a
+ * Gate G on the south side (documented); the other seven are ours, one to each side of the building, on the street sides the brief names (Pacific Boulevard to the south, Robson and Beatty Streets). Rogers Arena: the brief's corner
+ * entrance plazas on the Pat Quinn Way side, the south front and the two south corners, and one at the north-west, all ours.
+ */
+export const GATE_FACTS = Object.freeze({
+    "bc-place": SIDES("BC Place").map((g) => (g.id === "south" ? { ...g, name: { en: "Gate G", ja: "ゲートG" }, basis: "documented", read: "the English Wikipedia article on BC Place, revision 1372065649: a tear in the old roof 'close to Gate G on the south side'; where on the south side is ours" } : g)),
+    "rogers-arena": [
+        { id: "south", bearing: 180, basis: "plausible", read: ours("the main front of the building faces Pat Quinn Way to the south, as the brief says") },
+        { id: "south-west", bearing: 225, basis: "plausible", read: ours("a corner entrance plaza on the Pat Quinn Way side, as the brief says") },
+        { id: "south-east", bearing: 135, basis: "plausible", read: ours("a corner entrance plaza on the Pat Quinn Way side, as the brief says") },
+        { id: "north-west", bearing: 315, basis: "plausible", read: ours("a gate on the side of the Georgia Viaduct and the towers, one of those the brief asks for at the corners") },
+    ],
+});
+/** The ids of the venues that have gates. */
+export const GATE_VENUES = Object.freeze(Object.keys(GATE_FACTS));
+/** The point where a ray from the origin at a compass bearing first meets a ring (both in metres east and north of the origin), or `undefined`. */
+function hit(ring, bearing) {
+    const a = (bearing * Math.PI) / 180;
+    const [dx, dy] = [Math.sin(a), Math.cos(a)];
+    let best;
+    ring.forEach(([ax, ay], i) => {
+        const [bx, by] = ring[(i + 1) % ring.length];
+        const [ex, ey] = [bx - ax, by - ay];
+        const den = dx * ey - dy * ex;
+        if (Math.abs(den) < 1e-12)
+            return;
+        const t = (ax * ey - ay * ex) / den;
+        const u = (ax * dy - ay * dx) / den;
+        if (t > 1e-6 && u >= 0 && u <= 1 && (best === undefined || t < best))
+            best = t;
+    });
+    return best === undefined ? undefined : [dx * best, dy * best];
+}
+/** The outline and the middle of a venue's surface that its gates are placed from, `[longitude, latitude]`: an arena's, or a stadium's. */
+function outlineOf(id) {
+    const venue = venueById(id);
+    if (venue !== undefined)
+        return { ring: venue.osm.ring, centre: venue.osm.axis.centre };
+    const stadium = stadiumById(id);
+    return stadium === undefined ? undefined : { ring: stadium.osm.ring, centre: stadium.osm.axis.centre };
+}
+/** The name of a gate in a language: the source's where there is one, else its side (`South-west gate`). */
+export function gateName(fact, language) {
+    if (fact.name !== undefined)
+        return fact.name[language];
+    const side = WIND.find((w) => w.en === fact.id.replace(/-corner$/, ""));
+    return language === "ja" ? `${side?.ja ?? fact.id}ゲート` : `${(side?.en ?? fact.id).replace(/^./, (c) => c.toUpperCase())} gate`;
+}
+/**
+ * The gates of a venue (`bc-place`, `rogers-arena`), each on the building's outline where a ray from the middle of the surface at its bearing meets it; empty for a venue with none. A gate whose ray misses the outline is left out
+ * (none does for the venues here: a test holds it).
+ * @example
+ * ```ts
+ * import { venueGates } from "@johnmorrisdotca/kyogijo-stadiums/district";
+ * const gates = venueGates("bc-place");
+ * console.log(gates.length, gates.filter((g) => g.basis === "documented").map((g) => g.name.en).join(", "));
+ * // 8 Gate G
+ * ```
+ */
+export function venueGates(id) {
+    const facts = GATE_FACTS[id];
+    const outline = outlineOf(id);
+    if (facts === undefined || outline === undefined)
+        return [];
+    const ring = metresFrom(outline.centre, outline.ring);
+    const gates = [];
+    for (const fact of facts) {
+        const p = hit(ring, fact.bearing);
+        if (p === undefined)
+            continue;
+        gates.push({ key: `${id}:${fact.id}`, venue: id, id: fact.id, name: { en: gateName(fact, "en"), ja: gateName(fact, "ja") }, at: lonLatFrom(outline.centre, p).map((x) => Math.round(x * 1e6) / 1e6), bearing: fact.bearing, basis: fact.basis, read: fact.read });
+    }
+    return gates;
+}

package/dist/halls.d.ts

@@ -61,5 +61,7 @@ export interface Hall {
         ja: string;
     };
 }
+/** The Kodokan's main dojo as drawn: a square floor of 420 jō's area, four contest areas, the seat of honour, the banner, the wood and the gallery, in the two looks the owner's photographs show. The years of both are unknown. */
+export declare const KODOKAN_MAIN: DojoSpec;
 /** The halls, in the order of their surfaces' fame: the Kodokan, the Budokan, the Kokugikan, the Butokuden and the Budokwai. */
 export declare const HALLS: readonly Hall[];

package/dist/halls.js

@@ -1,5 +1,5 @@
 /** The Kodokan's main dojo as drawn: a square floor of 420 jō's area, four contest areas, the seat of honour, the banner, the wood and the gallery, in the two looks the owner's photographs show. The years of both are unknown. */
-const KODOKAN_MAIN = {
+export const KODOKAN_MAIN = {
     mats: { width: 26.4, length: 26.4 },
     surround: 4,
     areas: { across: 2, down: 2 },

package/dist/kodokan.d.ts

@@ -0,0 +1,28 @@
+import type { DistrictMember } from "./district.ts";
+import type { DojoSpec, Language } from "./types.ts";
+/** The main dojo as the district draws it: the atlas's floor and fittings, with no wood round the mats (the 4 metres the atlas draws would not stand inside the real building). */
+export declare const KODOKAN_DOJO: DojoSpec;
+/** How high the room stands, floor to the top of its lid, in metres: the 3D build's own figure (walls of 4.5 metres, the gallery level with their tops, the lid over it), two storeys of the building. Ours. */
+export declare const KODOKAN_ROOM_HEIGHT = 11.2;
+/** The height of the main dojo's floor above the ground, in metres: the 7th floor, six storeys up at the building's own storey height (its height over its storeys, 5.4 metres), and no higher than leaves the room under the roof. */
+export declare const KODOKAN_FLOOR_HEIGHT: number;
+/** Where the Kodokan's building stands and what it is: for tests and pages that say it. */
+export declare const KODOKAN: {
+    readonly floorHeight: number;
+    readonly roomHeight: 11.2;
+    readonly mats: 420;
+    readonly seats: 900;
+    readonly source: "bldg_ec4aa7a9-f8cb-4abb-af0c-a2cef6d06dd8";
+    readonly read: "2026-10-22";
+    readonly ring: readonly [readonly [139.753281, 35.707485], readonly [139.753287, 35.707464], readonly [139.753659, 35.707456], readonly [139.753548, 35.707846], readonly [139.753502, 35.707837], readonly [139.753496, 35.707859], readonly [139.753195, 35.707801], readonly [139.753268, 35.707546], readonly [139.753193, 35.707532], readonly [139.75321, 35.707472]];
+    readonly height: 43.1;
+    readonly storeys: 8;
+    readonly room: {
+        readonly centre: readonly [139.75342, 35.707654];
+        readonly heading: 77;
+        readonly side: 31.8;
+        readonly clearance: 0.18;
+    };
+};
+/** The Kodokan as a member of a district. */
+export declare function kodokanMember(language: Language): DistrictMember;

package/dist/kodokan.data.d.ts

@@ -0,0 +1,18 @@
+/** The Kodokan's building and the place of its main dojo in it. */
+export declare const KODOKAN_BUILDING: {
+    /** The building's id in PLATEAU's file (bldg:Building gml:id). */
+    readonly source: "bldg_ec4aa7a9-f8cb-4abb-af0c-a2cef6d06dd8";
+    readonly read: "2026-10-22";
+    /** The roof-edge outline, `[longitude, latitude]`. */
+    readonly ring: readonly [readonly [139.753281, 35.707485], readonly [139.753287, 35.707464], readonly [139.753659, 35.707456], readonly [139.753548, 35.707846], readonly [139.753502, 35.707837], readonly [139.753496, 35.707859], readonly [139.753195, 35.707801], readonly [139.753268, 35.707546], readonly [139.753193, 35.707532], readonly [139.75321, 35.707472]];
+    /** The height of the building's top above its ground, in metres, and its storeys above ground. */
+    readonly height: 43.1;
+    readonly storeys: 8;
+    /** The middle of the main dojo's room, `[longitude, latitude]`, the compass heading of its x axis (0 to under 180) and the length of its side in metres, walls and gallery included. */
+    readonly room: {
+        readonly centre: readonly [139.75342, 35.707654];
+        readonly heading: 77;
+        readonly side: 31.8;
+        readonly clearance: 0.18;
+    };
+};

package/dist/kodokan.data.js

@@ -0,0 +1,18 @@
+// Made by scripts/build-plateau.mjs from data-sources/plateau/2026-10-22/: do not edit by hand.
+//
+// THIS FILE IS DATA FROM PROJECT PLATEAU, edited: the Kodokan's building (its roof-edge outline simplified to 0.3 metres, its height and its storeys, from MLIT's 3D city model of Bunkyo ward, 2025 edition) and where the main dojo's
+// room is put in it (worked out here from the outline, ours). The credit is `PLATEAU_ATTRIBUTION` (plateau.credit.ts), the terms the PLATEAU Site Policy's (free, commercial use included, compatible with CC BY 4.0). Apart from the
+// OpenStreetMap data (ODbL 1.0); nothing is copied from one to the other. The raw extract is in data-sources/plateau/.
+/** The Kodokan's building and the place of its main dojo in it. */
+export const KODOKAN_BUILDING = {
+    /** The building's id in PLATEAU's file (bldg:Building gml:id). */
+    "source": "bldg_ec4aa7a9-f8cb-4abb-af0c-a2cef6d06dd8",
+    "read": "2026-10-22",
+    /** The roof-edge outline, `[longitude, latitude]`. */
+    "ring": [[139.753281, 35.707485], [139.753287, 35.707464], [139.753659, 35.707456], [139.753548, 35.707846], [139.753502, 35.707837], [139.753496, 35.707859], [139.753195, 35.707801], [139.753268, 35.707546], [139.753193, 35.707532], [139.75321, 35.707472]],
+    /** The height of the building's top above its ground, in metres, and its storeys above ground. */
+    "height": 43.1,
+    "storeys": 8,
+    /** The middle of the main dojo's room, `[longitude, latitude]`, the compass heading of its x axis (0 to under 180) and the length of its side in metres, walls and gallery included. */
+    "room": { "centre": [139.75342, 35.707654], "heading": 77, "side": 31.8, "clearance": 0.18 },
+};

package/dist/kodokan.js

@@ -0,0 +1,34 @@
+// The Kodokan (講道館) as a venue of a district: its building, from Project PLATEAU, and its main dojo (大道場), the room on the 7th floor with its gallery on the 8th, drawn in the air on its real floor over the building's own outline.
+// The facts that are documented are the count (420 jō of mats, four contest areas at once), the floor (the 7th), the gallery (the 8th, about 900) and the building (8 floors and a basement; PLATEAU: 8 storeys above ground, 43.1 metres): the Kodokan's own page, English
+// Wikipedia and the IJF say the first four (`docs/district.md`, "The Kodokan"). Ours: the shape of the floor (no source gives it: a square of 26.4 metres, the area of 420 jō, on which four areas of 8 metres fit, as `halls.ts` draws it), the room's place in the
+// building (the square that stands farthest from its walls, `scripts/build-plateau.mjs`), the wood round the mats (none, so that the room fits the real outline) and the height of the 7th floor (six storeys of the building's own). Pure data and a few sums.
+import { FEET_PER_METRE } from "./geometry.js";
+import { KODOKAN_MAIN } from "./halls.js";
+import { KODOKAN_BUILDING as BUILDING } from "./kodokan.data.js";
+import { PLATEAU_ATTRIBUTION } from "./plateau.credit.js";
+/** The main dojo as the district draws it: the atlas's floor and fittings, with no wood round the mats (the 4 metres the atlas draws would not stand inside the real building). */
+export const KODOKAN_DOJO = { ...KODOKAN_MAIN, surround: 0 };
+/** How high the room stands, floor to the top of its lid, in metres: the 3D build's own figure (walls of 4.5 metres, the gallery level with their tops, the lid over it), two storeys of the building. Ours. */
+export const KODOKAN_ROOM_HEIGHT = 11.2;
+/** The height of the main dojo's floor above the ground, in metres: the 7th floor, six storeys up at the building's own storey height (its height over its storeys, 5.4 metres), and no higher than leaves the room under the roof. */
+export const KODOKAN_FLOOR_HEIGHT = Math.min((6 * BUILDING.height) / BUILDING.storeys, BUILDING.height - KODOKAN_ROOM_HEIGHT);
+/** Where the Kodokan's building stands and what it is: for tests and pages that say it. */
+export const KODOKAN = { ...BUILDING, floorHeight: KODOKAN_FLOOR_HEIGHT, roomHeight: KODOKAN_ROOM_HEIGHT, mats: 420, seats: 900 };
+/** The Kodokan as a member of a district. */
+export function kodokanMember(language) {
+    return {
+        key: "kodokan",
+        id: "kodokan",
+        kind: "hall",
+        name: { en: "Kodokan", ja: "講道館" },
+        ring: BUILDING.ring,
+        centre: BUILDING.room.centre,
+        heading: BUILDING.room.heading,
+        basis: "building",
+        seats: KODOKAN.seats,
+        options: { sport: "dojo", dojo: KODOKAN_DOJO, crowd: { real: true }, language },
+        elevation: KODOKAN_FLOOR_HEIGHT * FEET_PER_METRE,
+        shell: { height: BUILDING.height * FEET_PER_METRE, storeys: BUILDING.storeys },
+        attribution: PLATEAU_ATTRIBUTION,
+    };
+}

package/dist/osm-entry.d.ts

@@ -0,0 +1,2 @@
+export { OSM_AREAS, OSM_ATTRIBUTION, VANCOUVER_CENTRE } from "./osm.context.data.ts";
+export type { ContextArea } from "./context.ts";

package/dist/osm-entry.js

@@ -0,0 +1,2 @@
+// The buildings and streets round a district, from OpenStreetMap (ODbL 1.0), as data a district takes in its `context` option: downtown Vancouver's, round BC Place and Rogers Arena, with the credit that goes with a drawing made from it.
+export { OSM_AREAS, OSM_ATTRIBUTION, VANCOUVER_CENTRE } from "./osm.context.data.js";

package/dist/osm.context.data.d.ts

@@ -0,0 +1,10 @@
+import type { ContextArea } from "./context.ts";
+/** The credit that goes with a drawing made from these buildings and streets, in each language. */
+export declare const OSM_ATTRIBUTION: {
+    en: string;
+    ja: string;
+};
+/** The buildings and streets round each district that has a mask, by key. */
+export declare const OSM_AREAS: Record<string, ContextArea>;
+/** Downtown Vancouver round BC Place and Rogers Arena. */
+export declare const VANCOUVER_CENTRE: ContextArea;