@johnmorrisdotca/kyogijo-stadiums 0.5.0 → 0.6.1

package/dist/turn-entry.d.ts

@@ -5,8 +5,8 @@ export type { TurnModel, TurnSettings } from "./turn.model.ts";
 export { layoutOf, planeMarkup, planeMatrix, turnMarkup, turnMarkupOf } from "./turn.markup.ts";
 export type { Layout } from "./turn.markup.ts";
 export { KYOGIJO_TURN_STYLE } from "./turn.style.ts";
-export { CURLING_PRESETS, LONG_PRESETS, NET_PRESETS, PITCH_MAX, STEP, TURN_DEFAULT, TURN_PRESETS, TURN_PRESET_NAMES, ZOOM_MAX, ZOOM_MIN, cameraMatrix, clampView, depthOf, drag, eyeDistance, fit, matrix3d, multiply, presetOf, presetView, presetsFor, project, step } from "./turn.camera.ts";
-export type { Box3, Mat4, Placement, TurnPreset, TurnView } from "./turn.camera.ts";
+export { CURLING_PRESETS, LONG_PRESETS, NET_PRESETS, PITCH_MAX, STEP, TURN_DEFAULT, TURN_PRESETS, TURN_PRESET_NAMES, ZOOM_MAX, ZOOM_MIN, cameraMatrix, clampView, depthOf, drag, eyeDistance, fit, matrix3d, multiply, nudge, presetOf, presetView, presetsFor, project, step } from "./turn.camera.ts";
+export type { Box3, Mat4, Placement, TurnPreset, TurnToward, TurnView } from "./turn.camera.ts";
 export { describeUprights, heightUnit, planesOf, uprightsFor } from "./uprights.ts";
 export type { UprightOptions, Uprights } from "./uprights.ts";
 export type { Plane, PartKind, Upright, UprightKind, V3 } from "./turn.kit.ts";

package/dist/turn-entry.js

@@ -3,5 +3,5 @@ export { mountKyogijoTurn, turnSupported } from "./turn.dom.js";
 export { buildTurn, floorOptions, openingView } from "./turn.model.js";
 export { layoutOf, planeMarkup, planeMatrix, turnMarkup, turnMarkupOf } from "./turn.markup.js";
 export { KYOGIJO_TURN_STYLE } from "./turn.style.js";
-export { CURLING_PRESETS, LONG_PRESETS, NET_PRESETS, PITCH_MAX, STEP, TURN_DEFAULT, TURN_PRESETS, TURN_PRESET_NAMES, ZOOM_MAX, ZOOM_MIN, cameraMatrix, clampView, depthOf, drag, eyeDistance, fit, matrix3d, multiply, presetOf, presetView, presetsFor, project, step } from "./turn.camera.js";
+export { CURLING_PRESETS, LONG_PRESETS, NET_PRESETS, PITCH_MAX, STEP, TURN_DEFAULT, TURN_PRESETS, TURN_PRESET_NAMES, ZOOM_MAX, ZOOM_MIN, cameraMatrix, clampView, depthOf, drag, eyeDistance, fit, matrix3d, multiply, nudge, presetOf, presetView, presetsFor, project, step } from "./turn.camera.js";
 export { describeUprights, heightUnit, planesOf, uprightsFor } from "./uprights.js";

package/dist/turn.camera.d.ts

@@ -56,7 +56,18 @@ export declare function step(view: TurnView, change: {
     pitch?: number;
     zoom?: number;
 }): TurnView;
-/** The view after a drag of the pointer by (dx, dy) pixels: across turns the scene, up and down tips it, `degreesPerPixel` apart. */
+/** A side a key, a button or a drag takes the surface toward. */
+export type TurnToward = "left" | "right" | "up" | "down";
+/**
+ * The view after a step of `amount` degrees toward a side, the way a drag toward that side takes the view: left and right carry the near side to the left and to the right (the yaw rises and
+ * falls), up tips the surface as a drag up does and down as a drag down does (the pitch rises and falls). The arrow keys and the four turn buttons are this, so that a drag, a key and a button
+ * toward one side all move the surface the same way.
+ */
+export declare function nudge(view: TurnView, toward: TurnToward, amount: number): TurnView;
+/**
+ * The view after a drag of the pointer by (dx, dy) pixels, `degreesPerPixel` apart: the surface is taken hold of, so a drag to the right carries the side nearest the eye to the right (the
+ * yaw falls) and a drag down tips the top toward the eye (the pitch falls).
+ */
 export declare function drag(view: TurnView, dx: number, dy: number, tilt?: boolean, degreesPerPixel?: number): TurnView;
 /** A box in the scene, in pixels from the scene's middle, the floor at `z0` and the highest thing at `z1`. */
 export interface Box3 {
@@ -83,8 +94,10 @@ export declare function covered(b: Box3, view: TurnView, at: Placement, distance
     y1: number;
 };
 /**
- * The placement that fits the scene in a container of width `w` and height `h` pixels, centred, with `pad` of its width and height left round it. The
- * perspective bends the sum, so it is found by a few rounds of scaling and re-centring; six is plenty.
+ * The placement that fits the scene in a container of width `w` and height `h` pixels, centred, with `pad` of its width and height left round it. It fits the scene at every turn about the
+ * vertical at the view's pitch, not at the view's own turn (its `yaw` is not used): the scale and the place are one for the whole circle, so that turning never zooms in and out or sways, and
+ * nothing is cut off at any angle. (A turn used to fit each angle alone, so a long floor was drawn up to 1.8 times as large side-on as end-on.) Tipping the view still rescales it, since the
+ * extent of the scene on the screen changes with the pitch. The perspective bends the sum, so it is found by a few rounds of scaling and re-centring; six is plenty.
  */
 export declare function fit(b: Box3, view: TurnView, w: number, h: number, distance: number, pad?: number): Placement;
 /** A 4 by 4 matrix, as CSS writes it in `matrix3d`: sixteen numbers, a column after a column. */

package/dist/turn.camera.js

@@ -77,9 +77,25 @@ export const STEP = { yaw: 6, yawBig: 24, pitch: 4, pitchBig: 12, zoom: 1.2 };
 export function step(view, change) {
     return clampView({ yaw: view.yaw + (change.yaw ?? 0), pitch: view.pitch + (change.pitch ?? 0), zoom: view.zoom * (change.zoom ?? 1) });
 }
-/** The view after a drag of the pointer by (dx, dy) pixels: across turns the scene, up and down tips it, `degreesPerPixel` apart. */
+/**
+ * The view after a step of `amount` degrees toward a side, the way a drag toward that side takes the view: left and right carry the near side to the left and to the right (the yaw rises and
+ * falls), up tips the surface as a drag up does and down as a drag down does (the pitch rises and falls). The arrow keys and the four turn buttons are this, so that a drag, a key and a button
+ * toward one side all move the surface the same way.
+ */
+export function nudge(view, toward, amount) {
+    switch (toward) {
+        case "left": return step(view, { yaw: amount });
+        case "right": return step(view, { yaw: -amount });
+        case "up": return step(view, { pitch: amount });
+        default: return step(view, { pitch: -amount });
+    }
+}
+/**
+ * The view after a drag of the pointer by (dx, dy) pixels, `degreesPerPixel` apart: the surface is taken hold of, so a drag to the right carries the side nearest the eye to the right (the
+ * yaw falls) and a drag down tips the top toward the eye (the pitch falls).
+ */
 export function drag(view, dx, dy, tilt = true, degreesPerPixel = 0.4) {
-    return clampView({ ...view, yaw: view.yaw + dx * degreesPerPixel, pitch: tilt ? view.pitch - dy * degreesPerPixel * 0.75 : view.pitch });
+    return clampView({ ...view, yaw: view.yaw - dx * degreesPerPixel, pitch: tilt ? view.pitch - dy * degreesPerPixel * 0.75 : view.pitch });
 }
 const RAD = Math.PI / 180;
 /** Where a point of the scene falls on the screen, in pixels from the middle of the container, when the scene is placed as given and the eye is `distance` pixels away. */
@@ -105,24 +121,54 @@ export function covered(b, view, at, distance) {
     const shown = corners(b).map((c) => project(c, view, at, distance));
     return { x0: Math.min(...shown.map((p) => p[0])), x1: Math.max(...shown.map((p) => p[0])), y0: Math.min(...shown.map((p) => p[1])), y1: Math.max(...shown.map((p) => p[1])) };
 }
+/** The turns the fit looks at: the whole circle in steps of five degrees. The pad round the scene is many times the little the extent can grow between two of them (a tenth of a percent). */
+const FIT_YAWS = Array.from({ length: 72 }, (_, i) => i * 5);
+/** The rectangle on the screen that a box covers over every turn of the circle, at this pitch. */
+function coveredAround(b, pitch, at, distance) {
+    const all = corners(b);
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let x1 = -Infinity;
+    let y1 = -Infinity;
+    for (const yaw of FIT_YAWS) {
+        for (const c of all) {
+            const [x, y] = project(c, { yaw, pitch, zoom: 1 }, at, distance);
+            if (x < x0)
+                x0 = x;
+            if (x > x1)
+                x1 = x;
+            if (y < y0)
+                y0 = y;
+            if (y > y1)
+                y1 = y;
+        }
+    }
+    return { x0, y0, x1, y1 };
+}
+let lastFit;
 /**
- * The placement that fits the scene in a container of width `w` and height `h` pixels, centred, with `pad` of its width and height left round it. The
- * perspective bends the sum, so it is found by a few rounds of scaling and re-centring; six is plenty.
+ * The placement that fits the scene in a container of width `w` and height `h` pixels, centred, with `pad` of its width and height left round it. It fits the scene at every turn about the
+ * vertical at the view's pitch, not at the view's own turn (its `yaw` is not used): the scale and the place are one for the whole circle, so that turning never zooms in and out or sways, and
+ * nothing is cut off at any angle. (A turn used to fit each angle alone, so a long floor was drawn up to 1.8 times as large side-on as end-on.) Tipping the view still rescales it, since the
+ * extent of the scene on the screen changes with the pitch. The perspective bends the sum, so it is found by a few rounds of scaling and re-centring; six is plenty.
  */
 export function fit(b, view, w, h, distance, pad = 0.03) {
+    const key = `${b.x0},${b.y0},${b.x1},${b.y1},${b.z0},${b.z1}|${view.pitch}|${w}|${h}|${distance}|${pad}`;
+    if (lastFit?.key === key)
+        return { ...lastFit.at };
     const at = { k: 0.5, tx: 0, ty: 0 };
-    const flat = { ...view, zoom: 1 };
     for (let i = 0; i < 8; i += 1) {
-        const r = covered(b, flat, at, distance);
+        const r = coveredAround(b, view.pitch, at, distance);
         const cw = r.x1 - r.x0;
         const ch = r.y1 - r.y0;
         if (cw <= 0 || ch <= 0)
             break;
         at.k *= Math.min((w * (1 - 2 * pad)) / cw, (h * (1 - 2 * pad)) / ch);
-        const c = covered(b, flat, at, distance);
+        const c = coveredAround(b, view.pitch, at, distance);
         at.tx -= (c.x0 + c.x1) / 2;
         at.ty -= (c.y0 + c.y1) / 2;
     }
+    lastFit = { key, at: { ...at } };
     return at;
 }
 /** Two matrices as one: `b` first, then `a`. */

package/dist/turn.dom.js

@@ -3,7 +3,7 @@
 // reduced motion gets jumps for glides, and where the browser cannot draw in 3D the flat drawing stays. Nothing is polled and nothing runs while the view is
 // still: the elements' `transform`s are written when the view changes, and a glide between viewpoints is a short run of animation frames.
 import { drawKyogijo } from "./draw.js";
-import { STEP, TURN_PRESET_NAMES, clampView, drag, nearest, presetOf, presetView, step } from "./turn.camera.js";
+import { STEP, TURN_PRESET_NAMES, clampView, drag, nearest, nudge, presetOf, presetView, step } from "./turn.camera.js";
 import { buildTurn, floorOptions, openingView, turnWords } from "./turn.model.js";
 import { controlsMarkup, layoutOf, turnMarkupOf, worldMarkup } from "./turn.markup.js";
 import { KYOGIJO_TURN_STYLE } from "./turn.style.js";
@@ -182,10 +182,11 @@ export function mountKyogijoTurn(host, options, settings = {}) {
             return toPreset(name);
         const big = event.shiftKey === true;
         switch (target.dataset.act) {
-            case "turn-left": return go(step(view, { yaw: -(big ? STEP.yawBig : STEP.yaw * 2) }), 180);
-            case "turn-right": return go(step(view, { yaw: big ? STEP.yawBig : STEP.yaw * 2 }), 180);
-            case "raise": return go(step(view, { pitch: -(big ? STEP.pitchBig : STEP.pitch * 2) }), 180);
-            case "lower": return go(step(view, { pitch: big ? STEP.pitchBig : STEP.pitch * 2 }), 180);
+            // The buttons take the surface toward their side as a drag and the arrow keys do.
+            case "turn-left": return go(nudge(view, "left", big ? STEP.yawBig : STEP.yaw * 2), 180);
+            case "turn-right": return go(nudge(view, "right", big ? STEP.yawBig : STEP.yaw * 2), 180);
+            case "raise": return go(nudge(view, "up", big ? STEP.pitchBig : STEP.pitch * 2), 180);
+            case "lower": return go(nudge(view, "down", big ? STEP.pitchBig : STEP.pitch * 2), 180);
             case "zoom-in": return go(step(view, { zoom: STEP.zoom }), 180, "none");
             case "zoom-out": return go(step(view, { zoom: 1 / STEP.zoom }), 180, "none");
             case "reset": return toOpening();
@@ -202,10 +203,11 @@ export function mountKyogijoTurn(host, options, settings = {}) {
         const pitch = big ? STEP.pitchBig : STEP.pitch;
         event.preventDefault();
         switch (event.key) {
-            case "ArrowLeft": return go(step(view, { yaw: -yaw }), 120);
-            case "ArrowRight": return go(step(view, { yaw }), 120);
-            case "ArrowUp": return go(step(view, { pitch: -pitch }), 120);
-            case "ArrowDown": return go(step(view, { pitch }), 120);
+            // A key takes the surface toward its side as a drag toward that side does: the side nearest the eye goes to the right on ArrowRight, and ArrowUp tips it as a drag up does.
+            case "ArrowLeft": return go(nudge(view, "left", yaw), 120);
+            case "ArrowRight": return go(nudge(view, "right", yaw), 120);
+            case "ArrowUp": return go(nudge(view, "up", pitch), 120);
+            case "ArrowDown": return go(nudge(view, "down", pitch), 120);
             case "+":
             case "=": return go(step(view, { zoom: STEP.zoom }), 120, "none");
             case "-":

package/dist/turn.kit.d.ts

@@ -1,7 +1,7 @@
 /** A point or a direction: x, y, z in feet. */
 export type V3 = readonly [number, number, number];
 /** What a plane is a part of: it is the class of its element (`ky-up-<kind>`) and what a test finds it by. */
-export type PartKind = "post" | "net" | "tape" | "antenna" | "board" | "glass" | "rim" | "stanchion" | "frame" | "goal" | "flag" | "stump" | "leg" | "table" | "pylon" | "wall" | "screen" | "pole" | "ground";
+export type PartKind = "post" | "net" | "tape" | "antenna" | "board" | "glass" | "rim" | "stanchion" | "frame" | "goal" | "flag" | "stump" | "leg" | "table" | "pylon" | "wall" | "screen" | "pole" | "ground" | "target";
 /** One flat rectangle. Its own x runs along `u` (its whole length) and its own y along `v`; `o` is the corner both start from. `svg` is what is drawn on it, in feet along `u` and `v`. */
 export interface Plane {
     /** A name that says what it is and where: `net`, `post-left`, `goal-right-back`. */
@@ -23,7 +23,7 @@ export interface Plane {
     shy?: readonly [number, number];
 }
 /** What stands on the surface as a thing a reader would name: a net, a basket, a goal, a pair of posts. */
-export type UprightKind = "scoreboard" | "net" | "antennae" | "goalposts" | "netposts" | "hoop" | "goal" | "boards" | "stumps" | "pylons" | "flags" | "fence" | "backstop" | "foul-poles" | "table-legs" | "walls" | "starting-blocks" | "backstroke-flags" | "false-start-rope" | "springboards" | "platforms" | "judges-stand" | "hurdles" | "steeplechase" | "high-jump" | "pole-vault" | "cage" | "padding" | "rink-boards";
+export type UprightKind = "scoreboard" | "net" | "antennae" | "goalposts" | "netposts" | "hoop" | "goal" | "boards" | "stumps" | "pylons" | "flags" | "fence" | "backstop" | "foul-poles" | "table-legs" | "walls" | "starting-blocks" | "backstroke-flags" | "false-start-rope" | "springboards" | "platforms" | "judges-stand" | "hurdles" | "steeplechase" | "high-jump" | "pole-vault" | "cage" | "padding" | "rink-boards" | "mound" | "azuchi" | "targets";
 /** A thing that stands on the surface: where, how high, and the planes it is made of. */
 export interface Upright {
     id: string;

package/dist/turn.style.js

@@ -3,9 +3,9 @@
  * defaults are in `:where()`, which has no weight, so a page's own rule always wins; the colours are custom properties (`--ky-up-*`) a page can set.
  */
 export const KYOGIJO_TURN_STYLE = `
-:where(.ky-turn){--ky-up-sbframe:#1a1f1c;--ky-up-sbedge:#5b645e;--ky-up-sbline:#59615b;--ky-up-pole:#e9e7de;--ky-up-white:#f6f4ec;--ky-up-yellow:#f2c230;--ky-up-red:#c8372d;--ky-up-orange:#f26a1b;--ky-up-wood:#e3d4b4;--ky-up-leg:#474e49;--ky-up-pad:#2f6db0;--ky-up-table:#18243f;--ky-up-foot:rgba(0,0,0,.25);--ky-up-ground:#d9d5c7;--ky-up-wall:#2f4a36;--ky-up-cap:#1d2a22;--ky-up-board:#ece9df;--ky-up-glass:rgba(138,190,232,.26);--ky-up-backboard:rgba(255,255,255,.88);--ky-up-outline:#f2f0e6;--ky-up-rim:#e8591a;--ky-up-mesh:rgba(24,30,27,.7);--ky-up-netfill:rgba(255,255,255,.2);--ky-up-tape:#fbfaf4;--ky-turn-bg:transparent;--ky-turn-ink:#1f2320;--ky-turn-rule:rgba(31,35,32,.22);--ky-turn-chip:rgba(255,255,255,.86);--ky-turn-chip-on:#1f2320;--ky-turn-chip-on-ink:#fff}
-@media (prefers-color-scheme:dark){:where(html:not([data-theme=light]) .ky-turn:not([data-theme=light])){--ky-up-sbframe:#0c0f0d;--ky-up-sbedge:#7a847d;--ky-up-sbline:#8a928c;--ky-up-pole:#d6d4ca;--ky-up-white:#e8e6dc;--ky-up-wood:#a89873;--ky-up-leg:#8a928c;--ky-up-ground:#242823;--ky-up-wall:#4d6b55;--ky-up-cap:#c9d2cc;--ky-up-board:#8d928b;--ky-up-glass:rgba(150,200,240,.2);--ky-up-backboard:rgba(255,255,255,.34);--ky-up-outline:#e7e4d8;--ky-up-mesh:rgba(236,236,226,.62);--ky-up-netfill:rgba(255,255,255,.08);--ky-up-tape:#efede2;--ky-turn-ink:#ece8dc;--ky-turn-rule:rgba(236,232,220,.28);--ky-turn-chip:rgba(24,28,25,.82);--ky-turn-chip-on:#ece8dc;--ky-turn-chip-on-ink:#1f2320}}
-:where(html[data-theme=dark] .ky-turn,.ky-turn[data-theme=dark]){--ky-up-sbframe:#0c0f0d;--ky-up-sbedge:#7a847d;--ky-up-sbline:#8a928c;--ky-up-pole:#d6d4ca;--ky-up-white:#e8e6dc;--ky-up-wood:#a89873;--ky-up-leg:#8a928c;--ky-up-ground:#242823;--ky-up-wall:#4d6b55;--ky-up-cap:#c9d2cc;--ky-up-board:#8d928b;--ky-up-glass:rgba(150,200,240,.2);--ky-up-backboard:rgba(255,255,255,.34);--ky-up-outline:#e7e4d8;--ky-up-mesh:rgba(236,236,226,.62);--ky-up-netfill:rgba(255,255,255,.08);--ky-up-tape:#efede2;--ky-turn-ink:#ece8dc;--ky-turn-rule:rgba(236,232,220,.28);--ky-turn-chip:rgba(24,28,25,.82);--ky-turn-chip-on:#ece8dc;--ky-turn-chip-on-ink:#1f2320}
+:where(.ky-turn){--ky-up-sbframe:#1a1f1c;--ky-up-sbedge:#5b645e;--ky-up-sbline:#59615b;--ky-up-pole:#e9e7de;--ky-up-white:#f6f4ec;--ky-up-yellow:#f2c230;--ky-up-red:#c8372d;--ky-up-orange:#f26a1b;--ky-up-wood:#e3d4b4;--ky-up-leg:#474e49;--ky-up-pad:#2f6db0;--ky-up-table:#18243f;--ky-up-foot:rgba(0,0,0,.25);--ky-up-ground:#d9d5c7;--ky-up-wall:#2f4a36;--ky-up-clay:#a8703f;--ky-up-cap:#1d2a22;--ky-up-board:#ece9df;--ky-up-glass:rgba(138,190,232,.26);--ky-up-backboard:rgba(255,255,255,.88);--ky-up-outline:#f2f0e6;--ky-up-rim:#e8591a;--ky-up-mesh:rgba(24,30,27,.7);--ky-up-netfill:rgba(255,255,255,.2);--ky-up-tape:#fbfaf4;--ky-turn-bg:transparent;--ky-turn-ink:#1f2320;--ky-turn-rule:rgba(31,35,32,.22);--ky-turn-chip:rgba(255,255,255,.86);--ky-turn-chip-on:#1f2320;--ky-turn-chip-on-ink:#fff}
+@media (prefers-color-scheme:dark){:where(html:not([data-theme=light]) .ky-turn:not([data-theme=light])){--ky-up-sbframe:#0c0f0d;--ky-up-sbedge:#7a847d;--ky-up-sbline:#8a928c;--ky-up-pole:#d6d4ca;--ky-up-white:#e8e6dc;--ky-up-wood:#a89873;--ky-up-leg:#8a928c;--ky-up-ground:#242823;--ky-up-wall:#4d6b55;--ky-up-clay:#7d5231;--ky-up-cap:#c9d2cc;--ky-up-board:#8d928b;--ky-up-glass:rgba(150,200,240,.2);--ky-up-backboard:rgba(255,255,255,.34);--ky-up-outline:#e7e4d8;--ky-up-mesh:rgba(236,236,226,.62);--ky-up-netfill:rgba(255,255,255,.08);--ky-up-tape:#efede2;--ky-turn-ink:#ece8dc;--ky-turn-rule:rgba(236,232,220,.28);--ky-turn-chip:rgba(24,28,25,.82);--ky-turn-chip-on:#ece8dc;--ky-turn-chip-on-ink:#1f2320}}
+:where(html[data-theme=dark] .ky-turn,.ky-turn[data-theme=dark]){--ky-up-sbframe:#0c0f0d;--ky-up-sbedge:#7a847d;--ky-up-sbline:#8a928c;--ky-up-pole:#d6d4ca;--ky-up-white:#e8e6dc;--ky-up-wood:#a89873;--ky-up-leg:#8a928c;--ky-up-ground:#242823;--ky-up-wall:#4d6b55;--ky-up-clay:#7d5231;--ky-up-cap:#c9d2cc;--ky-up-board:#8d928b;--ky-up-glass:rgba(150,200,240,.2);--ky-up-backboard:rgba(255,255,255,.34);--ky-up-outline:#e7e4d8;--ky-up-mesh:rgba(236,236,226,.62);--ky-up-netfill:rgba(255,255,255,.08);--ky-up-tape:#efede2;--ky-turn-ink:#ece8dc;--ky-turn-rule:rgba(236,232,220,.28);--ky-turn-chip:rgba(24,28,25,.82);--ky-turn-chip-on:#ece8dc;--ky-turn-chip-on-ink:#1f2320}
 .ky-turn{position:relative;display:block;width:100%;color:var(--ky-turn-ink);font-family:var(--ky-font,system-ui,-apple-system,"Segoe UI","Hiragino Sans","Noto Sans JP",sans-serif);background:var(--ky-turn-bg)}
 .ky-turn-view{position:relative;isolation:isolate;width:100%;aspect-ratio:var(--ky-turn-ratio,16/10);min-height:260px;overflow:hidden;touch-action:pan-y;cursor:grab;user-select:none;-webkit-user-select:none;-webkit-tap-highlight-color:transparent;border-radius:12px;outline-offset:2px}
 .ky-turn[data-touch=turn] .ky-turn-view{touch-action:none}
@@ -30,6 +30,7 @@ export const KYOGIJO_TURN_STYLE = `
 .ky-turn .u-foot{fill:var(--ky-up-foot)}
 .ky-turn .u-ground{fill:var(--ky-up-ground)}
 .ky-turn .u-wall{fill:var(--ky-up-wall)}
+.ky-turn .u-clay{fill:var(--ky-up-clay)}
 .ky-turn .u-cap{fill:var(--ky-up-cap)}
 .ky-turn .u-board{fill:var(--ky-up-board)}
 .ky-turn .u-glass{fill:var(--ky-up-glass)}

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import type { Background } from "./background.ts";
+import type { EmblemRef, EmblemRenderer } from "./emblems-source.ts";
 import type { Layer } from "./layers.types.ts";
 import type { Unit } from "./units.ts";
 import type { SoccerFrame, SoccerProviderId } from "./surfaces/soccer-providers.ts";
@@ -7,11 +8,16 @@ import type { Frame } from "./frames.ts";
 import type { PoolSport, PoolStyle } from "./pool.types.ts";
 import type { AthleticsStyle } from "./athletics/types.ts";
 import type { SkatingStyle } from "./skating/types.ts";
+import type { Situation } from "./situation.types.ts";
+import type { BudoStyle, DojoSpec, BudoScore } from "./budo/types.ts";
 /** The field sports: lacrosse (the field and the box), rugby (union and league), Australian football, Gaelic football and hurling, cricket, field hockey and team handball. */
 export type FieldSport = "lacrosse" | "rugby" | "afl" | "gaelic" | "cricket" | "fieldhockey" | "handball";
 export type { PoolSport, PoolStyle };
+/** The budō: the contest areas of judo and karate, the kendo shiai-jo, the sumo dohyō, the kyūdōjō, and a dojo of tatami. */
+export type BudoSport = "judo" | "karate" | "kendo" | "sumo" | "kyudo" | "dojo";
+export type { BudoStyle, DojoSpec, BudoScore };
 /** The surfaces: three football fields, a rink, a court, a ballpark, a soccer pitch, a curling sheet, twelve net, racket and court sports (tennis, volleyball, badminton, pickleball, table tennis, padel, squash, racquetball, sepak takraw, teqball, roundnet and netball), four pools (swimming, water polo, diving and artistic swimming), seven field sports (lacrosse, rugby, Australian football, Gaelic football and hurling, cricket, field hockey and handball) and the athletics stadium (the 400 m track with its infield, and the covered 200 m track). */
-export type Sport = "nfl" | "cfl" | "ifaf" | "nhl" | "nba" | "mlb" | "soccer" | "curling" | "tennis" | "volleyball" | "badminton" | "pickleball" | "tabletennis" | "padel" | "squash" | "racquetball" | "sepaktakraw" | "teqball" | "roundnet" | "netball" | PoolSport | FieldSport | "athletics" | "skating";
+export type Sport = "nfl" | "cfl" | "ifaf" | "nhl" | "nba" | "mlb" | "soccer" | "curling" | "tennis" | "volleyball" | "badminton" | "pickleball" | "tabletennis" | "padel" | "squash" | "racquetball" | "sepaktakraw" | "teqball" | "roundnet" | "netball" | PoolSport | FieldSport | "athletics" | "skating" | BudoSport;
 /** `auto` follows the device's light or dark setting (and `data-theme` on the page's root), the others force one. */
 export type Theme = "auto" | "light" | "dark";
 /** The language of the words the drawing says itself: its title, its description and its status labels. */
@@ -310,9 +316,9 @@ export interface CrowdOptions {
  * The parts of a surface a drawing can be cropped to (`range`). Football: `red-zone`, `between-the-20s`, `end-zone`, `field-of-play`, `own-half`, `opponent-half`.
  * Hockey: `offensive-zone`, `defensive-zone`, `neutral-zone`, `half`. Basketball: `half-court`, `paint`. Soccer: `half`, `final-third`, `defensive-third`, `middle-third`,
  * `penalty-area`. Baseball: `infield`, `outfield`. The net sports: `half-court`. Curling: `sheet`, `half`, `house`, `folded`. Rugby: `half`, `twenty-two` (union) or `twenty` (league), `in-goal`. Lacrosse: `half`, `crease`. Australian football: `half`, `forward-fifty`, `centre-square`.
- * Gaelic games: `half`, `large-rectangle`. Cricket: `pitch`, `circle`. Field hockey: `half`, `circle`, `twenty-three`. Handball: `half`, `goal-area`. Swimming: `half`, `pool-end`. Water polo: `half`, `goal-area`. Diving: `springboards`, `platforms`. Artistic swimming: `half`, `centre-stage`. Athletics: `bend`, `home-straight`, `back-straight`, `finish`, `start`, `infield`, a field event (`high-jump`, `pole-vault`, `long-jump`, `triple-jump`, `shot-put`, `discus-throw`, `hammer-throw`, `javelin-throw`) and `water-jump`. `RANGES` lists them for each sport.
+ * Gaelic games: `half`, `large-rectangle`. Cricket: `pitch`, `circle`. Field hockey: `half`, `circle`, `twenty-three`. Handball: `half`, `goal-area`. Swimming: `half`, `pool-end`. Water polo: `half`, `goal-area`. Diving: `springboards`, `platforms`. Artistic swimming: `half`, `centre-stage`. Judo and karate: `contest-area`, `start`. Sumo: `ring`. Kyudo: `shajo`, `yamichi`, `azuchi`. Dojo: `kamiza`, `half`. Athletics: `bend`, `home-straight`, `back-straight`, `finish`, `start`, `infield`, a field event (`high-jump`, `pole-vault`, `long-jump`, `triple-jump`, `shot-put`, `discus-throw`, `hammer-throw`, `javelin-throw`) and `water-jump`. `RANGES` lists them for each sport.
  */
-export type RangeName = "red-zone" | "between-the-20s" | "end-zone" | "field-of-play" | "own-half" | "opponent-half" | "offensive-zone" | "defensive-zone" | "neutral-zone" | "half" | "half-court" | "paint" | "final-third" | "defensive-third" | "middle-third" | "penalty-area" | "infield" | "outfield" | "sheet" | "house" | "folded" | "in-goal" | "twenty-two" | "twenty" | "crease" | "forward-fifty" | "centre-square" | "large-rectangle" | "pitch" | "circle" | "twenty-three" | "goal-area" | "pool-end" | "springboards" | "platforms" | "centre-stage" | "bend" | "home-straight" | "back-straight" | "finish" | "start" | "infield" | "high-jump" | "pole-vault" | "long-jump" | "triple-jump" | "shot-put" | "discus-throw" | "hammer-throw" | "javelin-throw" | "water-jump" | "crossing-straight" | "first-bend" | "second-bend" | "judges" | "kiss-and-cry";
+export type RangeName = "red-zone" | "between-the-20s" | "end-zone" | "field-of-play" | "own-half" | "opponent-half" | "offensive-zone" | "defensive-zone" | "neutral-zone" | "half" | "half-court" | "paint" | "final-third" | "defensive-third" | "middle-third" | "penalty-area" | "infield" | "outfield" | "sheet" | "house" | "folded" | "in-goal" | "twenty-two" | "twenty" | "crease" | "forward-fifty" | "centre-square" | "large-rectangle" | "pitch" | "circle" | "twenty-three" | "goal-area" | "pool-end" | "springboards" | "platforms" | "centre-stage" | "bend" | "home-straight" | "back-straight" | "finish" | "start" | "infield" | "high-jump" | "pole-vault" | "long-jump" | "triple-jump" | "shot-put" | "discus-throw" | "hammer-throw" | "javelin-throw" | "water-jump" | "crossing-straight" | "first-bend" | "second-bend" | "judges" | "kiss-and-cry" | "contest-area" | "ring" | "shajo" | "yamichi" | "azuchi" | "kamiza";
 /** A named range at the end of your choice: `{ name: "offensive-zone", end: "left" }` is the offensive zone of a team that attacks the left. */
 export interface RangeNamed {
     name: RangeName;
@@ -447,8 +453,8 @@ export interface PageantOptions {
     lines?: "over" | "under" | "through";
     /** A stage's ring: `gold` (the default), `team` (each team's colour), or a colour. */
     ring?: "gold" | "team" | (string & {});
-    /** The picture in the centre circle, centre ice, centre court or at the mound: a competition's emblem or a trophy, as a logo is given (an address, an image `data:` address or an SVG document as text). Yours; none is supplied. */
-    emblem?: string;
+    /** The picture in the centre circle, centre ice, centre court or at the mound: a competition's emblem or a trophy, as a logo is given (an address, an image `data:` address, an SVG document as text, or, with a renderer of emblems plugged in, the id of one: `"trophy:hockey-cup"`). Yours; none is supplied. */
+    emblem?: EmblemRef;
     /** `round` (the default): the emblem on a disc with a ring, as a team's mark. `plain`: the picture as it is, for a trophy with a cut-out outline. */
     emblemShape?: "round" | "plain";
     /** An emblem's fit on its disc: `contain` (the default: shown whole) or `cover` (it fills the disc). */
@@ -478,8 +484,8 @@ export interface Team {
     abbr?: string;
     /** The score. A number, or text such as "–" before the game. */
     score?: number | string;
-    /** The logo: an `https:` or relative address, an image `data:` address, or an SVG document as text. */
-    logo?: string;
+    /** The logo: an `https:` or relative address, an image `data:` address, an SVG document as text, or, with a renderer of emblems plugged in (`useEmblems`), the id of a ready-made emblem: `"crest:shield"` takes the team's `color`, `textColor` and `abbr`. */
+    logo?: EmblemRef;
     /**
      * How the logo is drawn: `round` clips it to a circle with a thin ring (a flag, or a crest) and, for a team with no logo, draws its initials on its colour; `plain` is the
      * logo as it is, in a box. The score's `markShape` is the default for both teams.
@@ -510,6 +516,8 @@ export interface Team {
     wickets?: number | string;
     overs?: number | string;
     innings?: readonly (number | string | null | undefined)[];
+    /** Judo, karate, kendo and sumo: what the team has scored, as the sport counts it (see `BudoScore`). */
+    budo?: BudoScore;
     /** The team's colour, for its end, key or dugout. */
     color?: string;
     /** The colour of the words on that colour. Black or white by the colour's lightness when missing. */
@@ -558,6 +566,8 @@ export interface SurfaceOptions {
     description?: string;
     /** A prefix for the ids inside the drawing. Made from the options when missing, so that the same call gives the same drawing. */
     id?: string;
+    /** A renderer of ready-made emblems for this drawing alone, so that a `logo`, an `emblem` or a mark may be an emblem's id: `emblems: renderEmblem` from `@johnmorrisdotca/dougu-sports/emblems`. Over the one the page plugged in with `useEmblems`. */
+    emblems?: EmblemRenderer;
     /** The ground to draw round the playing surface, in `units` (feet by default). A default for each sport. */
     margin?: number;
     /**
@@ -635,10 +645,16 @@ export interface SurfaceOptions {
     athletics?: AthleticsStyle;
     /** The skating rink: the long track's radius and lanes, the short track's tracks, the figure skating rink's size and furniture, the races marked. See `SkatingStyle`; the discipline is the `league`. */
     skating?: SkatingStyle;
+    /** The budō surfaces (judo, karate, kendo, sumo, kyudo): the size of the area, the marks, the number of areas, the look. See `BudoStyle`; the rulebook is the `league`. */
+    budo?: BudoStyle;
+    /** A dojo of tatami (`sport: "dojo"`): the mats, the pattern, the walls, the kamiza. See `DojoSpec` and `dojo()`. */
+    dojo?: DojoSpec;
     /** The soccer pitch: a preset (`fifa`, `uefa`, `mls`, `nwsl`, `ncaa`, `law-min`, `law-max`, `9-a-side`, `7-a-side`, `5-a-side`, `futsal`) or a size, `{ length, width, unit }`. The international 105 by 68 m by default. */
     pitch?: SoccerPitchId | SoccerSize;
     /** The soccer ground to draw: a key of `GROUNDS`. The pitch has the size its article publishes (the international 105 by 68 m where none is), and the drawing carries the ground's name for `year`. A `pitch` of your own wins over the ground's size. */
     ground?: string;
+    /** The arena to draw an NHL rink or an NBA court of: a key of `ARENAS`. The rink or the court has the size its sources publish where that differs from the league's (the league's where none does), the markings are those of `year`, and the drawing carries the arena's name for `year`. A `league` of your own wins over the arena's size. */
+    arena?: string;
     /** Draw a soccer pitch in a data provider's own coordinates (`opta`, `statsbomb`, `wyscout`, `tracab`, `metrica`, `skillcorner`, `secondspectrum`, `impect`, `uefa`, `international`), or in a frame of your own: the lines stand where the provider puts them, and an empty `ky-data` group in its units is put in the drawing for raw data. */
     pitchType?: SoccerProviderId | SoccerFrame;
     /** Only half of a soccer pitch: the `left` half or the `right` one. Ignored when the drawing has teams. `range: "half"` does the same for every sport and for a score too. */
@@ -689,6 +705,20 @@ export interface SurfaceOptions {
      * under a score's panel), cut to the surface's outline, and described in the drawing's description. See `drawLayers` and `layerTable`.
      */
     layers?: readonly Layer[];
+    /**
+     * Write what `clientPointToField` (the `pointer` entry) needs on the drawing's surface group: the box of the playing surface and the options that decide its rules (the league, the
+     * season, the park, the pitch). Off by default, so that a drawing without data is the same text as ever; a page that asks where a click is turns it on.
+     */
+    pointer?: boolean;
+    /** Write `data-mark-id`, `data-index` and `data-zone` on every mark of every data layer, for one listener to link a mark to a table (about 55 bytes a mark). Off by default; a layer whose data has an `id` has them anyway, and `pointer: true` turns them on. */
+    marks?: boolean;
+    /**
+     * The situation of the game, drawn on the surface, in the badge and in the compact card: hockey's skaters (a power play or an empty net as a pill, the attacking zone tinted) and its
+     * shootout as a strip of dots across centre ice; baseball's runners (the bases lit), outs, inning and count (a scorebug in the badge); football's down and distance (the line of scrimmage
+     * in blue, the first-down line in yellow, the red zone tinted, a tag) and a drive chart. For `nhl`, `mlb`, and the football fields; any other sport, and a special game, draws none.
+     * Off by default, and then the drawing is byte for byte as it was. See `docs/situation.md`.
+     */
+    situation?: Situation;
     /** `embed` (the default) writes the stylesheet into the drawing so that it stands alone; `none` leaves it to the page. */
     style?: "embed" | "none";
     /** An extra class on the `svg`. */
@@ -725,6 +755,12 @@ export interface ScoreOptions extends SurfaceOptions {
     uppercase?: boolean;
     /** The shape of both teams' marks, unless a team's own `mark` says otherwise: `plain` (the default) or `round`, a flag or logo in a circle with a ring. */
     markShape?: TeamMark;
+    /**
+     * Where the score goes: `centre` (the panel stands on the middle of the surface), `strip` (the compact strip under the drawing, as a pageant's `score: "strip"` does) or `auto` (the default:
+     * the centre, unless the drawing has a `lineup` layer, whose players the panel would hide, and then the strip). The strip also carries the situation's pill, scorebug or tag, which a drawing
+     * with a lineup then leaves off the surface. A pageant has its own `pageant.score`, which says it for the drawing.
+     */
+    score?: "auto" | "centre" | "strip";
     /** Draw the score's panel (or board) on the surface. On by default; `false` leaves the teams' names and the rest and no panel, as the 3D view does when it hangs the score up as a scoreboard. */
     plate?: boolean;
 }

package/dist/units.js

@@ -49,6 +49,13 @@ export const SURFACE_UNITS = Object.freeze({
     artisticswimming: "m",
     athletics: "m",
     skating: "m",
+    // The budō: the federations print their figures in metres (the kyūdōjō's and the dohyō's too), and a dojo is counted in mats of metres.
+    judo: "m",
+    karate: "m",
+    kendo: "m",
+    sumo: "m",
+    kyudo: "m",
+    dojo: "m",
 });
 /** True when `unit` is one of the six. */
 export const isUnit = (unit) => typeof unit === "string" && Object.prototype.hasOwnProperty.call(FEET_PER, unit);

package/dist/uprights.budo.d.ts

@@ -0,0 +1,17 @@
+import { type Upright } from "./turn.kit.ts";
+import type { SurfaceOptions } from "./types.ts";
+/** What the 3D view makes of a budō surface: the things that stand, how high the surface itself stands, and the box the view is fitted to. */
+export interface BudoUprights {
+    items: Upright[];
+    lift: number;
+    area: {
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+    };
+}
+/** The walls of a dojo, 3 m high (ours). */
+export declare const DOJO_WALL = 3;
+/** What stands on the budō surface the options draw. */
+export declare function budoUprights(o: Pick<SurfaceOptions, "sport" | "league" | "budo" | "dojo" | "detail">, thin: number): BudoUprights;

package/dist/uprights.budo.js

@@ -0,0 +1,87 @@
+// What stands on a budō surface, in 3D: the dohyō's clay mound (the clay square stands 34 cm to 60 cm over the floor of the hall, Sumo Rules, Dohyō Regulations, Article 1), the azuchi of a kyūdōjō with the
+// targets on it (36 cm across and 27 cm over the mound's base, tilted 5 degrees; 100 cm, 97 cm and 15 degrees for enteki), and the walls of a dojo. A judo, karate or kendo surface lies flat: nothing stands on it
+// (a judo platform's height is not in the rules: "it depends on the sightlines"). The plans are in metres in the frame of their own origin, and the drawing's frame is feet from the corner of the plan's
+// box, so every point goes through `at`. The mound's height is the option's; the azuchi's (1.5 m or 1.8 m) and a dojo wall's (3 m) are ours: no rule gives them.
+import { budoPlan } from "./budo/plan.js";
+import { n, plane, shy, wall } from "./turn.kit.js";
+const K = 1 / 0.3048;
+/** The walls of a dojo, 3 m high (ours). */
+export const DOJO_WALL = 3;
+/** The planes of the dohyō's clay mound: its four sides, from the floor of the hall up to the clay. */
+function moundPlanes(plan, at, height) {
+    const L = plan.sumo;
+    if (L === undefined)
+        return [];
+    const b = L.platform;
+    const corners = [at(b.x0, b.y0), at(b.x1, b.y0), at(b.x1, b.y1), at(b.x0, b.y1)];
+    const planes = [];
+    corners.forEach((a, i) => {
+        const c = corners[(i + 1) % 4];
+        planes.push(wall(`mound-${i + 1}`, "wall", a[0], a[1], c[0], c[1], 0, height, `<rect width="${n(Math.hypot(c[0] - a[0], c[1] - a[1]))}" height="${n(height)}" class="u-clay"/>`));
+    });
+    return planes;
+}
+/** The azuchi's face, a slope from the foot of the mound up to its top, and the target of each shooter standing against it. */
+function azuchiPlanes(plan, at) {
+    const L = plan.kyudo;
+    if (L === undefined)
+        return { mound: [], targets: [], height: 0 };
+    const fig = plan.figures;
+    const h = fig.azuchi.height * K;
+    const a = L.azuchi;
+    // The face runs from the foot, in front of the target's line, up to the top at the target's line: a slope of about 50 degrees reaches 1.5 m in 1.26 m.
+    const run = (fig.azuchi.height / Math.tan((50 * Math.PI) / 180)) * K;
+    const [fx, fy0] = at(a.x0, a.y0);
+    const [, fy1] = at(a.x0, a.y1);
+    const topX = fx + run;
+    const mound = plane("azuchi-face", "wall", [topX, fy0, h], [0, fy1 - fy0, 0], [-run, 0, -h], `<rect width="${n(fy1 - fy0)}" height="${n(Math.hypot(run, h))}" class="u-clay"/>`);
+    const d = fig.target.diameter * K;
+    const tilt = (fig.target.tilt * Math.PI) / 180;
+    const centre = fig.target.centre * K;
+    const targets = L.lanes.map((y, i) => {
+        const [tx, ty] = at(L.target, y);
+        // The face leans back at the top: its top is further from the shooters than its bottom.
+        const top = [tx + (d / 2) * Math.sin(tilt), ty - d / 2, centre + (d / 2) * Math.cos(tilt)];
+        return plane(`target-${i + 1}`, "target", top, [0, d, 0], [-d * Math.sin(tilt), 0, -d * Math.cos(tilt)], `<circle cx="${n(d / 2)}" cy="${n(d / 2)}" r="${n(d / 2)}" class="u-white"/><circle cx="${n(d / 2)}" cy="${n(d / 2)}" r="${n(d * 0.33)}" class="u-outline" fill="none"/><circle cx="${n(d / 2)}" cy="${n(d / 2)}" r="${n(d * 0.16)}" class="u-outline" fill="none"/>`);
+    });
+    return { mound: [mound], targets, height: h };
+}
+/** What stands on the budō surface the options draw. */
+export function budoUprights(o, thin) {
+    const plan = budoPlan(o);
+    const ox = plan.box.x0;
+    const oy = plan.box.y0;
+    const at = (x, y) => [(x - ox) * K, (y - oy) * K];
+    const area = { x0: 0, y0: 0, x1: (plan.box.x1 - ox) * K, y1: (plan.box.y1 - oy) * K };
+    const items = [];
+    let lift = 0;
+    if (plan.sumo !== undefined) {
+        lift = plan.sumo.height * K;
+        items.push({ id: "mound", kind: "mound", at: at(plan.sumo.centre[0], plan.sumo.centre[1]), height: lift, planes: moundPlanes(plan, at, lift) });
+    }
+    if (plan.kyudo !== undefined) {
+        const built = azuchiPlanes(plan, at);
+        items.push({ id: "azuchi", kind: "azuchi", at: at(plan.kyudo.target, plan.kyudo.lanes[0]), height: built.height, planes: built.mound });
+        if (built.targets.length > 0)
+            items.push({ id: "targets", kind: "targets", at: at(plan.kyudo.target, plan.kyudo.lanes[0]), height: Math.max(...built.targets.map((p) => p.o[2])), planes: built.targets });
+    }
+    if (plan.dojo !== undefined && plan.dojo.wall > 0) {
+        const f = plan.dojo.room;
+        const h = DOJO_WALL * K;
+        const w = plan.dojo.wall;
+        const centre = [area.x1 / 2, area.y1 / 2];
+        const planes = [
+            [f.x0 - w / 2, f.y0 - w / 2, f.x1 + w / 2, f.y0 - w / 2],
+            [f.x1 + w / 2, f.y0 - w / 2, f.x1 + w / 2, f.y1 + w / 2],
+            [f.x1 + w / 2, f.y1 + w / 2, f.x0 - w / 2, f.y1 + w / 2],
+            [f.x0 - w / 2, f.y1 + w / 2, f.x0 - w / 2, f.y0 - w / 2],
+        ].map(([x0, y0, x1, y1], i) => {
+            const [a, b] = [at(x0, y0), at(x1, y1)];
+            const run = Math.hypot(b[0] - a[0], b[1] - a[1]);
+            return shy(wall(`wall-${i + 1}`, "wall", a[0], a[1], b[0], b[1], 0, h, `<rect width="${n(run)}" height="${n(h)}" class="u-wall"/>`), centre);
+        });
+        items.push({ id: "walls", kind: "walls", at: centre, height: h, planes });
+    }
+    void thin;
+    return { items, lift, area };
+}

package/dist/uprights.js

@@ -22,13 +22,15 @@ import { netUprights } from "./uprights.net.js";
 import { isPoolSport, poolPlan, feet as poolFeet } from "./pool.js";
 import { poolUprights } from "./uprights.pools.js";
 import { athleticsUprights, skatingUprights } from "./uprights.track.js";
+import { budoUprights } from "./uprights.budo.js";
+import { isBudoSport } from "./budo/plan.js";
 import { courtUprights, rinkUprights } from "./uprights.rinks.js";
 import { convertLength } from "./units.js";
 import { sheetFor } from "./sheet.js";
 /** All the planes of all the things. */
 export const planesOf = (u) => u.items.flatMap((item) => item.planes);
 /** The unit each sport's rulebook gives its heights in, when the options name none. */
-const RULEBOOK_UNIT = { volleyball: "m", badminton: "m", tabletennis: "m", padel: "m", squash: "m", athletics: "m", skating: "m", swimming: "m", waterpolo: "m", diving: "m", artisticswimming: "m", sepaktakraw: "m", teqball: "m", roundnet: "m", netball: "m", soccer: "m", handball: "m", fieldhockey: "m", rugby: "m", afl: "m", gaelic: "m" };
+const RULEBOOK_UNIT = { volleyball: "m", badminton: "m", tabletennis: "m", padel: "m", squash: "m", athletics: "m", skating: "m", judo: "m", karate: "m", kendo: "m", sumo: "m", kyudo: "m", dojo: "m", swimming: "m", waterpolo: "m", diving: "m", artisticswimming: "m", sepaktakraw: "m", teqball: "m", roundnet: "m", netball: "m", soccer: "m", handball: "m", fieldhockey: "m", rugby: "m", afl: "m", gaelic: "m" };
 /** What stands on the surface the options draw: nothing on a curling sheet, which is flat. */
 export function uprightsFor(o, settings = {}) {
     const { sport, league } = chooseLeague(o);
@@ -102,6 +104,13 @@ export function uprightsFor(o, settings = {}) {
         thin = thinnest(area.x1, area.y1);
         items = skatingUprights({ ...o, sport }, thin).items;
     }
+    else if (isBudoSport(sport)) {
+        const built = budoUprights({ ...o, sport }, 0.3);
+        area = built.area;
+        thin = thinnest(area.x1, area.y1);
+        items = budoUprights({ ...o, sport }, thin).items;
+        lift = built.lift;
+    }
     else if (isFieldSport(sport)) {
         const plan = fieldPlan({ ...o, sport });
         thin = thinnest(plan.length, plan.width);

package/dist/uprights.pools.js

@@ -1,5 +1,5 @@
 // What stands on the pools, in 3D: a swimming pool's starting blocks, its backstroke flag lines and its false start rope; a diving well's springboards and platforms on their stands; a water
-// polo field's two floating goals; an artistic swimming area's judges' stand and starting platform. The heights are World Aquatics' (the Competition Regulations in force from 25 June 2025):
+// polo field's two floating goals; an artistic swimming area's judges' stand and starting platform. The heights are World Aquatics' (the Competition Regulations in force from February 2026, bar the few figures `pool.figures.ts` marks as the June 2025 edition's):
 // docs/sources.md, "Heights in the 3D view", says which rule each comes from, and `pool.figures.ts` holds the figures. A plan is in metres and the drawing's frame in feet, with the pool's
 // top left corner for the origin and the water level for the floor, so every length goes through `feet`. What the rules leave to the maker (the thickness of a stand, a rope, the sides of a
 // box) is ours and is said so there.
@@ -79,7 +79,7 @@ function swimmingUprights(plan, thin) {
     }
     return items;
 }
-/** The two goals of a water polo field, floating on the goal lines: 3 m between the posts, the crossbar's underside 0.9 m over the water (CR 18.3.3), a net 0.30 m deep behind the line. */
+/** The two goals of a water polo field, floating on the goal lines: 3 m between the posts, the crossbar's underside 0.9 m over the water (Part Six 21.6.3.2 and 21.6.4.2), a net 0.30 m deep behind the line (21.6.5). */
 function poloUprights(plan, thin) {
     const { goal } = WATER_POLO;
     const g0 = goal.netClear;
@@ -106,7 +106,7 @@ function poloUprights(plan, thin) {
     return items;
 }
 /**
- * A diving well: each springboard 4.88 m long and 0.50 m wide at 1 m or 3 m, its plummet over the water, on a stand behind the wall (Appendix 2); each platform at its height of 1, 3, 5, 7.5 or 10 m with
+ * A diving well: each springboard 4.88 m long and 0.50 m wide at 1 m or 3 m, its plummet over the water, on a stand behind the wall (Part Four, Appendix 2); each platform at its height of 1, 3, 5, 7.5 or 10 m with
  * the length and width of the table, on a tower behind the wall. The stands and towers are ours: the rules give where the plummet is and not what holds the board up.
  */
 function diveUprights(plan) {
@@ -144,7 +144,7 @@ function diveUprights(plan) {
         items.push({ id: "platforms", kind: "platforms", at: [0, feet(plan.width) / 2], height: feet(tall("platform")), planes: platformPlanes });
     return items;
 }
-/** An artistic swimming area: the judges' platform along the top side, 0.6 m high (CR 27.2.8: at least 0.6 m, not more than 2 m from the edge), and the starting platform 0.7 m high (CR 27.2.7). */
+/** An artistic swimming area: the judges' platform along the top side, 0.6 m high (Part Seven 12.2.5: at least 0.6 m, not more than 2 m from the edge), and the starting platform 0.7 m high (Part Seven 12.2.4). */
 function artisticUprights(plan) {
     const { judges, start } = ARTISTIC.drawn;
     const L = plan.length;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** The package's version: the same as package.json's, and a test holds them to each other. */
-export declare const VERSION = "0.5.0";
+export declare const VERSION = "0.6.1";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** The package's version: the same as package.json's, and a test holds them to each other. */
-export const VERSION = "0.5.0";
+export const VERSION = "0.6.1";

package/dist/zones-entry.d.ts

@@ -0,0 +1,2 @@
+export { PARKS_WITHOUT_WALL_HEIGHTS, RULE_IDS, betweenHashes, homeRun, inCrease, inPaint, inPenaltyArea, inRedZone, inRestrictedArea, inSixYardBox, inSlot, isFair, isHomeRun, isThreePointer, onWarningTrack, overWall, wallHeightAt, zoneAt, zoneAtSurface, zoneName, zoneResolver } from "./rules.ts";
+export type { HomeRunOptions, HomeRunVerdict, PlaceLike, RuleId, ZoneAnswer, ZoneOptions } from "./rules.ts";

package/dist/zones-entry.js

@@ -0,0 +1,2 @@
+// The rulebook as code: where a point lies on a surface in the sport's own terms (the zone, the area in it, every other area that holds), and the yes-or-no questions a coach asks.
+export { PARKS_WITHOUT_WALL_HEIGHTS, RULE_IDS, betweenHashes, homeRun, inCrease, inPaint, inPenaltyArea, inRedZone, inRestrictedArea, inSixYardBox, inSlot, isFair, isHomeRun, isThreePointer, onWarningTrack, overWall, wallHeightAt, zoneAt, zoneAtSurface, zoneName, zoneResolver } from "./rules.js";