@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/heat.zones.js

@@ -11,6 +11,13 @@ import { fill } from "./strings.js";
 import { lengthUnit } from "./common.js";
 import { courtFor, courtSize } from "./court.js";
 import { fieldPlan } from "./fields.js";
+import { WATER_POLO } from "./pool.figures.js";
+import { swimPlan } from "./pool.js";
+import { athleticsLanes, athleticsLeague } from "./athletics/plan.js";
+import { skatingPlan } from "./skating/plan.js";
+import { budoPlan } from "./budo/plan.js";
+import { laneEdges } from "./skating/track.js";
+import { iceRadius } from "./skating/long.js";
 import { LEAGUES, chooseLeague, cricketOf } from "./leagues.js";
 /** Every zone set, with the sports it is for, the source of its definition and its title. */
 export const ZONE_SETS = Object.freeze({
@@ -24,8 +31,16 @@ export const ZONE_SETS = Object.freeze({
     "baseball-spray": { sports: ["mlb"], title: "Spray zones: pull, centre, opposite by infield and outfield", source: "docs/sources.md#zone-sets" },
     "baseball-retrosheet": { sports: ["mlb"], title: "Retrosheet hit locations as the nearest sector", source: "https://www.retrosheet.org/location.htm" },
     "curling-house": { sports: ["curling"], title: "The house: the button, the 4-, 8- and 12-foot rings, and the free guard zone", source: "docs/sources.md#zone-sets" },
-    "net-court": { sports: ["tennis", "volleyball", "badminton", "pickleball", "tabletennis"], title: "Each side of the net: the front court and the back court, split by the court's own line", source: "docs/sources.md#zone-sets" },
-    "field-thirds": { sports: ["lacrosse", "rugby", "afl", "gaelic", "fieldhockey", "handball"], title: "Thirds: defensive, middle and attacking", source: "docs/sources.md#zone-sets" },
+    "net-court": { sports: ["tennis", "volleyball", "badminton", "pickleball", "tabletennis", "padel", "sepaktakraw", "teqball"], title: "Each side of the net: the front court and the back court, split by the court's own line", source: "docs/sources.md#zone-sets" },
+    "wall-court": { sports: ["squash", "racquetball"], title: "The front court and the back court, split by the short line", source: "docs/sources.md#zone-sets" },
+    "roundnet-rings": { sports: ["roundnet"], title: "The no hit zone, the ring out to the serving line, and the rest of the court", source: "docs/sources.md#zone-sets" },
+    "pool-lanes": { sports: ["swimming"], title: "Lanes: each lane of the pool, the whole length of it", source: "docs/sources.md#zone-sets" },
+    "water-polo-areas": { sports: ["waterpolo"], title: "The goal area, the ground from 2 to 6 m, and the rest of the field, at each end", source: "docs/sources.md#zone-sets" },
+    "pool-thirds": { sports: ["diving", "artisticswimming"], title: "Thirds along the pool, from the wall the boards or the judges stand at", source: "docs/sources.md#zone-sets" },
+    "budo-areas": { sports: ["judo", "karate", "kendo", "sumo", "kyudo", "dojo"], title: "The surface in its areas: the contest and the safety areas, the boundary band, the clay and the ring of a dohyō, the shajō, the yamichi and the azuchi, a dojo's floor", source: "docs/sources.md#zone-sets" },
+    "field-thirds": { sports: ["lacrosse", "rugby", "afl", "gaelic", "fieldhockey", "handball", "netball"], title: "Thirds: defensive, middle and attacking", source: "docs/sources.md#zone-sets" },
+    "skating-track": { sports: ["skating"], title: "The rink in parts: the finish straight, the first curve, the crossing straight, the second curve and the infield (a figure skating rink in thirds)", source: "docs/sources.md#zone-sets" },
+    "athletics-track": { sports: ["athletics"], title: "The track in parts: the finish straight, the first bend, the back straight, the second bend, and the infield", source: "docs/sources.md#zone-sets" },
     "cricket-ground": { sports: ["cricket"], title: "The pitch, the ground inside the fielding circle, and the outfield", source: "docs/sources.md#zone-sets" },
     "football-pass": { sports: ["nfl", "cfl", "ifaf"], title: "Pass grid: short and deep by left, middle and right", source: "https://nflreadr.nflverse.com/articles/dictionary_pbp.html" },
 });
@@ -184,7 +199,7 @@ function nhlZones(id, ctx) {
     return out;
 }
 /** The distance from home plate along a ray at `angle` (degrees, 0 straight out to centre field, negative to left) to the edge of the infield: the arc 95 feet round the pitcher's plate. */
-function infieldReach(angle) {
+export function infieldReach(angle) {
     const a = (angle * Math.PI) / 180;
     const along = MLB.pitcher * Math.cos(a);
     return along + Math.sqrt(along * along + MLB.skinRadius * MLB.skinRadius - MLB.pitcher * MLB.pitcher);
@@ -346,14 +361,15 @@ function curlingZones(ctx) {
 }
 /**
  * The court of a net sport on each side of the net: the front court, between the net and the line that the sport's own rules draw there, and the back court behind it.
- * That line is tennis's service line (21 ft), volleyball's attack line (3 m), badminton's short service line (1.98 m) and pickleball's non-volley zone line (7 ft); beach
- * volleyball and table tennis have none, so each side is one zone. The zones are ours: the rules name the lines, not the areas.
+ * That line is tennis's service line (21 ft), volleyball's attack line (3 m; sitting volleyball's 2 m), badminton's short service line (1.98 m), pickleball's non-volley zone
+ * line (7 ft), padel's service line (6.95 m) and teqball's service line (3.5 m); beach volleyball, table tennis and sepak takraw have none, so each side is one zone. The
+ * zones are ours: the rules name the lines, not the areas.
  */
 function netZones(ctx) {
     const plan = courtFor({ sport: ctx.o.sport, league: ctx.o.league, net: ctx.o.net });
     const { length: L, width: W } = courtSize(plan);
     const w = ctx.words;
-    const front = plan.sport === "tennis" ? plan.figures.serviceLine : plan.sport === "volleyball" ? plan.figures.attackLine : plan.sport === "badminton" ? plan.figures.shortServiceLine : plan.sport === "pickleball" ? plan.figures.nonVolley : null;
+    const front = plan.sport === "tennis" || plan.sport === "padel" || plan.sport === "teqball" ? plan.figures.serviceLine : plan.sport === "volleyball" ? plan.figures.attackLine : plan.sport === "badminton" ? plan.figures.shortServiceLine : plan.sport === "pickleball" ? plan.figures.nonVolley : null;
     const cx = L / 2;
     const both = ctx.end === "both";
     const ends = ctx.end === "both" ? ["left", "right"] : [ctx.end];
@@ -375,6 +391,37 @@ function netZones(ctx) {
     }
     return out;
 }
+/**
+ * A squash or racquetball court in two: the front court, from the front wall to the short line, and the back court behind it. The split is the short line's axis. The zones are
+ * ours: the rules name the lines, not the areas.
+ */
+function wallZones(ctx) {
+    const plan = courtFor({ sport: ctx.o.sport, league: ctx.o.league, net: ctx.o.net });
+    const { length: L, width: W } = courtSize(plan);
+    const w = ctx.words;
+    const split = plan.sport === "squash" || plan.sport === "racquetball" ? L - plan.figures.shortLine - plan.figures.lineWidth / 2 : L / 2;
+    return [rect("front-court", w.frontCourt, 0, 0, split, W, false, true), rect("back-court", w.backCourt, split, 0, L, W, true, true)];
+}
+/**
+ * A roundnet court in three: the no hit zone (the circle of 0.9 m), the ring from it out to the serving line (the circle of 2.6 m), and the rest of the court. The zones are ours:
+ * the rules name the lines, not the areas.
+ */
+function roundnetZones(ctx) {
+    const plan = courtFor({ sport: "roundnet", league: ctx.o.league, net: ctx.o.net });
+    const { length: L, width: W } = courtSize(plan);
+    if (plan.sport !== "roundnet")
+        return [];
+    const [cx, cy] = [L / 2, W / 2];
+    const { noHitRadius: n, servingRadius: R } = plan.figures;
+    const w = ctx.words;
+    const circle = (r) => `M${num(cx - r)} ${num(cy)}a${num(r)} ${num(r)} 0 1 0 ${num(2 * r)} 0a${num(r)} ${num(r)} 0 1 0 ${num(-2 * r)} 0Z`;
+    const dist = (x, y) => Math.hypot(x - cx, y - cy);
+    return [
+        { id: "outside-circles", name: w.outsideCircles, d: rectPath(0, 0, L, W) + circle(R), label: [cx, (cy + R + W) / 2], room: [L * 0.8, W / 2 - R], has: (x, y) => x >= 0 && x <= L && y >= 0 && y <= W && dist(x, y) > R },
+        { id: "serving-ring", name: w.servingRing, d: circle(R) + circle(n), label: [cx, cy - (R + n) / 2], room: [R - n, R - n], has: (x, y) => dist(x, y) > n && dist(x, y) <= R },
+        { id: "no-hit-zone", name: w.noHitZone, d: circle(n), label: [cx, cy], room: [2 * n, 2 * n], has: (x, y) => dist(x, y) <= n },
+    ];
+}
 /** The surface in thirds along it, counted from the team's own end: the same for every field sport with ends. */
 function fieldThirds(ctx) {
     const { box } = ctx.outline;
@@ -408,6 +455,159 @@ function cricketZones(ctx) {
     out.push({ id: "pitch", name: w.pitchZone, d: rectPath(px0, py0, px1, py1), label: [cx, cy], room: [px1 - px0, py1 - py0], has: inPitch });
     return out;
 }
+/** A swimming pool in lanes: each lane across the whole length of the pool, from the top of the drawing down. The lane's edges are the ropes'. */
+function poolLanes(ctx) {
+    const plan = swimPlan({ sport: "swimming", pool: ctx.o.pool });
+    const L = ctx.outline.box.w;
+    const per = FEET_PER_METRE;
+    const lanes = plan.lanes;
+    return lanes.map((lane, i) => rect(`lane-${lane.number}`, fill(ctx.words.poolLane, { n: lane.number }), 0, i === 0 ? 0 : lane.top * per, L, i === lanes.length - 1 ? ctx.outline.box.h : lane.bottom * per, true, i === lanes.length - 1));
+}
+/**
+ * A water polo field at each end: the goal area (to the 2 m line), the ground from 2 to 6 m (where the penalty foul applies), and the rest, split at the half distance line. The marks are the rules' (Part Six,
+ * Article 21.7, February 2026; Appendix 4, 20.4.1.5 in the June 2025 edition); the zones are ours.
+ */
+function waterPoloAreas(ctx) {
+    const { box } = ctx.outline;
+    const L = box.w;
+    const W = box.h;
+    const w = ctx.words;
+    const post = WATER_POLO.goal.netClear * FEET_PER_METRE;
+    const two = WATER_POLO.twoMetre * FEET_PER_METRE;
+    const six = WATER_POLO.sixMetre * FEET_PER_METRE;
+    const goalLeft = post;
+    const goalRight = L - post;
+    return [
+        rect("goal-area-left", `${w.poloGoalArea} (${w.endLeft})`, 0, 0, goalLeft + two, W, false, true),
+        rect("two-to-six-left", `${w.poloTwoToSix} (${w.endLeft})`, goalLeft + two, 0, goalLeft + six, W, false, true),
+        rect("beyond-six-left", `${w.poloBeyondSix} (${w.endLeft})`, goalLeft + six, 0, L / 2, W, false, true),
+        rect("beyond-six-right", `${w.poloBeyondSix} (${w.endRight})`, L / 2, 0, goalRight - six, W, false, true),
+        rect("two-to-six-right", `${w.poloTwoToSix} (${w.endRight})`, goalRight - six, 0, goalRight - two, W, false, true),
+        rect("goal-area-right", `${w.poloGoalArea} (${w.endRight})`, goalRight - two, 0, L, W, true, true),
+    ];
+}
+/** The pool in thirds along its length. */
+function poolThirds(ctx) {
+    const { box } = ctx.outline;
+    const w = ctx.words;
+    return [w.poolNear, w.poolMiddle, w.poolFar].map((name, i) => rect(["near", "middle", "far"][i] + "-third", name, (box.w * i) / 3, 0, (box.w * (i + 1)) / 3, box.h, i === 2, true));
+}
+/**
+ * The athletics track in parts, each a part of the oval as the Manual lays it out (2.2.1.1): the finish straight and the back straight between the centres of the semicircles, the first bend (the right-hand one, which
+ * the athletes enter from the finish line) and the second, and the infield inside the kerb. The zones are ours: the rules name no area of the track. Lane by lane is the lane lines' business, not a zone's.
+ */
+function athleticsZones(ctx) {
+    const league = athleticsLeague({ sport: "athletics", league: ctx.o.league });
+    const fig = league.dimensions;
+    const lanes = athleticsLanes({ sport: "athletics", league: ctx.o.league, athletics: ctx.o.athletics });
+    const k = FEET_PER_METRE;
+    const { box } = ctx.outline;
+    const cx = box.w / 2;
+    const cy = box.h / 2;
+    const S = fig.straight;
+    const R = fig.radius;
+    const Ro = R + lanes * fig.lane;
+    const w = ctx.words;
+    const p = (u, v) => `${num(cx + u * k)} ${num(cy + v * k)}`;
+    const arc = (r, sweep) => `A${num(r * k)} ${num(r * k)} 0 0 ${sweep}`;
+    const inside = (u, v, r) => Math.abs(v) <= r && (Math.abs(u) <= S / 2 || Math.hypot(Math.abs(u) - S / 2, v) <= r);
+    const m = (x, y) => [(x - cx) / k, (y - cy) / k];
+    const onTrack = (u, v) => inside(u, v, Ro) && !inside(u, v, R);
+    const stadium = (r) => `M${p(-S / 2, -r)}H${num(cx + (S / 2) * k)}${arc(r, 1)} ${p(S / 2, r)}H${num(cx - (S / 2) * k)}${arc(r, 1)} ${p(-S / 2, -r)}Z`;
+    const east = `M${p(S / 2, -Ro)}${arc(Ro, 1)} ${p(S / 2, Ro)}V${num(cy + R * k)}${arc(R, 0)} ${p(S / 2, -R)}Z`;
+    const west = `M${p(-S / 2, Ro)}${arc(Ro, 1)} ${p(-S / 2, -Ro)}V${num(cy - R * k)}${arc(R, 0)} ${p(-S / 2, R)}Z`;
+    return [
+        { id: "infield", name: w.trackInfield, d: stadium(R), label: [cx, cy], room: [S * k, R * k], has: (x, y) => { const [u, v] = m(x, y); return inside(u, v, R); } },
+        { id: "home-straight", name: w.homeStraight, d: `M${p(-S / 2, R)}H${num(cx + (S / 2) * k)}V${num(cy + Ro * k)}H${num(cx - (S / 2) * k)}Z`, label: [cx, cy + ((R + Ro) / 2) * k], room: [S * k, (Ro - R) * k], has: (x, y) => { const [u, v] = m(x, y); return onTrack(u, v) && Math.abs(u) <= S / 2 && v > 0; } },
+        { id: "first-bend", name: w.firstBend, d: east, label: [cx + (S / 2 + (R + Ro) / 2) * k, cy], room: [(Ro - R) * k, R * k], has: (x, y) => { const [u, v] = m(x, y); return onTrack(u, v) && u > S / 2; } },
+        { id: "back-straight", name: w.backStraight, d: `M${p(-S / 2, -Ro)}H${num(cx + (S / 2) * k)}V${num(cy - R * k)}H${num(cx - (S / 2) * k)}Z`, label: [cx, cy - ((R + Ro) / 2) * k], room: [S * k, (Ro - R) * k], has: (x, y) => { const [u, v] = m(x, y); return onTrack(u, v) && Math.abs(u) <= S / 2 && v < 0; } },
+        { id: "second-bend", name: w.secondBend, d: west, label: [cx - (S / 2 + (R + Ro) / 2) * k, cy], room: [(Ro - R) * k, R * k], has: (x, y) => { const [u, v] = m(x, y); return onTrack(u, v) && u < -S / 2; } },
+    ];
+}
+/**
+ * The skating rink in parts: for a track, the infield inside the inner edge, the finish straight, the first curve, the crossing straight and the second curve between the centres of the curves, each as the
+ * plan lays it out (the long track's ice out to its padding, the short track's rink); for a figure skating rink, its length in thirds. The zones are ours: the Rules name no area of the ice.
+ */
+function skatingZones(ctx) {
+    const plan = skatingPlan({ sport: "skating", league: ctx.o.league, skating: ctx.o.skating });
+    const k = FEET_PER_METRE;
+    const { box } = ctx.outline;
+    const w = ctx.words;
+    const cx = box.w / 2;
+    const cy = box.h / 2;
+    if (plan.discipline === "figure") {
+        const part = (i, id, name) => rect(id, name, (box.w * i) / 3, 0, (box.w * (i + 1)) / 3, box.h, i === 2, true);
+        return [part(0, "left", w.rinkLeft), part(1, "middle", w.rinkMiddle), part(2, "right", w.rinkRight)];
+    }
+    const S = plan.oval === undefined ? plan.short.straight : plan.oval.straight;
+    const R = plan.oval === undefined ? plan.short.blocks : laneEdges(plan.oval, 0).inner;
+    const Ro = plan.oval === undefined ? plan.short.width / 2 : iceRadius(plan.oval);
+    const p = (u, v) => `${num(cx + u * k)} ${num(cy + v * k)}`;
+    const arc = (r, sweep) => `A${num(r * k)} ${num(r * k)} 0 0 ${sweep}`;
+    const inside = (u, v, r) => Math.abs(v) <= r && (Math.abs(u) <= S / 2 || Math.hypot(Math.abs(u) - S / 2, v) <= r);
+    const m = (x, y) => [(x - cx) / k, (y - cy) / k];
+    const onIce = (u, v) => inside(u, v, Ro) && !inside(u, v, R);
+    const stadium = (r) => `M${p(-S / 2, -r)}H${num(cx + (S / 2) * k)}${arc(r, 1)} ${p(S / 2, r)}H${num(cx - (S / 2) * k)}${arc(r, 1)} ${p(-S / 2, -r)}Z`;
+    const east = `M${p(S / 2, -Ro)}${arc(Ro, 1)} ${p(S / 2, Ro)}V${num(cy + R * k)}${arc(R, 0)} ${p(S / 2, -R)}Z`;
+    const west = `M${p(-S / 2, Ro)}${arc(Ro, 1)} ${p(-S / 2, -Ro)}V${num(cy - R * k)}${arc(R, 0)} ${p(-S / 2, R)}Z`;
+    return [
+        { id: "infield", name: w.trackInfield, d: stadium(R), label: [cx, cy], room: [S * k, R * k], has: (x, y) => { const [u, v] = m(x, y); return inside(u, v, R); } },
+        { id: "home-straight", name: w.finishStraight, d: `M${p(-S / 2, R)}H${num(cx + (S / 2) * k)}V${num(cy + Ro * k)}H${num(cx - (S / 2) * k)}Z`, label: [cx, cy + ((R + Ro) / 2) * k], room: [S * k, (Ro - R) * k], has: (x, y) => { const [u, v] = m(x, y); return onIce(u, v) && Math.abs(u) <= S / 2 && v > 0; } },
+        { id: "first-curve", name: w.firstCurve, d: east, label: [cx + (S / 2 + (R + Ro) / 2) * k, cy], room: [(Ro - R) * k, R * k], has: (x, y) => { const [u, v] = m(x, y); return onIce(u, v) && u > S / 2; } },
+        { id: "crossing-straight", name: w.crossingStraight, d: `M${p(-S / 2, -Ro)}H${num(cx + (S / 2) * k)}V${num(cy - R * k)}H${num(cx - (S / 2) * k)}Z`, label: [cx, cy - ((R + Ro) / 2) * k], room: [S * k, (Ro - R) * k], has: (x, y) => { const [u, v] = m(x, y); return onIce(u, v) && Math.abs(u) <= S / 2 && v < 0; } },
+        { id: "second-curve", name: w.secondCurve, d: west, label: [cx - (S / 2 + (R + Ro) / 2) * k, cy], room: [(Ro - R) * k, R * k], has: (x, y) => { const [u, v] = m(x, y); return onIce(u, v) && u < -S / 2; } },
+    ];
+}
+/**
+ * The budō surface in its areas, each as the plan lays it out (budo/plan.ts): a judo or karate area's mats by the colour they are laid in (the safety area under, the contest area, and for karate the boundary band, over
+ * it); a dohyō's clay, the jano-me and the ring; a kyūdōjō's shajō, yamichi and azuchi; a kendo floor and a dojo's in two parts (a dojo's kamiza end and the rest). The zones are ours: no rule names them.
+ */
+function budoZones(ctx) {
+    const plan = budoPlan({ sport: ctx.o.sport, league: ctx.o.league, budo: ctx.o.budo, dojo: ctx.o.dojo });
+    const k = FEET_PER_METRE;
+    const ox = plan.box.x0;
+    const oy = plan.box.y0;
+    const w = ctx.words;
+    const box = (b) => [(b.x0 - ox) * k, (b.y0 - oy) * k, (b.x1 - ox) * k, (b.y1 - oy) * k];
+    const one = (id, name, b) => {
+        const [x0, y0, x1, y1] = box(b);
+        return rect(id, name, x0, y0, x1, y1, true, true);
+    };
+    const whole = one("surface", w.budoSafety, plan.box);
+    // The zones do not overlap: a zone is what is in it and in none of the zones laid over it.
+    const inBox = (b, x, y) => x >= (b.x0 - ox) * k - 1e-9 && x <= (b.x1 - ox) * k + 1e-9 && y >= (b.y0 - oy) * k - 1e-9 && y <= (b.y1 - oy) * k + 1e-9;
+    const without = (z, over) => ({ ...z, has: (x, y) => z.has(x, y) && !over.some((b) => inBox(b, x, y)) });
+    if (plan.judo !== undefined)
+        return [without(one("safety-area", w.budoSafety, plan.judo.tatami), plan.judo.contests), ...plan.judo.contests.map((c, i) => one(`contest-area-${i + 1}`, w.budoContest, c))];
+    if (plan.karate !== undefined)
+        return [without(one("safety-area", w.budoSafety, plan.karate.mats), plan.karate.areas), ...plan.karate.areas.map((c, i) => without(one(`boundary-band-${i + 1}`, w.budoBand, c), plan.karate.inner)), ...plan.karate.inner.map((c, i) => one(`contest-area-${i + 1}`, w.budoContest, c))];
+    if (plan.sumo !== undefined) {
+        const L = plan.sumo;
+        const [cx, cy] = [(L.centre[0] - ox) * k, (L.centre[1] - oy) * k];
+        const ring = (r) => `M${num(cx - r * k)} ${num(cy)}A${num(r * k)} ${num(r * k)} 0 1 0 ${num(cx + r * k)} ${num(cy)}A${num(r * k)} ${num(r * k)} 0 1 0 ${num(cx - r * k)} ${num(cy)}Z`;
+        const jano = L.outer + plan.figures.jano;
+        const dist = (x, y) => Math.hypot(x - cx, y - cy) / k;
+        const base = one("clay", w.budoClay, L.platform);
+        const inner = L.ring + plan.figures.bale.width;
+        return [
+            { ...base, has: (x, y) => base.has(x, y) && dist(x, y) > jano },
+            { id: "jano-me", name: w.budoJano, d: ring(jano), label: [cx, cy - ((L.outer + jano) / 2) * k], room: [(jano - L.outer) * k, (jano - L.outer) * k], has: (x, y) => dist(x, y) <= jano && dist(x, y) > inner },
+            { id: "ring", name: w.budoRing, d: ring(L.ring), label: [cx, cy - L.ring * 0.5 * k], room: [L.ring * k, L.ring * k * 0.4], has: (x, y) => dist(x, y) <= inner },
+        ];
+    }
+    if (plan.kyudo !== undefined) {
+        const parts = [plan.kyudo.shajo, plan.kyudo.yamichi, plan.kyudo.azuchi];
+        return [without({ ...whole, id: "range", name: w.budoRest }, parts), one("shajo", w.budoShajo, plan.kyudo.shajo), without(one("yamichi", w.budoYamichi, plan.kyudo.yamichi), [plan.kyudo.shajo, plan.kyudo.azuchi]), without(one("azuchi", w.budoAzuchi, plan.kyudo.azuchi), [plan.kyudo.shajo, plan.kyudo.yamichi])];
+    }
+    const ranges = plan.ranges;
+    const kamiza = ranges.kamiza;
+    if (plan.dojo !== undefined && kamiza !== undefined && !("left" in kamiza))
+        return [without({ ...whole, id: "floor", name: w.budoRest }, [kamiza]), one("kamiza", w.budoKamiza, kamiza)];
+    const halves = ranges.half;
+    if (halves !== undefined && "left" in halves)
+        return [one("left", w.endLeft, halves.left), without(one("right", w.endRight, halves.right), [halves.left])];
+    return [whole];
+}
 /** The zones of a set on the surface the context describes. Throws for a set that is not for the surface's sport. */
 export function buildZoneSet(id, ctx) {
     if (!Object.prototype.hasOwnProperty.call(ZONE_SETS, id))
@@ -419,6 +619,6 @@ export function buildZoneSet(id, ctx) {
         const { zones, which } = retrosheetZones(ctx);
         return { id, zones, which };
     }
-    const zones = id === "field-thirds" ? fieldThirds(ctx) : id === "cricket-ground" ? cricketZones(ctx) : id.startsWith("soccer") ? soccerZones(id, ctx) : id === "nba-shot" ? nbaZones(ctx) : id.startsWith("nhl") ? nhlZones(id, ctx) : id === "baseball-spray" ? baseballSpray(ctx) : id === "curling-house" ? curlingZones(ctx) : id === "net-court" ? netZones(ctx) : footballPass(ctx);
+    const zones = id === "budo-areas" ? budoZones(ctx) : id === "skating-track" ? skatingZones(ctx) : id === "athletics-track" ? athleticsZones(ctx) : id === "field-thirds" ? fieldThirds(ctx) : id === "cricket-ground" ? cricketZones(ctx) : id.startsWith("soccer") ? soccerZones(id, ctx) : id === "nba-shot" ? nbaZones(ctx) : id.startsWith("nhl") ? nhlZones(id, ctx) : id === "baseball-spray" ? baseballSpray(ctx) : id === "curling-house" ? curlingZones(ctx) : id === "net-court" ? netZones(ctx) : id === "wall-court" ? wallZones(ctx) : id === "roundnet-rings" ? roundnetZones(ctx) : id === "pool-lanes" ? poolLanes(ctx) : id === "water-polo-areas" ? waterPoloAreas(ctx) : id === "pool-thirds" ? poolThirds(ctx) : footballPass(ctx);
     return { id, zones, which: lastWins(zones) };
 }

package/dist/homeside.js

@@ -10,6 +10,11 @@ export const HOME_FIRST = Object.freeze({
     fieldhockey: true,
     handball: true,
     cricket: true,
+    // Water polo lists the home team first. A swimming, diving or artistic swimming dual meet follows the North American convention: the visitor is listed first.
+    waterpolo: true,
+    swimming: false,
+    diving: false,
+    artisticswimming: false,
     // North American professional and college leagues, and the leagues that follow them: the visitor is listed first.
     lacrosse: false,
     nfl: false,
@@ -25,6 +30,25 @@ export const HOME_FIRST = Object.freeze({
     badminton: false,
     pickleball: false,
     tabletennis: false,
+    padel: false,
+    squash: false,
+    racquetball: false,
+    sepaktakraw: false,
+    teqball: false,
+    roundnet: false,
+    // Netball is scored as a goals sport, not in sets, and is listed "home v away" in the Commonwealth countries where it is played most: the home team is first, on the left.
+    netball: true,
+    // A track meeting has no home and away.
+    athletics: false,
+    // A skating race has no home and away.
+    skating: false,
+    // A budō contest is between the first contestant called and the second (judo: blue to the referee's right, white to his left; karate: aka and ao; kendo: aka and shiro; sumo: east and west): no home side.
+    judo: false,
+    karate: false,
+    kendo: false,
+    sumo: false,
+    kyudo: false,
+    dojo: false,
 });
 /** The leagues whose convention is not their sport's: the international federation's lacrosse lists the home team first. */
 export const HOME_FIRST_LEAGUES = Object.freeze({

package/dist/index.d.ts

@@ -1,13 +1,28 @@
-export { COLOR_PROPERTIES, SPORTS, describe, drawBadge, drawKyogijo, drawScore, drawSurface, isPortrait, statusLabel, statusText, winnerOf } from "./draw.ts";
+export { COLOR_PROPERTIES, SPORTS, crowdStands, describe, drawBadge, drawKyogijo, drawScore, drawSurface, isPortrait, statusLabel, statusText, winnerOf } from "./draw.ts";
 export { HOME_FIRST, HOME_FIRST_LEAGUES, homeSideFor } from "./homeside.ts";
-export { inkOn, luminance, rgbOf, safeColour, safeLogo } from "./colour.ts";
+export { inkOn, luminance, rgbOf, safeColour, safePicture } from "./colour.ts";
+export { safeLogo } from "./logo.ts";
+export { useEmblems } from "./emblems-source.ts";
+export type { EmblemDrawOptions, EmblemId, EmblemRef, EmblemRenderer, EmblemStyleName } from "./emblems-source.ts";
 export { OUTCOMES, drawLayers, layerTable } from "./layers.ts";
 export { RANGES } from "./ranges.names.ts";
 export { BACKGROUND_OPACITY, BACKGROUND_PATTERNS, KYOGIJO_BACKGROUND_STYLE } from "./background.ts";
 export type { Background, BackgroundFit, BackgroundOptions, BackgroundPattern } from "./background.ts";
 export { FIELD_SPORTS, fieldPlan, isFieldSport } from "./fields.ts";
+export { POOL_SPORTS, isPoolSport, poolPlan, swimPlan, venueLayout } from "./pool.ts";
+export type { ArtisticPlan, Board, DivePlan, LanePlan, PoloPlan, PoolPlan, Rope, RopeColour, SwimPlan, VenueItem, VenueLayout } from "./pool.ts";
+export { formatTime, parseTime } from "./pool.race.ts";
+export type { DeckLook, DivingPlatform, PaceOptions, PoolKind, PoolLook, PoolRace, PoolSection, RaceShow, Swimmer, SwimmerStatus, VenueOptions, VenuePool } from "./pool.types.ts";
 export type { Area as FieldArea, FieldPlan, GoalPlan as FieldGoalPlan, Outline as FieldOutline, Shape as FieldShape } from "./fields.types.ts";
 export { KYOGIJO_FIELDS_STYLE } from "./fields.style.ts";
+export { KYOGIJO_ATHLETICS_STYLE, KYOGIJO_TRACK_STYLE } from "./athletics.style.ts";
+export { KYOGIJO_SKATING_STYLE } from "./skating.style.ts";
+export { KYOGIJO_BUDO_STYLE } from "./budo.style.ts";
+export { dojo, drawDojo } from "./budo/dojo.api.ts";
+export type { Dojo, Tatami } from "./budo/dojo.api.ts";
+export type { BudoScore, BudoStyle, DojoSpec } from "./budo/types.ts";
+export type { SkatingDiscipline, SkatingFurniture, SkatingInfield, SkatingRace, SkatingStyle } from "./skating/types.ts";
+export type { AthleticsFieldEvent, AthleticsInfield, AthleticsRace, AthleticsStyle, AthleticsTrackLook, WaterJump } from "./athletics/types.ts";
 export type { RangeInfo } from "./ranges.names.ts";
 export { rampColour } from "./layers.marks.ts";
 export { HEAT_RAMPS, HEAT_RAMP_NAMES } from "./heat.colour.ts";
@@ -17,13 +32,22 @@ export type { ArrowsLayer, Comet, Layer, LayerBase, LayerKind, LayerTeam, LineDa
 export { KYOGIJO_STRINGS } from "./strings.ts";
 export type { KyogijoWords } from "./strings.ts";
 export { KYOGIJO_COURTS_STYLE } from "./courts.style.ts";
+export { HARDWOOD_SMALL, KYOGIJO_HARDWOOD_STYLE } from "./hardwood.ts";
+export { KYOGIJO_CROWD_STYLE } from "./crowd.draw.ts";
+export { GRIDIRON_GROUNDS, WALL_SEATS, outlinePath, outlinePoints } from "./crowd.ts";
+export type { CrowdStands, StandGap, StandRing, StandSector, Outline as StandOutline } from "./crowd.ts";
 export { KYOGIJO_MARK_STYLE } from "./mark.ts";
+export { DRIVE_CODES, readSituation, situationText } from "./situation.ts";
+export type { BaseballSituation, DriveLeg, DriveResult, FootballSituation, HockeySituation, ShootoutAttempt, ShootoutRound, Situation, SituationContext, SituationRead, SituationTeam, HockeyRead, BaseballRead, FootballRead, DriveRead } from "./situation.ts";
+export { KYOGIJO_SITUATION_STYLE } from "./situation.style.ts";
+export { KYOGIJO_PAGEANT_MOTION, KYOGIJO_PAGEANT_STYLE } from "./pageant.style.ts";
+export { KYOGIJO_POOL_STYLE } from "./pool.style.ts";
 export { KYOGIJO_CURLING_STYLE, KYOGIJO_HEAT_STYLE, KYOGIJO_NOTE_STYLE, KYOGIJO_STYLE, KYOGIJO_TEAM_STYLE, KYOGIJO_WALLS_STYLE } from "./style.ts";
 export { KYOGIJO_LOOK_STYLE, LOOKS, LOOK_NAMES, LOOK_PAIRS, contrastOf, groupOf, lookPalette, lookStyle } from "./look.ts";
 export type { Group as LookGroup, Look, Palette as LookPalette, PaletteKey as LookPaletteKey } from "./look.ts";
 export { FEATURES, FEATURE_INFO, KYOGIJO_FEATURE_STYLE } from "./features.ts";
 export type { Feature } from "./features.ts";
-export type { DelaunayLayer, FlowLayer, Formation, FormationLayer, FormationPlayer, FormationPosition, FormationSport, HullLayer, MoveDatum, NetworkLayer, NetworkNode, PassDatum, PlayerDatum, SonarLayer, VoronoiLayer } from "./team.types.ts";
+export type { DelaunayLayer, FlowLayer, Formation, FormationLayer, FormationPlayer, FormationPosition, FormationSport, HullLayer, LineupLayer, LineupPlayer, MoveDatum, NetworkLayer, NetworkNode, PassDatum, PlayerDatum, SonarLayer, VoronoiLayer } from "./team.types.ts";
 export { COURT_THEMES } from "./themes.ts";
 export { abbreviate, capitals, fitLines, textWidth } from "./text.ts";
 export type { FittedLines } from "./text.ts";
@@ -33,6 +57,8 @@ export type { PlaceAlias, PlaceNameKind } from "./names.ts";
 export type { CoverQuirk, DugoutSide, HillQuirk, OverhangQuirk, Park, ParkData, ParkDugouts, ParkPeriod, ParkPeriodData, ParkQuirk, ParkSource, ParkWall, ParkWallData, PointQuirk, QuirkKind, WallPlace } from "./parks.ts";
 export { ERA_CURRENT, ERA_SOURCES, ERA_SPORTS, eraChanges, eraRange, eraStates, footballIn, rulesFor, seasonLabel } from "./eras.ts";
 export type { EraChange, EraRules, EraRulesOf, EraSource, EraSpan, EraSport, FootballRules, MlbRules, NbaRules, NhlRules } from "./eras.ts";
+export { ARENA_IDS, ARENAS, arenaById, arenaByName, arenaByWikidata, arenaCourtIn, arenaNameIn, arenaOfficialName, arenaRinkIn, arenaSourceUrl, arenasByName } from "./arenas.ts";
+export type { Arena, ArenaCapacity, ArenaData, ArenaName, ArenaSize, ArenaSource } from "./arenas.ts";
 export { GROUND_IDS, GROUNDS, groundById, groundByName, groundByWikidata, groundNameIn, groundOfficialName, groundSourceUrl, groundsByName, groundsHosting } from "./grounds.ts";
 export type { Ground, GroundCompetition, GroundData, GroundName, GroundSource, GroundTournament } from "./grounds.ts";
 export { AFL_GROUNDS, FAMILY_OF, LEAGUES, LEAGUE_SOURCES, VARIANTS, chooseLeague, hasHistory, leagueAt, leagueById, leagueChanges, leagueFigures, leagueIds, leagueSeason, leagueSize } from "./leagues.ts";
@@ -44,4 +70,4 @@ export type { SoccerPitchClass, SoccerPitchId, SoccerSize, SoccerSpec } from "./
 export { SOCCER_PROVIDER_IDS, SOCCER_PROVIDERS, frameMatrix, rescale, soccerFrame, soccerLandmarks } from "./surfaces/soccer-providers.ts";
 export type { Rescaler, SoccerFrame, SoccerProvider, SoccerProviderId } from "./surfaces/soccer-providers.ts";
 export { VERSION } from "./version.ts";
-export type { AxesOptions, Box, Colors, CourtStyle, Detail, DirectionOptions, FieldSport, FieldStyle, Fence, GoalInfo, GoalStyle, Language, NetStyle, LineDash, LineWidth, LookName, Orientation, QuirkName, QuirkOptions, RangeBox, RangeName, RangeNamed, ScoreOptions, Side, Size, Sport, StatusWord, StripePattern, SurfaceOptions, Team, TeamMark, Theme, WallOptions, } from "./types.ts";
+export type { AxesOptions, Box, Colors, CourtStyle, CrowdOptions, CrowdShape, Detail, DirectionOptions, BudoSport, FieldSport, FieldStyle, Fence, GoalInfo, GoalStyle, HardwoodOptions, Language, NetStyle, LineDash, LineWidth, LookName, Orientation, PoolSport, PoolStyle, QuirkName, QuirkOptions, RangeBox, PageantOptions, PageantStyle, RangeName, RangeNamed, ScoreOptions, Side, Size, Sport, StatusWord, StripePattern, SurfaceOptions, Team, TeamMark, Theme, WallOptions, } from "./types.ts";

package/dist/index.js

@@ -1,18 +1,33 @@
 // Kyogijo Stadiums 競技場: sports surfaces as SVG, drawn to scale, with the teams and the score on them.
-export { COLOR_PROPERTIES, SPORTS, describe, drawBadge, drawKyogijo, drawScore, drawSurface, isPortrait, statusLabel, statusText, winnerOf } from "./draw.js";
+export { COLOR_PROPERTIES, SPORTS, crowdStands, describe, drawBadge, drawKyogijo, drawScore, drawSurface, isPortrait, statusLabel, statusText, winnerOf } from "./draw.js";
 export { HOME_FIRST, HOME_FIRST_LEAGUES, homeSideFor } from "./homeside.js";
-export { inkOn, luminance, rgbOf, safeColour, safeLogo } from "./colour.js";
+export { inkOn, luminance, rgbOf, safeColour, safePicture } from "./colour.js";
+export { safeLogo } from "./logo.js";
+export { useEmblems } from "./emblems-source.js";
 export { OUTCOMES, drawLayers, layerTable } from "./layers.js";
 export { RANGES } from "./ranges.names.js";
 export { BACKGROUND_OPACITY, BACKGROUND_PATTERNS, KYOGIJO_BACKGROUND_STYLE } from "./background.js";
 export { FIELD_SPORTS, fieldPlan, isFieldSport } from "./fields.js";
+export { POOL_SPORTS, isPoolSport, poolPlan, swimPlan, venueLayout } from "./pool.js";
+export { formatTime, parseTime } from "./pool.race.js";
 export { KYOGIJO_FIELDS_STYLE } from "./fields.style.js";
+export { KYOGIJO_ATHLETICS_STYLE, KYOGIJO_TRACK_STYLE } from "./athletics.style.js";
+export { KYOGIJO_SKATING_STYLE } from "./skating.style.js";
+export { KYOGIJO_BUDO_STYLE } from "./budo.style.js";
+export { dojo, drawDojo } from "./budo/dojo.api.js";
 export { rampColour } from "./layers.marks.js";
 export { HEAT_RAMPS, HEAT_RAMP_NAMES } from "./heat.colour.js";
 export { ZONE_SETS, ZONE_SET_IDS } from "./heat.zones.js";
 export { KYOGIJO_STRINGS } from "./strings.js";
 export { KYOGIJO_COURTS_STYLE } from "./courts.style.js";
+export { HARDWOOD_SMALL, KYOGIJO_HARDWOOD_STYLE } from "./hardwood.js";
+export { KYOGIJO_CROWD_STYLE } from "./crowd.draw.js";
+export { GRIDIRON_GROUNDS, WALL_SEATS, outlinePath, outlinePoints } from "./crowd.js";
 export { KYOGIJO_MARK_STYLE } from "./mark.js";
+export { DRIVE_CODES, readSituation, situationText } from "./situation.js";
+export { KYOGIJO_SITUATION_STYLE } from "./situation.style.js";
+export { KYOGIJO_PAGEANT_MOTION, KYOGIJO_PAGEANT_STYLE } from "./pageant.style.js";
+export { KYOGIJO_POOL_STYLE } from "./pool.style.js";
 export { KYOGIJO_CURLING_STYLE, KYOGIJO_HEAT_STYLE, KYOGIJO_NOTE_STYLE, KYOGIJO_STYLE, KYOGIJO_TEAM_STYLE, KYOGIJO_WALLS_STYLE } from "./style.js";
 export { KYOGIJO_LOOK_STYLE, LOOKS, LOOK_NAMES, LOOK_PAIRS, contrastOf, groupOf, lookPalette, lookStyle } from "./look.js";
 export { FEATURES, FEATURE_INFO, KYOGIJO_FEATURE_STYLE } from "./features.js";
@@ -21,6 +36,7 @@ export { abbreviate, capitals, fitLines, textWidth } from "./text.js";
 export { PARKS, PARK_IDS, fenceFor, parkById, parkByName, parkByWikidata, parkNameIn, parkOfficialName, parkPointsIn, parkQuirksIn, parkSourceUrl, parkUnit, parkWallsIn, parksByName } from "./parks.js";
 export { officialName, plainName } from "./names.js";
 export { ERA_CURRENT, ERA_SOURCES, ERA_SPORTS, eraChanges, eraRange, eraStates, footballIn, rulesFor, seasonLabel } from "./eras.js";
+export { ARENA_IDS, ARENAS, arenaById, arenaByName, arenaByWikidata, arenaCourtIn, arenaNameIn, arenaOfficialName, arenaRinkIn, arenaSourceUrl, arenasByName } from "./arenas.js";
 export { GROUND_IDS, GROUNDS, groundById, groundByName, groundByWikidata, groundNameIn, groundOfficialName, groundSourceUrl, groundsByName, groundsHosting } from "./grounds.js";
 export { AFL_GROUNDS, FAMILY_OF, LEAGUES, LEAGUE_SOURCES, VARIANTS, chooseLeague, hasHistory, leagueAt, leagueById, leagueChanges, leagueFigures, leagueIds, leagueSeason, leagueSize } from "./leagues.js";
 export { SURFACE_UNITS, UNITS, convertLength, isUnit } from "./units.js";

package/dist/layers-entry.d.ts

@@ -13,7 +13,8 @@ export { KYOGIJO_HEAT_STYLE } from "./style.ts";
 export type { ArrowsLayer, Comet, Layer, LayerBase, LayerKind, LayerTeam, LineDatum, LineStyle, LinesLayer, MarkDatum, MarkShape, OutcomeStyle, Paint, PointDatum, PointStyle, PointsLayer, Scale, TableOptions, TextDatum, TextLayer, TextStyle } from "./layers.types.ts";
 export { KYOGIJO_TEAM_STYLE } from "./style.ts";
 export { FORMATIONS, FORMATION_IDS, POSITION_NAMES, formationById, formationsOf, positionName } from "./formations.ts";
+export { LINEUP_CODES } from "./lineup.codes.ts";
 export type { Named } from "./formations.ts";
 export { clipNearer, convexHull, delaunay, neighbours, polygonArea, polygonCentroid, triangulationEdges, voronoiCells } from "./team.geometry.ts";
 export type { Pt, Triangulation } from "./team.geometry.ts";
-export type { DelaunayLayer, FlowLayer, Formation, FormationLayer, FormationPlayer, FormationPosition, FormationSport, HullLayer, MoveDatum, NetworkLayer, NetworkNode, PassDatum, PlayerDatum, SonarLayer, VoronoiLayer } from "./team.types.ts";
+export type { DelaunayLayer, FlowLayer, Formation, FormationLayer, FormationPlayer, FormationPosition, FormationSport, HullLayer, LineupLayer, LineupPlayer, MoveDatum, NetworkLayer, NetworkNode, PassDatum, PlayerDatum, SonarLayer, VoronoiLayer } from "./team.types.ts";

package/dist/layers-entry.js

@@ -8,4 +8,5 @@ export { ZONE_SETS, ZONE_SET_IDS, buildZoneSet } from "./heat.zones.js";
 export { KYOGIJO_HEAT_STYLE } from "./style.js";
 export { KYOGIJO_TEAM_STYLE } from "./style.js";
 export { FORMATIONS, FORMATION_IDS, POSITION_NAMES, formationById, formationsOf, positionName } from "./formations.js";
+export { LINEUP_CODES } from "./lineup.codes.js";
 export { clipNearer, convexHull, delaunay, neighbours, polygonArea, polygonCentroid, triangulationEdges, voronoiCells } from "./team.geometry.js";

package/dist/layers.d.ts

@@ -1,3 +1,4 @@
+import { type Env } from "./layers.env.ts";
 import type { Layer, OutcomeStyle, TableOptions } from "./layers.types.ts";
 import type { Box, ScoreOptions, SurfaceOptions } from "./types.ts";
 /**
@@ -11,7 +12,7 @@ export interface RenderedLayers {
     summaries: string[];
 }
 /** The layers of a drawing as markup, and a sentence for each. `turned` says whether the surface group is turned a quarter. */
-export declare function renderLayers(o: SurfaceOptions | ScoreOptions, layers: readonly Layer[] | undefined, turned?: boolean, range?: Box): RenderedLayers;
+export declare function renderLayers(o: SurfaceOptions | ScoreOptions, layers: readonly Layer[] | undefined, turned?: boolean, range?: Box, upright?: number, zone?: Env["zone"]): RenderedLayers;
 /**
  * The layers of a drawing as one SVG group, in the surface's own frame, for a caller who composes the drawing's parts. Put it inside the
  * surface's group (the one with the quarter turn, when the drawing is tall) and the marks lie on the surface, cut to its outline, with

package/dist/layers.env.d.ts

@@ -14,6 +14,8 @@ export interface Env {
     o: SurfaceOptions | ScoreOptions;
     id: string;
     turned: boolean;
+    /** The turn, in degrees, that texts and logos are given to read upright: the quarter back (-90) when the surface is turned a quarter, else 0, or the surface's own (a close-up of an athletics start is turned to any angle). */
+    back: number;
     unit: Unit;
     outline: Outline;
     /**
@@ -30,7 +32,16 @@ export interface Env {
         home?: string;
         away?: string;
     };
+    /** Whether the layer being drawn writes `data-mark-id`, `data-index` and `data-zone` on its marks: set for each layer by `renderLayers`. */
+    marks: boolean;
+    /** The finest zone of the surface a place (feet, the drawing's wide frame) lies in, by id: what a mark carries as `data-zone`. `undefined` where the sport has none there. */
+    zone: (x: number, y: number) => string | undefined;
 }
+/**
+ * The data attributes every mark carries, so that one listener on the drawing can link a mark to a table: `data-mark-id` (the id the caller gave the datum, else its index),
+ * `data-index` (its place in the layer's data) and `data-zone` (the zone it lies in, from `zoneAt`'s rules). The place is in feet in the drawing's wide frame.
+ */
+export declare function markAttrs(env: Env, id: unknown, index: number, at?: readonly [number, number], name?: string): string;
 /** What a layer made. */
 export interface Made {
     /** The elements of the layer, and its gradients as `defs`. */
@@ -69,4 +80,4 @@ export declare function place(layer: LayerBase, env: Env, points: readonly P[],
 /** The inverse of `place`: places on the surface, in feet, as the layer's own coordinates (its frame and unit). */
 export declare function placeBack(layer: LayerBase, env: Env, points: readonly P[], unit: Unit): P[];
 export declare function newMade(): Made;
-export declare function envFor(o: SurfaceOptions | ScoreOptions, turned: boolean | undefined, range?: Box): Env;
+export declare function envFor(o: SurfaceOptions | ScoreOptions, turned: boolean | undefined, range?: Box, upright?: number, zone?: Env["zone"]): Env;

package/dist/layers.env.js

@@ -1,8 +1,10 @@
 // What every kind of data layer is drawn against: the drawing's id, its unit and outline, the words, and what a layer made. Kept apart
 // from layers.ts so that the heat maps, which are written in files of their own, can use it without importing the file that imports them.
-import { safeLogo } from "./colour.js";
+import { safeLogo } from "./logo.js";
+import { esc } from "./format.js";
 import { drawingId, isPortrait, lengthUnit } from "./common.js";
 import { fromSurface, toSurface } from "./frames.js";
+import { zoneResolver } from "./rules.js";
 import "./frames.providers.js";
 import { chooseLeague } from "./leagues.js";
 import { frameSizeOf, outlineOf } from "./outline.js";
@@ -12,6 +14,32 @@ export const isNum = (value) => typeof value === "number" && Number.isFinite(val
 export const clamp01 = (value) => Math.max(0, Math.min(1, value));
 export const own = (table, key) => Object.prototype.hasOwnProperty.call(table, key);
 export const opacityOf = (value) => (isNum(value) ? clamp01(value) : undefined);
+/** The zone of a drawing's marks, made when the first mark asks: a surface the rules cannot be made for (a special game) has none. */
+function zonesOf(o) {
+    let resolver;
+    return (x, y) => {
+        if (resolver === undefined) {
+            try {
+                resolver = o.host !== undefined ? () => undefined : zoneResolver(o.sport, o);
+            }
+            catch {
+                resolver = () => undefined;
+            }
+        }
+        return resolver(x, y);
+    };
+}
+/**
+ * The data attributes every mark carries, so that one listener on the drawing can link a mark to a table: `data-mark-id` (the id the caller gave the datum, else its index),
+ * `data-index` (its place in the layer's data) and `data-zone` (the zone it lies in, from `zoneAt`'s rules). The place is in feet in the drawing's wide frame.
+ */
+export function markAttrs(env, id, index, at, name = "data-zone") {
+    if (!env.marks)
+        return "";
+    const given = typeof id === "string" && id !== "" ? id : typeof id === "number" && Number.isFinite(id) ? String(id) : String(index);
+    const zone = at === undefined ? undefined : env.zone(at[0], at[1]);
+    return ` data-mark-id="${esc(given)}" data-index="${index}"${zone === undefined ? "" : ` ${name}="${esc(zone)}"`}`;
+}
 export const toArray = (value, what) => {
     if (!Array.isArray(value))
         throw new TypeError(`${what} needs data: a list of marks`);
@@ -60,20 +88,24 @@ export function placeBack(layer, env, points, unit) {
 export function newMade() {
     return { marks: "", defs: "", style: "", attr: "", opacity: undefined, drawn: 0, skipped: 0, outcomes: new Map(), teams: new Map(), low: Infinity, high: -Infinity };
 }
-export function envFor(o, turned, range) {
+export function envFor(o, turned, range, upright, zone) {
     const language = o.language === "ja" ? "ja" : "en";
     const outline = outlineOf(o);
     const teams = o;
+    const quarter = turned ?? (isPortrait(o) && o.sport !== "mlb");
     return {
         o,
         id: drawingId(o),
-        turned: turned ?? (isPortrait(o) && o.sport !== "mlb"),
+        turned: quarter,
+        back: upright ?? (quarter ? -90 : 0),
         unit: lengthUnit(o),
         outline,
         shown: range ?? outline.box,
         cropped: range !== undefined,
         base: Math.max((range ?? outline.box).w, (range ?? outline.box).h) * 0.013,
         words: KYOGIJO_STRINGS[language],
-        logos: { home: safeLogo(teams.home?.logo), away: safeLogo(teams.away?.logo) },
+        logos: { home: safeLogo(teams.home?.logo, { color: teams.home?.color, accent: teams.home?.textColor }), away: safeLogo(teams.away?.logo, { color: teams.away?.color, accent: teams.away?.textColor }) },
+        marks: o.marks === true || o.pointer === true,
+        zone: zone ?? zonesOf(o),
     };
 }