@johnmorrisdotca/kyogijo-stadiums 0.17.0 → 0.18.0

package/CHANGELOG.md

@@ -7,6 +7,17 @@ All notable changes to this project are written here. The format follows
 
 ## [Unreleased]
 
+## [0.18.0] - 2026-10-20
+
+### Added
+
+- **Shiai judging assignments** (`style: "shiai"` of `@johnmorrisdotca/kyogijo-stadiums/judging`). A contest area's officials by seat, with a name and an ID, drawn as the kata area's are (a card in the seat where the name fits, the chart of seat, role, name and ID that never cuts a name, 2D and 3D, light and dark, English and Japanese, `mat`, `focus`, `chart`, `orientation`, `judgingTable`). From the IJF Sport and Organisation Rules of 21 January 2026: **the referee**, on the tatami at its centre 2 m back from the line the athletes start on, facing the technical table (Article 9; the Refereeing Rules' Article 2); **the timekeeper and the scorekeeper**, the two technical officials a tatami should have for timing and scoring (the Refereeing Rules' opening article); **the referee supervisor**, on the technical table with the CARE replay system (the same article); and **two side judges**, for an event with no CARE system (Article 13, 5), drawn only with the new `sideJudges: true` or when a mat names them. Which chair at the table is whose, the side judges' places (two opposite corners of the contest area, 2 m out: the Rules give none), the chairs, the table and the cards are ours. In the close-up of the bench (`focus: "bench"`) only the table's seats are drawn and the referee's and side judges' names are in the chart; in 3D the referee's and a side judge's cards stand on posts. Seat words: `referee`, `timekeeper`, `scorekeeper`, `supervisor`, `side-judge-1`, `side-judge-2` (or their numbers 1 to 6, or `judge-1`, `scorer`, `jury`...). The demo, [judging assignments](https://johnmorrisdotca.github.io/kyogijo-stadiums/judging.html), has a Style choice (`style=shiai`), the side judges' checkbox and a row in its editor for each seat; the docs have [a section](./docs/judging.md#the-seats-of-a-contest) and the gallery [a contest](https://johnmorrisdotca.github.io/kyogijo-stadiums/docs/gallery-judging.html#shiai).
+
+### Changed
+
+- `JudgingStyle` is `"kata" | "shiai"`; `JudgingSeat` has `where` (`table`, `mat` or `corner`) and `optional`, and its `role` the contest's roles; `seatsOf(style, "listed")` leaves out the optional seats; `judgingPlan(style, count)` gives each mat's `places` (a chair and a card for each seat, in metres) and its bench; `fitSeats` takes a box for each seat. A kata assignment draws byte for byte what it did.
+- `JudoLayout` (the judo plan) also gives `desks` (the technical tables) and `free` (the free zone), as data only: no drawing changes.
+
 ## [0.17.0] - 2026-10-20
 
 ### Added

package/dist/budo/judo.d.ts

@@ -43,6 +43,10 @@ export interface JudoLayout {
         seats: MBox[];
         coaches: MBox[];
     };
+    /** A contest area's technical tables (ours: 3 m by 0.8 m), one for each area of the top row; empty for a kata area. */
+    desks: MBox[];
+    /** The free zone round the whole competition area. */
+    free: MBox;
 }
 /** The mats of a `tatami` option, or the league's own when none. @throws Error for a name that is not a size of mat. */
 export declare function matOf(asked: BudoStyle["tatami"], fig: JudoFigures): MatSize;

package/dist/budo/judo.js

@@ -139,7 +139,7 @@ export function judoParts(o) {
     if (judges.coaches.length > 0)
         marks.push({ id: "coach-chair", x: (judges.coaches[0].x0 + judges.coaches[0].x1) / 2, y: (judges.coaches[0].y0 + judges.coaches[0].y1) / 2, side: "bottom" });
     const extent = union([free, ...desks.map((d) => grow(d, 0.3)), ...[...judges.tables, ...judges.seats, ...judges.coaches].map((d) => grow(d, 0.3))]);
-    return { parts, tatami, extent, contests, gap, pieces, mat, marks, danger: band, judges };
+    return { parts, tatami, extent, contests, gap, pieces, mat, marks, danger: band, judges, desks, free };
 }
 /** The number of mats of the competition area: a half mat counts a half. */
 export const mats = (layout, mat) => Math.round(matCount(layout.pieces, mat) * 100) / 100;

package/dist/judging-entry.d.ts

@@ -1,12 +1,12 @@
 export { drawJudging, judgingChart, judgingDrawing, judgingTable, judgingText } from "./judging.draw.ts";
 export { JUDGING_HEIGHTS, JUDGING_PRESETS, buildJudgingTurn, judgingTurnMarkup, mountJudgingTurn } from "./judging.turn.ts";
-export { JUDGING_LEAGUE, JUDGING_MATS_MAX, JUDGING_SEATS, JUDGING_SEAT_COUNT, JUDGING_STYLES } from "./judging.data.ts";
-export { JUDGING_LIMITS, judgingPlan, judgingSetting, matLabel, seatOf, seatsOf } from "./judging.ts";
+export { JUDGING_LEAGUE, JUDGING_MATS_MAX, JUDGING_SEATS, JUDGING_SEAT_COUNT, JUDGING_SEAT_WORDS, JUDGING_STYLES } from "./judging.data.ts";
+export { JUDGING_LIMITS, benchOf, judgingPlan, judgingSetting, matLabel, seatIn, seatOf, seatsOf } from "./judging.ts";
 export { fitCard, fitChart, fitSeats, wrapText } from "./judging.fit.ts";
 export { KYOGIJO_JUDGING_STYLE } from "./judging.style.ts";
 export { JUDGING_WORDS } from "./judging.words.ts";
 export type { JudgingWords } from "./judging.words.ts";
 export type { JudgingAssignment, JudgingMat, JudgingOfficial, JudgingOptions, JudgingResolved, JudgingSeat, JudgingStyle } from "./judging.types.ts";
 export type { JudgingDrawing } from "./judging.draw.ts";
-export type { JudgingPlan, JudgingSetting } from "./judging.ts";
+export type { JudgingPlan, JudgingSetting, MatPlaces, SeatPlace } from "./judging.ts";
 export type { CardAsk, CardFit } from "./judging.fit.ts";

package/dist/judging-entry.js

@@ -1,8 +1,8 @@
 // A judging assignment: the officials of each mat area of a judo tournament, by seat, with their names and IDs, in the seat where they fit and in a chart where they do not; in 2D and in 3D.
 export { drawJudging, judgingChart, judgingDrawing, judgingTable, judgingText } from "./judging.draw.js";
 export { JUDGING_HEIGHTS, JUDGING_PRESETS, buildJudgingTurn, judgingTurnMarkup, mountJudgingTurn } from "./judging.turn.js";
-export { JUDGING_LEAGUE, JUDGING_MATS_MAX, JUDGING_SEATS, JUDGING_SEAT_COUNT, JUDGING_STYLES } from "./judging.data.js";
-export { JUDGING_LIMITS, judgingPlan, judgingSetting, matLabel, seatOf, seatsOf } from "./judging.js";
+export { JUDGING_LEAGUE, JUDGING_MATS_MAX, JUDGING_SEATS, JUDGING_SEAT_COUNT, JUDGING_SEAT_WORDS, JUDGING_STYLES } from "./judging.data.js";
+export { JUDGING_LIMITS, benchOf, judgingPlan, judgingSetting, matLabel, seatIn, seatOf, seatsOf } from "./judging.js";
 export { fitCard, fitChart, fitSeats, wrapText } from "./judging.fit.js";
 export { KYOGIJO_JUDGING_STYLE } from "./judging.style.js";
 export { JUDGING_WORDS } from "./judging.words.js";

package/dist/judging.d.ts

@@ -7,10 +7,10 @@ export declare const JUDGING_LIMITS: Readonly<{
     id: 64;
     label: 40;
 }>;
-/** The seats of a style. @throws TypeError for a style that is not one. */
-export declare function seatsOf(style: unknown): readonly JudgingSeat[];
+/** The seats of a style: every one, or without the optional ones (the side judges of a contest). @throws TypeError for a style that is not one. */
+export declare function seatsOf(style: unknown, only?: "all" | "listed"): readonly JudgingSeat[];
 /**
- * The seat a name stands for: its number (`3`, `"3"`), its key (`"judge-3"`, `"Judge 3"`) or `"central"`.
+ * The seat a name stands for: its number (`3`, `"3"`), its key (`"judge-3"`, `"Judge 3"`, `"referee"`, `"timekeeper"`) or a word (`"central"`, `"scorer"`, `"jury"`).
  * @throws RangeError for a seat the style does not have, naming the seats it has.
  */
 export declare function seatOf(style: JudgingStyle, seat: unknown): JudgingSeat;
@@ -34,22 +34,41 @@ export interface JudgingSetting {
  * @throws TypeError for an option of the wrong kind, RangeError for a number of mats outside 1 to 6, a mat that does not exist, a seat the style does not have, a seat named twice on one mat or a text that is too long.
  */
 export declare function judgingSetting(options: JudgingOptions): JudgingSetting;
-/** Where the seats are on one mat's plan, in metres from the top left of the tatami, and the plan they are on. */
+/** Where one seat is on a mat's plan, in metres from the top left of the tatami: its chair (or the place where the official stands) and the card that carries the name, which may lie over the table in front of it. */
+export interface SeatPlace {
+    chair: MBox;
+    card: MBox;
+}
+/** One mat's seats, in the order the style lists them (`JUDGING_SEATS`, optional seats included), its table and its bench. */
+export interface MatPlaces {
+    places: SeatPlace[];
+    /** The judges' table or the technical table behind the seats at it. */
+    table: MBox;
+    /** The seats at the table close up: the picture of `focus: "bench"`. */
+    bench: MBox;
+}
+/** Where the seats are on the plan of a style, and the plan they are on. */
 export interface JudgingPlan {
     plan: BudoPlan;
-    /** The chair of each seat, in seat order, and the judges' table behind them. */
+    /** Each mat's seats, for the mats side by side the plan has (`count`). */
+    mats: MatPlaces[];
+    /** The first mat's seats, its table and its bench, as `mats[0]` has them (the chairs of the seats, in order). */
+    places: SeatPlace[];
     chairs: MBox[];
     table: MBox;
-    /** The distance between two seats. */
+    bench: MBox;
+    /** The distance between two seats at the table. */
     pitch: number;
-    /** The whole picture of a mat (the free zone, the table, the seats, the coach's chair) and the judges' bench close up. */
+    /** The whole picture of a mat (the free zone, the table, the seats, their cards): what `focus: "mat"` shows, for the first mat. */
     extent: MBox;
-    bench: MBox;
 }
 /**
- * The judges' bench close up: the seats and the table with a little round them and a few rows of mats in front, from the seats of one mat or of several side by side. `matTop` is where the mats start (the top of the first
- * contest area), so that the picture shows how the bench sits at the mat's edge; `front` instead says how far in front of the table the picture reaches, in metres (the 3D view, which turns, wants as little of the floor as will do).
+ * The judges' bench close up: the seats and their table with a little round them and a few rows of mats in front, from the seats of one mat or of several side by side. `matTop` is where the mats start (the top of the first
+ * contest area), so that the picture shows how the bench sits at the mat's edge; `front` instead says how far in front of the table the picture reaches, in metres (the 3D view, which turns, wants as little of the floor as
+ * will do).
  */
 export declare function benchOf(chairs: readonly MBox[], table: MBox, pitch: number, matTop: number, front?: number): MBox;
-/** The plan of one mat of a style, with its seats: the package's own judo area, so that the seats named are the seats drawn. */
-export declare function judgingPlan(style: JudgingStyle): JudgingPlan;
+/** The plan of `count` mats side by side of a style, with its seats: the package's own judo area, so that the seats named are the seats drawn. */
+export declare function judgingPlan(style: JudgingStyle, count?: number): JudgingPlan;
+/** Whether a seat is in a box: its card's middle is inside it. A seat that is not is not drawn in a close-up of the bench, and its name is in the chart only. */
+export declare function seatIn(place: SeatPlace, box: MBox): boolean;

package/dist/judging.data.d.ts

@@ -1,8 +1,10 @@
 import type { JudgingSeat, JudgingStyle } from "./judging.types.ts";
-/** How many officials a style seats. */
+/** How many officials a style seats at the most (a contest's two side judges included). */
 export declare const JUDGING_SEAT_COUNT: Readonly<Record<JudgingStyle, number>>;
-/** The seats of every style, in the order they are drawn. */
+/** The seats of every style, in the order they are listed. */
 export declare const JUDGING_SEATS: Readonly<Record<JudgingStyle, readonly JudgingSeat[]>>;
+/** The other words a seat is asked for by, besides its key and its number. */
+export declare const JUDGING_SEAT_WORDS: Readonly<Record<string, readonly string[]>>;
 /** The styles that can be asked for. */
 export declare const JUDGING_STYLES: readonly JudgingStyle[];
 /** The league each style is drawn in (`drawKyogijo`'s `league`), and the sources its seats are read from (keys of `LEAGUE_SOURCES`). */

package/dist/judging.data.js

@@ -1,24 +1,53 @@
-// The seats of each judging style, as the rulebook has them. A kata area is judged by five judges on the shomen side, 1.25 m apart, the central judge at the centre of the area, and no referee (IJF Sport and
-// Organisation Rules of 21 January 2026, B1.8 and the judges' article; the Kata Commission's Tournament Handbook 2024). The rules do not number the judges: the numbers here are ours, from the left as the plan lies
-// with the shomen at the top (so the central judge is 3), and are said so in the docs. The positions are the plan's own (`budoPlan`), so that what is drawn and what is named cannot differ.
+// The seats of each judging style, as the rulebook has them.
+// A kata area is judged by five judges on the shomen side, 1.25 m apart, the central judge at the centre of the area, and no referee (IJF Sport and Organisation Rules of 21 January 2026, B1.8 and the judges' article; the
+// Kata Commission's Tournament Handbook 2024). The rules do not number the judges: the numbers here are ours, from the left as the plan lies with the shomen at the top (so the central judge is 3).
+// A contest (shiai) has one referee, on the tatami at its centre 2 m back from the line the athletes start on, facing the technical table (SOR, Refereeing Rules, Article 9 and Article 2); two technical officials a
+// tatami for timing and scoring (the Refereeing Rules' opening article); the IJF Referee Supervisor(s) on the technical table with the CARE replay system, and the referees not officiating seated at it (Article 3);
+// and, for an event with no CARE system, two side judges with a majority of three (Article 13, 5). The Rules give no place for a side judge: the corners of the contest area are ours. The positions are the plan's own
+// (`budoPlan`) and the figures round them in `judging.ts`, so that what is drawn and what is named cannot differ.
 import { IJF_KATA } from "./leagues/budo.js";
-/** How many officials a style seats. */
-export const JUDGING_SEAT_COUNT = Object.freeze({ kata: IJF_KATA.panel?.count ?? 5 });
+/** How many officials a style seats at the most (a contest's two side judges included). */
+export const JUDGING_SEAT_COUNT = Object.freeze({ kata: IJF_KATA.panel?.count ?? 5, shiai: 6 });
 /** The seats of a kata area: five judges, the middle one the central judge. */
 function kata() {
-    const count = JUDGING_SEAT_COUNT.kata;
+    const count = IJF_KATA.panel?.count ?? 5;
     const middle = Math.ceil(count / 2);
     return Array.from({ length: count }, (_, i) => {
         const n = i + 1;
         const central = n === middle;
-        return { id: `judge-${n}`, n, role: central ? "central" : "judge", label: { en: central ? `Judge ${n}, central` : `Judge ${n}`, ja: central ? `審判員${n}（中央）` : `審判員${n}` } };
+        return { id: `judge-${n}`, n, role: central ? "central" : "judge", where: "table", label: { en: central ? `Judge ${n}, central` : `Judge ${n}`, ja: central ? `審判員${n}（中央）` : `審判員${n}` } };
     });
 }
-/** The seats of every style, in the order they are drawn. */
-export const JUDGING_SEATS = Object.freeze({ kata: Object.freeze(kata()) });
+/** The seats of a contest: the referee, then the technical table's three, then the side judges (drawn only when asked for or named). */
+function shiai() {
+    const seat = (n, id, role, where, en, ja, optional = false) => ({ id, n, role, where, label: { en, ja }, ...(optional ? { optional: true } : {}) });
+    return [
+        seat(1, "referee", "referee", "mat", "Referee", "主審"),
+        seat(2, "timekeeper", "timekeeper", "table", "Timekeeper", "計時係"),
+        seat(3, "scorekeeper", "scorekeeper", "table", "Scorekeeper", "記録係"),
+        seat(4, "supervisor", "supervisor", "table", "Referee supervisor", "審判委員"),
+        seat(5, "side-judge-1", "side-judge", "corner", "Side judge 1", "副審1", true),
+        seat(6, "side-judge-2", "side-judge", "corner", "Side judge 2", "副審2", true),
+    ];
+}
+/** The seats of every style, in the order they are listed. */
+export const JUDGING_SEATS = Object.freeze({ kata: Object.freeze(kata()), shiai: Object.freeze(shiai()) });
+/** The other words a seat is asked for by, besides its key and its number. */
+export const JUDGING_SEAT_WORDS = Object.freeze({
+    "judge-3": ["central", "centre", "center"],
+    referee: ["main", "main-referee", "central-referee", "shimpan"],
+    timekeeper: ["time", "timer", "timing"],
+    scorekeeper: ["score", "scorer", "scoring", "recorder"],
+    supervisor: ["referee-supervisor", "jury", "care"],
+    "side-judge-1": ["judge-1", "side-1"],
+    "side-judge-2": ["judge-2", "side-2"],
+});
 /** The styles that can be asked for. */
-export const JUDGING_STYLES = Object.freeze(["kata"]);
+export const JUDGING_STYLES = Object.freeze(["kata", "shiai"]);
 /** The league each style is drawn in (`drawKyogijo`'s `league`), and the sources its seats are read from (keys of `LEAGUE_SOURCES`). */
-export const JUDGING_LEAGUE = Object.freeze({ kata: { league: "ijf-kata", sources: ["ijf-sor", "ijf-kata-handbook", "ijf-kata-criteria"] } });
+export const JUDGING_LEAGUE = Object.freeze({
+    kata: { league: "ijf-kata", sources: ["ijf-sor", "ijf-kata-handbook", "ijf-kata-criteria"] },
+    shiai: { league: "ijf", sources: ["ijf-sor"] },
+});
 /** The most mat areas an assignment names: the plan's own limit for areas side by side. */
 export const JUDGING_MATS_MAX = 6;

package/dist/judging.draw.js

@@ -7,7 +7,7 @@ import { el, esc, hash, num } from "./format.js";
 import { PLAN_CARD, badge, card } from "./judging.card.js";
 import { fitChart, fitSeats } from "./judging.fit.js";
 import { JUDGING_LEAGUE } from "./judging.data.js";
-import { judgingPlan, judgingSetting } from "./judging.js";
+import { judgingPlan, judgingSetting, seatIn } from "./judging.js";
 import { KYOGIJO_JUDGING_STYLE } from "./judging.style.js";
 import { JUDGING_WORDS } from "./judging.words.js";
 import { fill } from "./strings.js";
@@ -117,26 +117,31 @@ function planMarkup(mat, surface, geom, region, box, m, setting, clip) {
     markup += el("rect", { class: "ky-apron", x, y, width: w, height: h });
     markup += el("g", { class: "ky-ju-plan", "clip-path": `url(#${clip})`, transform: `translate(${num(x - region.x0 * FT * sf)} ${num(y - region.y0 * FT * sf)}) scale(${(sf).toFixed(5)})` }, surface.body);
     markup += el("rect", { class: "ky-ju-plan-frame", x, y, width: w, height: h });
-    // The card of a seat is its chair and the table in front of it: a seat wide and as deep as both.
-    const cardW = (geom.pitch - 0.06) * s;
-    const cardH = (geom.table.y1 - (geom.chairs[0].y0 - 0.05)) * s;
-    const pad = Math.max(2 * m.k, cardW * 0.05);
-    const r = clamp(cardW * 0.2, 6 * m.k, 14 * m.k);
-    const innerW = cardW - 2 * pad;
-    const innerH = cardH - 2 * pad - r;
-    const fitted = fitSeats(mat.seats, { width: innerW, height: innerH, max: Math.min(cardW * 0.3, 26 * m.k), min: m.cardMin, idLabel: words.chart.idLabel });
-    const fits = mat.seats.map((a, i) => !a.assigned || fitted[i] !== undefined);
+    // The card of a seat is the place the plan gives it: for a kata judge its chair and the table in front of it, for a contest's referee and side judges a card of their own.
+    const boxes = mat.seats.map((a) => {
+        const c = geom.places[a.seat.n - 1].card;
+        const cw = (c.x1 - c.x0) * s;
+        const ch = (c.y1 - c.y0) * s;
+        const pad = Math.max(2 * m.k, cw * 0.05);
+        const r = clamp(cw * 0.2, 6 * m.k, 14 * m.k);
+        return { cw, ch, pad, r, width: cw - 2 * pad, height: ch - 2 * pad - r, max: Math.min(cw * 0.3, 26 * m.k) };
+    });
+    const fitted = fitSeats(mat.seats, boxes, { min: m.cardMin, idLabel: words.chart.idLabel });
+    // A seat outside the picture (the referee in a close-up of the bench) has its name in the chart only: it does not fit.
+    const shown = mat.seats.map((a) => seatIn(geom.places[a.seat.n - 1], region));
+    const fits = mat.seats.map((a, i) => !a.assigned || (shown[i] && fitted[i] !== undefined));
     mat.seats.forEach((a, i) => {
-        const chair = geom.chairs[i];
-        const cx = X((chair.x0 + chair.x1) / 2);
-        const top = Y(chair.y0 - 0.05);
+        if (!shown[i])
+            return;
+        const place = geom.places[a.seat.n - 1];
+        const b = boxes[i];
         const fit = fitted[i];
         let g = "";
         if (fit !== undefined)
-            g += card(PLAN_CARD, fit, a.seat.n, cx - cardW / 2, top, cardW, cardH, pad, r, 3 * m.k);
+            g += card(PLAN_CARD, fit, a.seat.n, X(place.card.x0), Y(place.card.y0), b.cw, b.ch, b.pad, b.r, 3 * m.k);
         else {
-            const br = clamp(geom.pitch * s * 0.3, 7 * m.k, 16 * m.k);
-            g += badge(PLAN_CARD, cx, Y((chair.y0 + chair.y1) / 2), br, a.seat.n, a.assigned);
+            const br = clamp(Math.min(b.cw, 1.25 * s) * 0.3, 7 * m.k, 16 * m.k);
+            g += badge(PLAN_CARD, X((place.chair.x0 + place.chair.x1) / 2), Y((place.chair.y0 + place.chair.y1) / 2), br, a.seat.n, a.assigned);
         }
         markup += el("g", { class: "ky-ju-seat", "data-mat": mat.n, "data-seat": a.seat.id, "data-card": fit === undefined ? "no" : "yes" }, g);
     });

package/dist/judging.fit.d.ts

@@ -38,14 +38,17 @@ export declare function fitCard(ask: CardAsk): CardFit | undefined;
  * It always fits, whatever the text, because the row grows.
  */
 export declare function fitChart(ask: Omit<CardAsk, "maxLines" | "breakWords" | "height">): CardFit;
-/**
- * Fit the name and ID of every seat of a mat into a card of one size, as one size for all of them, so that the row of cards reads evenly: each seat that has a name is fitted alone, the smallest size any of them needs is
- * taken, and each is fitted again at that size. A seat whose name does not fit at the floor, or that has nobody in it, has no card (undefined).
- */
-export declare function fitSeats(seats: readonly JudgingAssignment[], box: {
+/** The box a card gives a seat's name and ID, and the biggest size its name may be set in. */
+export interface SeatBox {
     width: number;
     height: number;
     max: number;
+}
+/**
+ * Fit the name and ID of every seat of a mat into its card, as one size for all of them, so that the row of cards reads evenly: each seat that has a name is fitted alone, the smallest size any of them needs is taken, and
+ * each is fitted again at that size. A seat whose name does not fit at the floor, or that has nobody in it, has no card (undefined). `boxes` has the card box of each seat, in order.
+ */
+export declare function fitSeats(seats: readonly JudgingAssignment[], boxes: readonly SeatBox[], limits: {
     min: number;
     idLabel: string;
 }): (CardFit | undefined)[];

package/dist/judging.fit.js

@@ -83,13 +83,13 @@ export function fitChart(ask) {
     return fit;
 }
 /**
- * Fit the name and ID of every seat of a mat into a card of one size, as one size for all of them, so that the row of cards reads evenly: each seat that has a name is fitted alone, the smallest size any of them needs is
- * taken, and each is fitted again at that size. A seat whose name does not fit at the floor, or that has nobody in it, has no card (undefined).
+ * Fit the name and ID of every seat of a mat into its card, as one size for all of them, so that the row of cards reads evenly: each seat that has a name is fitted alone, the smallest size any of them needs is taken, and
+ * each is fitted again at that size. A seat whose name does not fit at the floor, or that has nobody in it, has no card (undefined). `boxes` has the card box of each seat, in order.
  */
-export function fitSeats(seats, box) {
-    const ask = (a, max) => (a.assigned ? fitCard({ name: a.name, id: a.id, idLabel: box.idLabel, width: box.width, height: box.height, max, min: box.min, maxLines: 3, breakWords: false }) : undefined);
-    const alone = seats.map((a) => ask(a, box.max));
+export function fitSeats(seats, boxes, limits) {
+    const ask = (a, i, max) => (a.assigned ? fitCard({ name: a.name, id: a.id, idLabel: limits.idLabel, width: boxes[i].width, height: boxes[i].height, max, min: limits.min, maxLines: 3, breakWords: false }) : undefined);
+    const alone = seats.map((a, i) => ask(a, i, boxes[i].max));
     const sizes = alone.filter((f) => f !== undefined).map((f) => f.nameSize);
-    const common = sizes.length === 0 ? box.max : Math.min(...sizes);
-    return seats.map((a, i) => (alone[i] === undefined ? undefined : ask(a, common)));
+    const common = sizes.length === 0 ? Infinity : Math.min(...sizes);
+    return seats.map((a, i) => (alone[i] === undefined ? undefined : ask(a, i, Math.min(common, boxes[i].max))));
 }

package/dist/judging.js

@@ -1,36 +1,34 @@
 // A judging assignment worked out: the options held to what they may be, each mat's seats with who sits in them, and where the seats are on the plan. The plan is the package's own judo area (`budoPlan`), so that the
 // seats named here are the seats drawn, in metres from the top left of the tatami. Nothing here draws.
 import { budoPlan } from "./budo/plan.js";
-import { JUDGING_LEAGUE, JUDGING_MATS_MAX, JUDGING_SEATS, JUDGING_STYLES } from "./judging.data.js";
+import { JUDGING_LEAGUE, JUDGING_MATS_MAX, JUDGING_SEATS, JUDGING_SEAT_WORDS, JUDGING_STYLES } from "./judging.data.js";
 import { JUDGING_WORDS } from "./judging.words.js";
 import { fill } from "./strings.js";
 /** The longest name, ID and mat label that are taken, in characters. */
 export const JUDGING_LIMITS = Object.freeze({ name: 120, id: 64, label: 40 });
 /** Text made safe to show: control characters become spaces, runs of spaces one, the ends trimmed. */
 const clean = (text) => text.replace(/\p{Cc}/gu, " ").replace(/\s+/g, " ").trim();
-/** The seats of a style. @throws TypeError for a style that is not one. */
-export function seatsOf(style) {
+/** The seats of a style: every one, or without the optional ones (the side judges of a contest). @throws TypeError for a style that is not one. */
+export function seatsOf(style, only = "all") {
     if (typeof style !== "string" || !JUDGING_STYLES.includes(style))
         throw new TypeError(`judging style is ${JUDGING_STYLES.map((s) => `"${s}"`).join(" or ")}`);
-    return JUDGING_SEATS[style];
+    const seats = JUDGING_SEATS[style];
+    return only === "all" ? seats : seats.filter((s) => s.optional !== true);
 }
 /**
- * The seat a name stands for: its number (`3`, `"3"`), its key (`"judge-3"`, `"Judge 3"`) or `"central"`.
+ * The seat a name stands for: its number (`3`, `"3"`), its key (`"judge-3"`, `"Judge 3"`, `"referee"`, `"timekeeper"`) or a word (`"central"`, `"scorer"`, `"jury"`).
  * @throws RangeError for a seat the style does not have, naming the seats it has.
  */
 export function seatOf(style, seat) {
     const seats = seatsOf(style);
-    const text = typeof seat === "number" ? String(seat) : typeof seat === "string" ? seat.trim().toLowerCase() : "";
+    const text = typeof seat === "number" ? String(seat) : typeof seat === "string" ? seat.trim().toLowerCase().replace(/\s+/g, "-") : "";
     let found;
-    if (text === "central" || text === "centre" || text === "center")
-        found = seats.find((s) => s.role === "central");
-    else {
-        const m = /^(?:judge)?[-\s]?(\d{1,2})$/.exec(text);
-        if (m !== null)
-            found = seats.find((s) => s.n === Number(m[1]));
-    }
+    if (/^\d{1,2}$/.test(text))
+        found = seats.find((s) => s.n === Number(text));
+    else
+        found = seats.find((s) => s.id === text) ?? seats.find((s) => JUDGING_SEAT_WORDS[s.id]?.includes(text) === true);
     if (found === undefined)
-        throw new RangeError(`The ${style} area has no seat ${JSON.stringify(seat)}: its seats are ${seats.map((s) => s.id).join(", ")} (or their numbers, or "central")`);
+        throw new RangeError(`The ${style} area has no seat ${JSON.stringify(seat)}: its seats are ${seats.map((s) => s.id).join(", ")} (or their numbers)`);
     return found;
 }
 /** The label of a mat: the caller's, held to its length, else the language's `Mat {n}`. */
@@ -61,15 +59,15 @@ export function judgingSetting(options) {
     if (!Array.isArray(options.mats) || options.mats.length < 1 || options.mats.length > JUDGING_MATS_MAX)
         throw new RangeError(`An assignment has 1 to ${JUDGING_MATS_MAX} mats`);
     const language = options.language === "ja" ? "ja" : "en";
-    const all = options.mats.map((mat, i) => {
+    const given = options.mats.map((mat, i) => {
         if (typeof mat !== "object" || mat === null)
             throw new TypeError("a mat is { label, officials }");
-        const given = new Map();
+        const byId = new Map();
         for (const official of mat.officials ?? []) {
             if (typeof official !== "object" || official === null)
                 throw new TypeError("an official is { seat, name, id }");
             const seat = seatOf(style, official.seat);
-            if (given.has(seat.id))
+            if (byId.has(seat.id))
                 throw new RangeError(`Mat ${i + 1} names seat ${seat.id} twice`);
             if (official.name !== undefined && typeof official.name !== "string")
                 throw new TypeError("an official's name is text");
@@ -81,10 +79,15 @@ export function judgingSetting(options) {
                 throw new RangeError(`A name is at most ${JUDGING_LIMITS.name} characters`);
             if ([...id].length > JUDGING_LIMITS.id)
                 throw new RangeError(`An ID is at most ${JUDGING_LIMITS.id} characters`);
-            given.set(seat.id, { seat, name, id, assigned: name !== "" || id !== "" });
+            byId.set(seat.id, { seat, name, id, assigned: name !== "" || id !== "" });
         }
-        return { n: i + 1, label: matLabel(mat, i + 1, language), seats: seats.map((seat) => given.get(seat.id) ?? { seat, name: "", id: "", assigned: false }) };
+        return byId;
     });
+    if (options.sideJudges !== undefined && typeof options.sideJudges !== "boolean")
+        throw new TypeError("sideJudges is true or false");
+    // The seats that are drawn: every one that is not optional, and an optional one when asked for or when a mat names it.
+    const shown = seats.filter((seat) => seat.optional !== true || options.sideJudges === true || given.some((m) => m.has(seat.id)));
+    const all = options.mats.map((mat, i) => ({ n: i + 1, label: matLabel(mat, i + 1, language), seats: shown.map((seat) => given[i].get(seat.id) ?? { seat, name: "", id: "", assigned: false }) }));
     let mats = all;
     if (options.mat !== undefined) {
         if (!Number.isInteger(options.mat) || options.mat < 1 || options.mat > all.length)
@@ -106,30 +109,89 @@ export function judgingSetting(options) {
     };
 }
 const plans = new Map();
+/** A box of a given centre and size. */
+const around = (cx, cy, w, h) => ({ x0: cx - w / 2, y0: cy - h / 2, x1: cx + w / 2, y1: cy + h / 2 });
+const union = (boxes) => ({ x0: Math.min(...boxes.map((b) => b.x0)), y0: Math.min(...boxes.map((b) => b.y0)), x1: Math.max(...boxes.map((b) => b.x1)), y1: Math.max(...boxes.map((b) => b.y1)) });
+/** A card for a seat that is not at a table (the referee on the mat, a side judge at a corner): 2.6 m by 1.8 m, since there is room round them (ours). */
+const FREE_CARD = { w: 2.6, h: 1.8 };
 /**
- * The judges' bench close up: the seats and the table with a little round them and a few rows of mats in front, from the seats of one mat or of several side by side. `matTop` is where the mats start (the top of the first
- * contest area), so that the picture shows how the bench sits at the mat's edge; `front` instead says how far in front of the table the picture reaches, in metres (the 3D view, which turns, wants as little of the floor as will do).
+ * The judges' bench close up: the seats and their table with a little round them and a few rows of mats in front, from the seats of one mat or of several side by side. `matTop` is where the mats start (the top of the first
+ * contest area), so that the picture shows how the bench sits at the mat's edge; `front` instead says how far in front of the table the picture reaches, in metres (the 3D view, which turns, wants as little of the floor as
+ * will do).
  */
 export function benchOf(chairs, table, pitch, matTop, front) {
     const side = (pitch - 0.5) / 2 + 0.15;
     return { x0: Math.min(...chairs.map((c) => c.x0)) - side, y0: chairs[0].y0 - 0.9, x1: Math.max(...chairs.map((c) => c.x1)) + side, y1: front === undefined ? Math.max(table.y1 + 1.8, matTop + 1.2) : table.y1 + front };
 }
-/** The plan of one mat of a style, with its seats: the package's own judo area, so that the seats named are the seats drawn. */
-export function judgingPlan(style) {
-    const hit = plans.get(style);
+/** A kata area's seats: five chairs behind one table, each with the card that lies over its chair and the table in front of it. */
+function kataPlaces(chairs, table, pitch) {
+    return chairs.map((chair) => {
+        const cx = (chair.x0 + chair.x1) / 2;
+        return { chair, card: { x0: cx - (pitch / 2 - 0.03), y0: chair.y0 - 0.05, x1: cx + (pitch / 2 - 0.03), y1: table.y1 } };
+    });
+}
+/**
+ * A contest's seats round one contest area (ours, but for the referee's: 2 m back from the line the athletes start on, at the centre, facing the table): the timekeeper, the scorekeeper and the referee supervisor in chairs
+ * behind the technical table, 1 m apart, and the side judges at two opposite corners of the contest area, 2 m out from them.
+ */
+function shiaiPlaces(contest, desk) {
+    const cx = (contest.x0 + contest.x1) / 2;
+    const cy = (contest.y0 + contest.y1) / 2;
+    const seat = (x, y, w, h) => ({ chair: around(x, y, 0.5, 0.5), card: around(x, y, w, h) });
+    const chairY = desk.y0 - 0.35;
+    const tableSeat = (x) => ({ chair: around(x, chairY, 0.5, 0.5), card: { x0: x - 0.47, y0: chairY - 0.3, x1: x + 0.47, y1: desk.y1 } });
+    return [
+        seat(cx, cy + 2, FREE_CARD.w, FREE_CARD.h),
+        tableSeat(cx - 1),
+        tableSeat(cx),
+        tableSeat(cx + 1),
+        seat(contest.x0 - 2, contest.y0 - 2, FREE_CARD.w, FREE_CARD.h),
+        seat(contest.x1 + 2, contest.y1 + 2, FREE_CARD.w, FREE_CARD.h),
+    ];
+}
+/** The plan of `count` mats side by side of a style, with its seats: the package's own judo area, so that the seats named are the seats drawn. */
+export function judgingPlan(style, count = 1) {
+    const key = `${style}:${count}`;
+    const hit = plans.get(key);
     if (hit !== undefined)
         return hit;
     seatsOf(style);
-    const plan = budoPlan({ sport: "judo", league: JUDGING_LEAGUE[style].league, budo: { style, officials: true } });
-    const judges = plan.judo?.judges;
-    if (judges === undefined || judges.seats.length !== JUDGING_SEATS[style].length || judges.tables.length === 0)
-        throw new Error(`The ${style} plan has no judges' seats`);
-    const chairs = judges.seats.slice(0, JUDGING_SEATS[style].length);
-    const table = judges.tables[0];
-    const pitch = (chairs[chairs.length - 1].x0 - chairs[0].x0) / (chairs.length - 1);
-    const first = plan.judo.contests[0];
-    const bench = benchOf(chairs, table, pitch, first.y0);
-    const built = { plan, chairs, table, pitch, extent: plan.extent, bench };
-    plans.set(style, built);
+    const plan = budoPlan({ sport: "judo", league: JUDGING_LEAGUE[style].league, budo: { style, officials: true, areas: count } });
+    const judo = plan.judo;
+    const mats = [];
+    for (let mi = 0; mi < count; mi += 1) {
+        const contest = judo.contests[mi];
+        if (style === "kata") {
+            const per = JUDGING_SEATS.kata.length;
+            const chairs = judo.judges.seats.slice(mi * per, (mi + 1) * per);
+            const table = judo.judges.tables[mi];
+            if (chairs.length !== per || table === undefined)
+                throw new Error("The kata plan has no judges' seats");
+            const pitch = (chairs[per - 1].x0 - chairs[0].x0) / (per - 1);
+            mats.push({ places: kataPlaces(chairs, table, pitch), table, bench: benchOf(chairs, table, pitch, contest.y0) });
+        }
+        else {
+            const desk = judo.desks[mi];
+            if (desk === undefined)
+                throw new Error("The contest plan has no technical table");
+            const places = shiaiPlaces(contest, desk);
+            const atTable = places.slice(1, 4);
+            // The bench of a contest is its technical table with the three officials at it; the referee and the side judges are on the mat and at its corners, and are not in the picture of the bench.
+            const bench = { x0: Math.min(...atTable.map((p) => p.card.x0)) - 0.4, y0: atTable[0].chair.y0 - 0.9, x1: Math.max(...atTable.map((p) => p.card.x1)) + 0.4, y1: desk.y1 + 1.8 };
+            mats.push({ places, table: desk, bench });
+        }
+    }
+    const first = mats[0];
+    const chairs = first.places.map((p) => p.chair);
+    const pitch = style === "kata" ? (first.places[first.places.length - 1].chair.x0 - first.places[0].chair.x0) / (first.places.length - 1) : 1;
+    const extent = union([plan.extent, ...first.places.map((p) => p.card), ...first.places.map((p) => p.chair)]);
+    const built = { plan, mats, places: first.places, chairs, table: first.table, bench: first.bench, pitch, extent };
+    plans.set(key, built);
     return built;
 }
+/** Whether a seat is in a box: its card's middle is inside it. A seat that is not is not drawn in a close-up of the bench, and its name is in the chart only. */
+export function seatIn(place, box) {
+    const x = (place.card.x0 + place.card.x1) / 2;
+    const y = (place.card.y0 + place.card.y1) / 2;
+    return x >= box.x0 && x <= box.x1 && y >= box.y0 && y <= box.y1;
+}

package/dist/judging.turn.d.ts

@@ -9,6 +9,7 @@ export declare const JUDGING_HEIGHTS: Readonly<{
     card: 0.95;
     sign: 0.7;
     signAbove: 0.25;
+    post: 1;
 }>;
 /**
  * The four viewpoints of a judging view. A card stands upright, so a high eye squashes its type: the broadcast view is from the mat side, so that the judges' table is at the far side and the cards face the eye, at a

package/dist/judging.turn.js

@@ -1,14 +1,10 @@
-// A judging assignment in 3D: the 3D view of `turn.ts` over the package's own judo floor (`drawKyogijo`, with as many areas side by side as there are mats), with each judge's chair and the judges' table stood up, a name
-// card on the table in front of every judge who has a name (turned to face the eye, so that it is read from wherever the view is) and the name of each mat on a sign over its judges' table. Nothing is drawn a second
-// way: the card is the plan's card (`judging.card.ts`), fitted by the same rule. The model it makes is a `TurnModel`, so the camera, the controls, the pointer, the auto-turn and the tests of every other 3D view are this one's.
-import { budoPlan } from "./budo/plan.js";
 import { drawKyogijo } from "./draw.js";
 import { hash } from "./format.js";
 import { FEET_PER_METRE as FT } from "./geometry.js";
 import { TURN_CARD, badge, card } from "./judging.card.js";
 import { JUDGING_LEAGUE } from "./judging.data.js";
 import { fitCard, fitSeats } from "./judging.fit.js";
-import { benchOf, judgingSetting } from "./judging.js";
+import { benchOf, judgingPlan, judgingSetting, seatIn } from "./judging.js";
 import { judgingDrawing, judgingText } from "./judging.draw.js";
 import { JUDGING_WORDS } from "./judging.words.js";
 import { mountTurn } from "./turn.dom.js";
@@ -18,9 +14,18 @@ import { WORLD_PX, openingView, sceneBox } from "./turn.model.js";
 import { box, n, plane, pole, rect, thinnest } from "./turn.kit.js";
 import { planesOf } from "./uprights.js";
 /** How high things stand, in metres (ours: no rule gives them): the table's top, a chair's seat, a name card on the table, the sign over it. */
-export const JUDGING_HEIGHTS = Object.freeze({ table: 0.75, chair: 0.45, card: 0.95, sign: 0.7, signAbove: 0.25 });
+export const JUDGING_HEIGHTS = Object.freeze({ table: 0.75, chair: 0.45, card: 0.95, sign: 0.7, signAbove: 0.25, post: 1.0 });
 /** The lens of a view close up on several benches at once: the scene turns about the middle of them, and a bench several metres from it would swell as it swung toward the eye, so the lens is long (the default is 8). */
 const BENCHES_LENS = 60;
+/** The bench the 3D view is fitted to when it is close up: a kata's seats at their tables, a contest's technical tables and referees, all mats in one box, reaching as little of the floor in front as will do. */
+function benchNear(style, geom, count) {
+    if (style === "shiai") {
+        const b = geom.mats.slice(0, count).map((m) => m.bench);
+        return { x0: Math.min(...b.map((x) => x.x0)), y0: Math.min(...b.map((x) => x.y0)), x1: Math.max(...b.map((x) => x.x1)), y1: Math.max(...b.map((x) => x.y1)) };
+    }
+    const chairs = geom.mats.slice(0, count).flatMap((m) => m.places.map((p) => p.chair));
+    return benchOf(chairs, geom.table, geom.pitch, geom.plan.judo.contests[0].y0, 2.2);
+}
 const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
 /**
  * The four viewpoints of a judging view. A card stands upright, so a high eye squashes its type: the broadcast view is from the mat side, so that the judges' table is at the far side and the cards face the eye, at a
@@ -44,49 +49,62 @@ export function buildJudgingTurn(options, settings = {}) {
     if (found === null)
         throw new Error("the floor of a 3D view must be an SVG with a viewBox");
     const [vx, vy, vw, vh] = found.slice(1).map(Number);
-    const plan = budoPlan({ sport: "judo", league, budo: { style: setting.style, officials: true, areas: count } });
-    const judges = plan.judo.judges;
-    const seatsPerMat = setting.mats[0].seats.length;
+    const geom = judgingPlan(setting.style, count);
     // The plan's own frame is metres from the top left of the tatami, and the drawing's is feet from the same corner.
     const ft = (m) => m * FT;
     const H = JUDGING_HEIGHTS;
     const items = [];
     const tableTop = ft(H.table);
-    const pitch = judges.seats.length > 1 ? judges.seats[1].x0 - judges.seats[0].x0 : 1.25;
-    const cardW = ft(pitch - 0.06);
     const cardH = ft(H.card);
-    const pad = Math.max(0.08, cardW * 0.05);
-    const r = clamp(cardW * 0.2, 0.2, 0.45);
-    const innerW = cardW - 2 * pad;
-    const innerH = cardH - 2 * pad - r;
     const minName = 0.62;
+    // Close up on the bench, only the seats at it stand (the referee and the side judges of a contest are out of the picture, and in the chart).
+    const near = setting.focus === "bench" ? benchNear(setting.style, geom, count) : undefined;
     setting.mats.forEach((mat, mi) => {
-        const table = judges.tables[mi];
-        const fitted = fitSeats(mat.seats, { width: innerW, height: innerH, max: Math.min(cardW * 0.3, 0.75), min: minName, idLabel: words.chart.idLabel });
+        const places = geom.mats[mi];
+        const table = places.table;
+        const boxes = mat.seats.map((a) => {
+            const c = places.places[a.seat.n - 1].card;
+            const w = ft(c.x1 - c.x0);
+            const pad = Math.max(0.08, w * 0.05);
+            const r = clamp(w * 0.2, 0.2, 0.45);
+            return { w, pad, r, width: w - 2 * pad, height: cardH - 2 * pad - r, max: Math.min(w * 0.3, 0.75) };
+        });
+        const fitted = fitSeats(mat.seats, boxes, { min: minName, idLabel: words.chart.idLabel });
         const furniture = [];
         furniture.push(...box(`m${mat.n}-table`, "desk", rect(ft(table.x0), ft(table.y0), ft(table.x1 - table.x0), ft(table.y1 - table.y0)), tableTop, "u-bench"));
         const cards = [];
+        const stands = [];
         mat.seats.forEach((a, si) => {
-            const chair = judges.seats[mi * seatsPerMat + si];
-            furniture.push(...box(`m${mat.n}-chair-${a.seat.n}`, "chair", rect(ft(chair.x0), ft(chair.y0), ft(chair.x1 - chair.x0), ft(chair.y1 - chair.y0)), ft(H.chair), "u-bench"));
-            const cx = ft((chair.x0 + chair.x1) / 2);
-            const cy = ft((table.y0 + table.y1) / 2);
+            const place = places.places[a.seat.n - 1];
+            if (near !== undefined && !seatIn(place, near))
+                return;
+            const b = boxes[si];
+            // A chair for the seats that have one (the referee stands on the mat).
+            if (a.seat.role !== "referee")
+                furniture.push(...box(`m${mat.n}-chair-${a.seat.n}`, "chair", rect(ft(place.chair.x0), ft(place.chair.y0), ft(place.chair.x1 - place.chair.x0), ft(place.chair.y1 - place.chair.y0)), ft(H.chair), "u-bench"));
+            const cx = ft((place.card.x0 + place.card.x1) / 2);
+            // A card at a table stands on the table; any other on a post, at the height of a standing official's chest.
+            const atTable = a.seat.where === "table";
+            const cy = atTable ? ft((table.y0 + table.y1) / 2) : ft((place.card.y0 + place.card.y1) / 2);
+            const base = atTable ? tableTop : ft(H.post);
+            if (!atTable)
+                stands.push(...pole(`m${mat.n}-post-${a.seat.n}`, "pole", cx, cy, 0, base, ft(0.06), "u-pole"));
             const fit = fitted[si];
             if (fit !== undefined) {
-                const p = plane(`m${mat.n}-card-${a.seat.n}`, "card", [cx - cardW / 2, cy, tableTop + cardH], [cardW, 0, 0], [0, 0, -cardH], card(TURN_CARD, fit, a.seat.n, 0, 0, cardW, cardH, pad, r, 0.1));
+                const p = plane(`m${mat.n}-card-${a.seat.n}`, "card", [cx - b.w / 2, cy, base + cardH], [b.w, 0, 0], [0, 0, -cardH], card(TURN_CARD, fit, a.seat.n, 0, 0, b.w, cardH, b.pad, b.r, 0.1));
                 cards.push({ ...p, billboard: true });
             }
             else {
                 // Nobody in the seat, or a name that does not fit a card: the seat's number alone, on a small badge, with the name in the chart.
                 const br = 0.55;
-                const p = plane(`m${mat.n}-badge-${a.seat.n}`, "card", [cx - br, cy, tableTop + 2 * br], [2 * br, 0, 0], [0, 0, -2 * br], badge(TURN_CARD, br, br, br * 0.92, a.seat.n, a.assigned));
+                const p = plane(`m${mat.n}-badge-${a.seat.n}`, "card", [cx - br, cy, base + 2 * br], [2 * br, 0, 0], [0, 0, -2 * br], badge(TURN_CARD, br, br, br * 0.92, a.seat.n, a.assigned));
                 cards.push({ ...p, billboard: true });
             }
         });
-        // The mat's name on a sign over the whole bench, on a pole at each end of the table.
+        // The mat's name on a sign over the whole table, on a pole at each end of it.
         const midX = ft((table.x0 + table.x1) / 2);
         const midY = ft((table.y0 + table.y1) / 2);
-        const signW = ft(pitch * seatsPerMat);
+        const signW = ft(table.x1 - table.x0);
         const signH = ft(H.sign);
         const signBottom = tableTop + cardH + ft(H.signAbove);
         const text = fitCard({ name: mat.label, id: "", idLabel: "", width: signW * 0.9, height: signH * 0.86, max: signH * 0.62, min: signH * 0.3, maxLines: 2, breakWords: true });
@@ -96,10 +114,9 @@ export function buildJudgingTurn(options, settings = {}) {
         const sign = { ...plane(`m${mat.n}-sign`, "sign", [midX - signW / 2, midY, signBottom + signH], [signW, 0, 0], [0, 0, -signH], `<rect class="u-sign" width="${n(signW)}" height="${n(signH)}" rx="${n(signH * 0.12)}"/>${label}`), billboard: true };
         const poles = [table.x0, table.x1].flatMap((px, k) => pole(`m${mat.n}-sign-pole-${k + 1}`, "pole", ft(px), midY, tableTop, signBottom + signH * 0.5, ft(0.06), "u-pole"));
         items.push({ id: `m${mat.n}-furniture`, kind: "officials", at: [midX, midY], height: tableTop, planes: furniture });
-        items.push({ id: `m${mat.n}-judges`, kind: "judges", at: [midX, midY], height: tableTop + cardH, planes: [...cards, ...poles, sign] });
+        items.push({ id: `m${mat.n}-judges`, kind: "judges", at: [midX, midY], height: tableTop + cardH, planes: [...cards, ...stands, ...poles, sign] });
     });
-    // The view is fitted to the whole floor, or to the judges' bench close up (the scene then turns about the bench, so that the cards stay where they are read).
-    const near = setting.focus === "bench" ? benchOf(judges.seats.slice(0, count * seatsPerMat), judges.tables[0], pitch, plan.judo.contests[0].y0, 2.2) : undefined;
+    // The view is fitted to the whole floor, or to the officials' bench close up (the scene then turns about the bench, so that the cards stay where they are read).
     const area = near === undefined ? { x0: vx, y0: vy, x1: vx + vw, y1: vy + vh } : { x0: ft(near.x0), y0: ft(near.y0), x1: ft(near.x1), y1: ft(near.y1) };
     const uprights = { items, lift: 0, thin: thinnest(vw, vh), area, whole: true };
     const planes = planesOf(uprights);

package/dist/judging.types.d.ts

@@ -1,7 +1,7 @@
 import type { Language } from "./types.ts";
-/** The style a judo area is judged in. `kata` has five judges; `shiai`, the contest, is the next release. */
-export type JudgingStyle = "kata";
-/** One official: the seat, and who sits in it. The seat is its number (`3`, `"3"`), its key (`"judge-3"`) or `"central"` (the middle seat of a kata area). */
+/** The style a judo area is officiated in: `kata` has five judges; `shiai`, the contest, a referee on the mat and the officials at the technical table. */
+export type JudgingStyle = "kata" | "shiai";
+/** One official: the seat, and who sits in it. The seat is its number (`3`, `"3"`), its key (`"judge-3"`, `"referee"`, `"timekeeper"`) or a word (`"central"` for the middle seat of a kata area). */
 export interface JudgingOfficial {
     seat: string | number;
     /** The name as it is to be read, at most 120 characters; a seat with no name is shown as not assigned. */
@@ -26,6 +26,8 @@ export interface JudgingOptions {
     mat?: number;
     /** The chart of mat, seat, name and ID. `auto` (the default) draws it whenever a name or an ID does not fit in its seat, `always` and `never` as they say. */
     chart?: "auto" | "always" | "never";
+    /** Shiai: draw the two side judges' seats too (the IJF's rules for an event with no CARE system use them; its other events have none), as not assigned where nobody is named. A seat a mat names is drawn whatever this says. Off by default. */
+    sideJudges?: boolean;
     /** Where the chart is laid: beside the plan (`landscape`, the default) or under it (`portrait`). */
     orientation?: "landscape" | "portrait";
     /** What the plan shows: the whole `mat` (the default) or the judges' `bench`, close up, so that the names in the seats are as large as they can be. */
@@ -46,10 +48,14 @@ export interface JudgingOptions {
 export interface JudgingSeat {
     /** The key: `judge-3`. */
     id: string;
-    /** The number, from 1, in the order the seats are drawn (left to right as the plan lies, the shomen at the top). */
+    /** The number, from 1, in the order the seats are listed (a kata area's from the left as the plan lies, the shomen at the top). */
     n: number;
-    /** `central` for the middle seat of a kata area. */
-    role: "judge" | "central";
+    /** What the seat is: a kata area's judges (`central` the middle one), or a contest's referee, side judges, timekeeper, scorekeeper and referee supervisor. */
+    role: "judge" | "central" | "referee" | "side-judge" | "timekeeper" | "scorekeeper" | "supervisor";
+    /** Where it is: at the judges' table of a kata area or the technical table of a contest (`table`), on the mat (`mat`: the referee) or at a corner of the area (`corner`: a side judge). */
+    where: "table" | "mat" | "corner";
+    /** True for a seat that is drawn only when asked for or named (the side judges). */
+    optional?: true;
     label: {
         en: string;
         ja: string;

package/dist/judging.words.d.ts

@@ -5,6 +5,7 @@ export interface JudgingWords {
     /** What a style is called on the plan, `{count}` the number of seats. */
     styleName: {
         kata: string;
+        shiai: string;
     };
     /** The chart: its heading, its columns, the word before an ID and what a seat with nobody in it says. */
     chart: {

package/dist/judging.words.js

@@ -1,7 +1,7 @@
 export const JUDGING_WORDS = {
     en: {
         mat: "Mat {n}",
-        styleName: { kata: "Kata, {count} judges" },
+        styleName: { kata: "Kata, {count} judges", shiai: "Shiai, {count} officials" },
         chart: { heading: "Judging assignments", seat: "Seat", name: "Name", id: "ID", idLabel: "ID", vacant: "Not assigned" },
         say: {
             title: "Judging assignments: {style}, {mats}",
@@ -20,7 +20,7 @@ export const JUDGING_WORDS = {
     },
     ja: {
         mat: "第{n}試合場",
-        styleName: { kata: "形（{count}人制）" },
+        styleName: { kata: "形（{count}人制）", shiai: "試合（{count}人体制）" },
         chart: { heading: "審判員の配置", seat: "席", name: "氏名", id: "ID", idLabel: "ID", vacant: "未定" },
         say: {
             title: "審判員の配置：{style}、{mats}",

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.17.0";
+export declare const VERSION = "0.18.0";

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.17.0";
+export const VERSION = "0.18.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johnmorrisdotca/kyogijo-stadiums",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Kyogijo Stadiums 競技場, 39 sports' surfaces as SVG, drawn to scale from the rulebooks: NFL, CFL and IFAF football fields, an NHL rink, an NBA court, MLB ballparks, soccer pitches, curling sheets, athletics stadiums, speed skating, short track and figure skating rinks, swimming pools, water polo fields, diving wells, artistic swimming areas, and the courts and fields of tennis, volleyball (indoor, beach and sitting), badminton, pickleball, table tennis, padel, squash, racquetball, sepak takraw, teqball, roundnet, netball, lacrosse, rugby, Australian football, Gaelic games, cricket, field hockey and handball, and the budo of judo, karate, kendo, sumo and kyudo with a dojo of tatami laid as real units, with each team's name and logo on its side and the score in the middle, stands and a crowd, a pageant of flags, and a 3D view. Light and dark, accessible, a compact badge for lists, a helper for React and a custom element. Zero dependencies.",
   "keywords": [
     "sports",