Retours du test sur téléphone : feuille de route, plans, Playwright validé

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Makefile

@@ -107,6 +107,8 @@ lint: ## Vérifie le style et les erreurs courantes
 deploy: site ## Sert l'application sur le réseau local (Ctrl+C pour arrêter)
 	@ip="$$(ip -4 route get 1.1.1.1 2>/dev/null | awk '{ for (i = 1; i < NF; i++) if ($$i == "src") print $$(i + 1) }')"; \
 	echo "Application : http://$${ip:-ADRESSE-DU-PC}:$(WEB_PORT)/"; \
+	echo "Test du moteur : http://$${ip:-ADRESSE-DU-PC}:$(WEB_PORT)/moteur/"; \
+	echo "Page de mesure : http://$${ip:-ADRESSE-DU-PC}:$(WEB_PORT)/moteur/bench.html"; \
 	echo "À ouvrir depuis le téléphone, sur le même Wi-Fi. Ctrl+C pour arrêter."
 	@docker run --rm --init -p $(WEB_PORT):8080 -v "$(CURDIR)/$(BUILD_DIR)/site:/site:ro" \
 		$(BUILD_C_IMAGE) python3 -m http.server 8080 --directory /site
@@ -121,7 +123,7 @@ SITE_ICONS := icone.svg icone-192.png icone-512.png icone-maskable-192.png icone
 
 # Le site tel qu'il sera publié, reconstruit entièrement à chaque appel :
 # - web/ à la racine : la page de l'application, son style, sa police, le
-#   manifeste et le Web Worker du moteur ;
+#   manifeste, le Web Worker du moteur, et les pages de test sous moteur/ ;
 # - sous icons/, le logo et les icônes de la charte, copiés depuis
 #   docs/identite/logo/ (une seule source, ADR 0010) ;
 # - l'application compilée (build/web/src/) sous app/ ;

app/src/domain/game/game.ts

@@ -79,10 +79,9 @@ export class Game {
     readonly #dice: DiceSource;
     readonly #ply: Ply;
     #journal: GameJournal = EMPTY_JOURNAL;
-    // Coup du joueur en cours de saisie : pas encore dans le journal (il n'y
-    // entre qu'à sa validation, confirmMove). Pour chaque demi-coup saisi, la
-    // position après lui, et si le coup est alors complet, selon le moteur.
-    #pending: PendingHalfMove[] = [];
+    // Coup du joueur en cours de saisie : pas encore dans le journal.
+    #pending: HalfMove[] = [];
+    #pendingPosition: PositionId | null = null;
 
     private constructor(engine: Engine, options: GameOptions) {
         this.#engine = engine;
@@ -142,37 +141,12 @@ export class Game {
 
     /** Les demi-coups déjà saisis du coup en cours. */
     get pendingHalfMoves(): readonly HalfMove[] {
-        return this.#pending.map((p) => p.halfMove);
-    }
-
-    /** Les demi-coups saisis forment un coup complet (le moteur le dit) : il
-     * n'attend plus que d'être validé (confirmMove) ou défait
-     * (undoLastHalfMove). */
-    get moveComplete(): boolean {
-        return this.#pending.at(-1)?.complete === true;
+        return this.#pending;
     }
 
     /** La position à afficher : après les demi-coups déjà saisis. */
     get displayedPosition(): PositionId {
-        return this.#pending.at(-1)?.position ?? this.state.position;
-    }
-
-    /**
-     * Les dés du jet à jouer (quatre pour un double), et pour chacun s'il est
-     * déjà utilisé par un demi-coup saisi ; liste vide hors de la saisie d'un
-     * coup du joueur. Un demi-coup utilise le dé qui l'a produit dans
-     * nextHalfMoves (de from vers from - dé, ou vers la sortie) : aucune
-     * règle n'est jugée ici, la légalité vient du moteur.
-     */
-    get diceToPlay(): DieToPlay[] {
-        const state = this.state;
-        if (state.turn !== "player" || state.phase !== "moving" || state.roll === null) {
-            return [];
-        }
-        const [a, b] = state.roll;
-        const dice = a === b ? [a, a, a, a] : [a, b];
-        const used = assignDice(dice, this.pendingHalfMoves);
-        return dice.map((value, i) => ({ value, used: used[i] === true }));
+        return this.#pendingPosition ?? this.state.position;
     }
 
     /** Le plateau affiché (après les demi-coups déjà saisis), décodé par le
@@ -231,7 +205,7 @@ export class Game {
      */
     async nextHalfMoves(): Promise<HalfMove[]> {
         const state = this.state;
-        if (state.turn !== "player" || state.phase !== "moving" || this.moveComplete) {
+        if (state.turn !== "player" || state.phase !== "moving") {
             return [];
         }
         const roll = rollToPlay(state);
@@ -246,7 +220,7 @@ export class Game {
         const moves = [...candidates.values()];
         const checks = await Promise.all(
             moves.map((h) =>
-                this.#engine.checkHalfMoves(state.position, roll, [...this.pendingHalfMoves, h]),
+                this.#engine.checkHalfMoves(state.position, roll, [...this.#pending, h]),
             ),
         );
         return moves.filter((_, i) => checks[i]?.valid === true);
@@ -300,51 +274,34 @@ export class Game {
 
     /**
      * Le joueur déplace un pion (un dé). Renvoie false si ce demi-coup ne
-     * mène à aucun coup légal (ou si le coup est déjà complet) : il est
-     * refusé et rien ne change. Le coup n'est pas joué pour autant : une fois
-     * complet (moveComplete), il attend d'être validé (confirmMove).
+     * mène à aucun coup légal : il est refusé et rien ne change. Quand les
+     * demi-coups forment un coup complet, le coup est joué.
      */
     async playHalfMove(halfMove: HalfMove): Promise<boolean> {
         const state = this.#expect("player", "moving");
-        if (this.moveComplete) {
-            return false;
-        }
-        const check = await this.#engine.checkHalfMoves(state.position, rollToPlay(state), [
-            ...this.pendingHalfMoves,
-            halfMove,
-        ]);
+        const halfMoves = [...this.#pending, halfMove];
+        const check = await this.#engine.checkHalfMoves(
+            state.position,
+            rollToPlay(state),
+            halfMoves,
+        );
         if (!check.valid || check.position === null) {
             return false;
         }
-        this.#pending = [
-            ...this.#pending,
-            { halfMove, position: check.position, complete: check.complete },
-        ];
+        if (check.complete) {
+            this.cancelHalfMoves();
+            await this.#playMove("player", halfMoves, check.position);
+        } else {
+            this.#pending = halfMoves;
+            this.#pendingPosition = check.position;
+        }
         return true;
     }
 
-    /** Défait le dernier demi-coup saisi du coup en cours (rien s'il n'y en a
-     * pas) : il n'a jamais été dans le journal. */
-    undoLastHalfMove(): void {
-        this.#pending = this.#pending.slice(0, -1);
-    }
-
-    /** Oublie tous les demi-coups saisis du coup en cours. */
+    /** Oublie les demi-coups saisis du coup en cours. */
     cancelHalfMoves(): void {
         this.#pending = [];
-    }
-
-    /** Le joueur valide son coup complet : il entre dans le journal
-     * (MovePlayed) et le tour passe. Erreur si le coup n'est pas complet. */
-    async confirmMove(): Promise<void> {
-        this.#expect("player", "moving");
-        const last = this.#pending.at(-1);
-        if (last?.complete !== true) {
-            throw new Error("le coup n'est pas complet : jouez encore");
-        }
-        const halfMoves = this.pendingHalfMoves;
-        this.cancelHalfMoves();
-        await this.#playMove("player", halfMoves, last.position);
+        this.#pendingPosition = null;
     }
 
     /** Le joueur double, avant de lancer les dés ; l'ordinateur prend ou passe
@@ -497,52 +454,6 @@ export class Game {
     }
 }
 
-/** Un dé du jet à jouer, et s'il est déjà utilisé par un demi-coup saisi. */
-export interface DieToPlay {
-    readonly value: number;
-    readonly used: boolean;
-}
-
-/** Un demi-coup saisi, pas encore validé. */
-interface PendingHalfMove {
-    readonly halfMove: HalfMove;
-    /** La position après lui, vue du joueur. */
-    readonly position: PositionId;
-    /** Les demi-coups saisis jusqu'à lui forment un coup complet. */
-    readonly complete: boolean;
-}
-
-/**
- * Quels dés les demi-coups ont utilisés : chaque demi-coup reçoit un dé
- * différent qui le produit (de from vers from - dé, ou vers la sortie si le
- * dé dépasse), comme les candidats de nextHalfMoves. Les dés sont essayés du
- * plus petit au plus grand : un pion sorti l'est avec le plus petit dé
- * suffisant. Si aucune répartition ne convient, les premiers dés sont
- * marqués, un par demi-coup.
- */
-function assignDice(dice: readonly number[], halfMoves: readonly HalfMove[]): boolean[] {
-    const order = dice.map((_, i) => i).sort((i, j) => (dice[i] ?? 0) - (dice[j] ?? 0));
-    const used = dice.map(() => false);
-    const fits = (h: HalfMove, die: number) => Math.max(h.from - die, OFF) === h.to;
-    const place = (k: number): boolean => {
-        const h = halfMoves[k];
-        if (h === undefined) {
-            return true;
-        }
-        for (const i of order) {
-            if (!used[i] && fits(h, dice[i] ?? 0)) {
-                used[i] = true;
-                if (place(k + 1)) {
-                    return true;
-                }
-                used[i] = false;
-            }
-        }
-        return false;
-    };
-    return place(0) ? used : dice.map((_, i) => i < halfMoves.length);
-}
-
 /** Le jet à jouer, en phase moving. */
 function rollToPlay(state: GameState): Roll {
     if (state.roll === null) {

app/src/ui/app.ts

@@ -13,22 +13,8 @@ import type { GameJournal } from "../domain/game/events.js";
 import type { Game, MoveSteps, SideBoards } from "../domain/game/game.js";
 import { formatHalfMoves, type HalfMove } from "../domain/game/position.js";
 import { otherSide, type Side } from "../domain/game/side.js";
-import {
-    boardModel,
-    moveTargets,
-    moveTrace,
-    onlyHalfMove,
-    type Place,
-    placeOf,
-} from "./board-model.js";
-import {
-    checkerSpot,
-    type DiceAction,
-    NO_MARKS,
-    renderBoard,
-    type ShownDie,
-    slideChecker,
-} from "./board-view.js";
+import { boardModel, moveTargets, moveTrace, type Place, placeOf } from "./board-model.js";
+import { checkerSpot, NO_MARKS, renderBoard, type ShownDie, slideChecker } from "./board-view.js";
 import { showHelp } from "./help.js";
 import { TEXTS } from "./texts.js";
 
@@ -65,7 +51,6 @@ export function startApp(options: AppOptions): void {
         double: byId<HTMLButtonElement>("double"),
         take: byId<HTMLButtonElement>("take"),
         drop: byId<HTMLButtonElement>("drop"),
-        confirm: byId<HTMLButtonElement>("confirm"),
         cancel: byId<HTMLButtonElement>("cancel"),
         skip: byId<HTMLButtonElement>("skip"),
         replay: byId<HTMLButtonElement>("replay"),
@@ -76,19 +61,12 @@ export function startApp(options: AppOptions): void {
         game: byId("game"),
         help: byId("help"),
         helpContent: byId("help-content"),
-        doubleDialog: byId<HTMLDialogElement>("double-dialog"),
-        doubleQuestion: byId("double-question"),
-        doubleConfirm: byId<HTMLButtonElement>("double-confirm"),
-        doubleCancel: byId<HTMLButtonElement>("double-cancel"),
     };
     ui.board.setAttribute("aria-label", TEXTS.boardLabel);
     ui.roll.textContent = TEXTS.roll;
     ui.double.textContent = TEXTS.double;
     ui.take.textContent = TEXTS.take;
     ui.drop.textContent = TEXTS.drop;
-    ui.confirm.textContent = TEXTS.confirm;
-    ui.doubleConfirm.textContent = TEXTS.double;
-    ui.doubleCancel.textContent = TEXTS.cancel;
     ui.cancel.textContent = TEXTS.cancel;
     ui.skip.textContent = TEXTS.skip;
     ui.replay.textContent = TEXTS.replay;
@@ -153,9 +131,9 @@ export function startApp(options: AppOptions): void {
                     shownMove === null
                         ? null
                         : moveTrace(shownMove.side, shownMove.halfMoves, shownMove.hits),
-                // Mêmes conditions que les boutons « Lancer les dés »,
-                // « Valider » et « Doubler ».
-                diceAction: busy ? null : diceAction(game),
+                // Mêmes conditions que les boutons « Lancer les dés » et
+                // « Doubler ».
+                canRoll: !busy && state.turn === "player" && state.phase === "rolling",
                 canDouble: !busy && canDouble,
             });
         }
@@ -178,7 +156,6 @@ export function startApp(options: AppOptions): void {
         show(ui.roll, player && state.phase === "rolling");
         show(ui.double, player && state.phase === "rolling");
         ui.double.disabled = busy || !canDouble;
-        show(ui.confirm, player && state.phase === "moving" && game.moveComplete);
         show(ui.cancel, player && state.phase === "moving" && !stuck);
         show(ui.skip, stuck);
         ui.cancel.disabled = busy || game.pendingHalfMoves.length === 0;
@@ -191,7 +168,6 @@ export function startApp(options: AppOptions): void {
             ui.roll,
             ui.take,
             ui.drop,
-            ui.confirm,
             ui.skip,
             ui.replay,
             ui.again,
@@ -328,22 +304,11 @@ export function startApp(options: AppOptions): void {
             await g.skipTurn();
         });
 
-    // Doubler demande confirmation : un double proposé ne se reprend pas.
-    ui.double.onclick = () => {
-        if (busy || game === null || !canDouble) {
-            return;
-        }
-        ui.doubleQuestion.textContent = TEXTS.confirmDouble(2 * game.state.cube.value);
-        ui.doubleDialog.showModal();
-    };
-    ui.doubleCancel.onclick = () => ui.doubleDialog.close();
-    ui.doubleConfirm.onclick = () => {
-        ui.doubleDialog.close();
-        void act(async (g) => {
+    ui.double.onclick = () =>
+        act(async (g) => {
             await g.double();
             info = g.state.phase === "over" ? "" : TEXTS.computerTakes(g.state.cube.value);
         });
-    };
 
     ui.take.onclick = () =>
         act((g) => {
@@ -357,23 +322,12 @@ export function startApp(options: AppOptions): void {
             info = "";
         });
 
-    // Le coup saisi, complet, entre dans la partie : le tour passe.
-    ui.confirm.onclick = () =>
-        act(async (g) => {
-            info = "";
-            await g.confirmMove();
-        });
-
-    // Annuler défait le dernier demi-coup saisi, un par un. L'écran est
-    // occupé le temps que le moteur recalcule les coups possibles.
     ui.cancel.onclick = () => {
         if (!busy && game !== null) {
-            game.undoLastHalfMove();
+            game.cancelHalfMoves();
             selected = null;
             shownMove = null;
-            busy = true;
-            render();
-            void settle(false);
+            void refresh();
         }
     };
 
@@ -390,30 +344,15 @@ export function startApp(options: AppOptions): void {
     ui.newGame.onclick = newGame;
     ui.again.onclick = newGame;
 
-    /** Joue un demi-coup du joueur ; le coup attend ensuite sa suite ou sa
-     * validation. */
-    function playHalfMove(halfMove: HalfMove): void {
-        void act(async (g) => {
-            info = "";
-            await g.playHalfMove(halfMove);
-        });
-    }
-
-    // Toucher le plateau : un pion jouable, puis une de ses cases d'arrivée
-    // (ou aucune, s'il n'en a qu'une : il y va tout de suite).
+    // Toucher le plateau : un pion jouable, puis une de ses cases d'arrivée.
     ui.board.addEventListener("click", (event) => {
         const target = event.target as Element | null;
-        // Toucher les dés (d'un côté ou de l'autre du plateau) ou le videau :
-        // comme leurs boutons.
+        // Toucher les dés en attente ou le videau : comme leurs boutons.
         const action = target?.closest("[data-action]")?.getAttribute("data-action");
         if (action === "roll" && !ui.roll.hidden && !ui.roll.disabled) {
             ui.roll.click();
             return;
         }
-        if (action === "confirm" && !ui.confirm.hidden && !ui.confirm.disabled) {
-            ui.confirm.click();
-            return;
-        }
         if (action === "double" && !ui.double.hidden && !ui.double.disabled) {
             ui.double.click();
             return;
@@ -424,12 +363,10 @@ export function startApp(options: AppOptions): void {
         }
         const halfMove = selected === null ? undefined : targets.get(selected)?.get(place);
         if (halfMove !== undefined) {
-            playHalfMove(halfMove);
-            return;
-        }
-        const only = place === selected ? null : onlyHalfMove(targets, place);
-        if (only !== null) {
-            playHalfMove(only);
+            void act(async (g) => {
+                info = "";
+                await g.playHalfMove(halfMove);
+            });
             return;
         }
         selected = targets.has(place) && place !== selected ? place : null;
@@ -468,7 +405,6 @@ export function startApp(options: AppOptions): void {
         ui.double,
         ui.take,
         ui.drop,
-        ui.confirm,
         ui.cancel,
         ui.skip,
         ui.replay,
@@ -516,44 +452,19 @@ function rollBefore(game: Game): readonly number[] {
     return rolled?.type === "DiceRolled" ? rolled.roll : [];
 }
 
-/** Ce que fait un toucher sur les dés : lancer quand le joueur peut lancer,
- * valider quand son coup est complet. */
-function diceAction(game: Game): DiceAction | null {
-    const state = game.state;
-    if (state.turn !== "player") {
-        return null;
-    }
-    if (state.phase === "rolling") {
-        return "roll";
-    }
-    return state.phase === "moving" && game.moveComplete ? "confirm" : null;
-}
-
-/** Les dés à montrer : le dernier jet, de la couleur de qui l'a lancé (au
- * jet d'ouverture, un dé chacun ; quatre pour un double). Pendant que le
- * joueur saisit son coup, chaque dé déjà utilisé est estompé. Ils sont
- * barrés si le jet ne permet aucun coup : le joueur est bloqué (stuck), ou
- * l'ordinateur vient de passer son tour sans bouger. */
+/** Les dés à montrer : le dernier jet, de la couleur de qui l'a lancé
+ * (au jet d'ouverture, un dé chacun). Ils sont barrés si le jet ne permet
+ * aucun coup : le joueur est bloqué (stuck), ou l'ordinateur vient de passer
+ * son tour sans bouger. */
 function shownDice(game: Game, stuck: boolean): ShownDie[] {
-    const toPlay = game.diceToPlay;
     const rolled = game.events.findLast((e) => e.type === "DiceRolled");
     if (rolled?.type !== "DiceRolled") {
         return [];
     }
-    // Au jet d'ouverture, un dé chacun.
-    const sideOf = (i: number): Side => rolled.side ?? (i === 0 ? "player" : "computer");
-    if (toPlay.length > 0) {
-        return toPlay.map((die, i) => ({
-            value: die.value,
-            side: sideOf(i),
-            blocked: stuck,
-            used: die.used,
-        }));
-    }
-    const blocked = computerCouldNotMove(game);
-    const [a, b] = rolled.roll;
-    const values = a === b ? [a, a, a, a] : [a, b];
-    return values.map((value, i) => ({ value, side: sideOf(i), blocked, used: false }));
+    const blocked = stuck || computerCouldNotMove(game);
+    const sides: Side[] =
+        rolled.side === null ? ["player", "computer"] : [rolled.side, rolled.side];
+    return rolled.roll.map((value, i) => ({ value, side: sides[i] ?? "player", blocked }));
 }
 
 /** La dernière chose jouée (fin de partie mise à part) est un tour de
@@ -608,9 +519,6 @@ function prompt(game: Game, selecting: boolean, canDouble: boolean): string {
     if (state.phase === "rolling") {
         return canDouble ? TEXTS.yourRoll : TEXTS.yourRollNoDouble;
     }
-    if (state.phase === "moving" && game.moveComplete) {
-        return TEXTS.confirmOrUndo;
-    }
     if (state.phase === "moving" && state.roll !== null) {
         return selecting ? TEXTS.pickTarget : TEXTS.yourMove(state.roll);
     }

app/src/ui/board-model.ts

@@ -82,19 +82,6 @@ export function moveTargets(halfMoves: readonly HalfMove[]): Map<Place, Map<Plac
     return targets;
 }
 
-/** Le seul demi-coup possible depuis place, s'il n'a qu'une case d'arrivée
- * (le pion y va dès qu'on le touche) ; null sinon. */
-export function onlyHalfMove(
-    targets: ReadonlyMap<Place, ReadonlyMap<Place, HalfMove>>,
-    place: Place,
-): HalfMove | null {
-    const tos = targets.get(place);
-    if (tos === undefined || tos.size !== 1) {
-        return null;
-    }
-    return [...tos.values()][0] ?? null;
-}
-
 /** Ce qui reste dessiné d'un coup une fois joué. */
 export interface MoveTrace {
     /** Le camp qui a joué. */
@@ -139,14 +126,6 @@ export function moveTrace(
     return { side, arrows, landed, left, hits: hits.filter(Boolean).length };
 }
 
-/** La couleur d'une flèche (case), d'après son numéro affiché (1 à 24,
- * pour le joueur) : impaire en point-a, paire en point-b (charte). Jamais
- * d'après sa colonne : les cases 12 et 13, l'une au-dessus de l'autre,
- * n'ont pas la même couleur. */
-export function pointColor(number: number): "point-a" | "point-b" {
-    return number % 2 === 1 ? "point-a" : "point-b";
-}
-
 /** Où se trouve une case sur le dessin : rangée du haut ou du bas, et
  * colonne de 0 (à gauche) à 11 (à droite), sans compter la barre. */
 export function pointSlot(number: number): { top: boolean; column: number } {

app/src/ui/board-view.ts

@@ -11,13 +11,7 @@
 
 import type { Cube } from "../domain/game/cube.js";
 import type { Side } from "../domain/game/side.js";
-import {
-    type BoardModel,
-    type MoveTrace,
-    type Place,
-    pointColor,
-    pointSlot,
-} from "./board-model.js";
+import { type BoardModel, type MoveTrace, type Place, pointSlot } from "./board-model.js";
 import { TEXTS } from "./texts.js";
 
 /** Un dé affiché, de la couleur du camp qui l'a lancé. */
@@ -26,13 +20,8 @@ export interface ShownDie {
     readonly side: Side;
     /** Le jet ne permet aucun coup : le dé est estompé et barré. */
     readonly blocked: boolean;
-    /** Le dé est déjà utilisé par un demi-coup saisi : il est estompé. */
-    readonly used: boolean;
 }
 
-/** Ce que fait un toucher sur les dés : lancer, ou valider le coup saisi. */
-export type DiceAction = "roll" | "confirm";
-
 /** Ce qui s'ajoute aux pions : dés, videau, mises en évidence. */
 export interface BoardDecor {
     readonly dice: readonly ShownDie[];
@@ -44,10 +33,8 @@ export interface BoardDecor {
     readonly targets: ReadonlySet<Place>;
     /** Les traces du dernier coup de l'ordinateur, tant qu'on les montre. */
     readonly trace: MoveTrace | null;
-    /** Ce que fait un toucher sur la zone des dés, d'un côté ou de l'autre
-     * du plateau (null : rien). Pour « roll », les dés du joueur en attente
-     * sont dessinés. */
-    readonly diceAction: DiceAction | null;
+    /** Le joueur peut lancer les dés : ses dés en attente se touchent. */
+    readonly canRoll: boolean;
     /** Le joueur peut doubler : le videau se touche. */
     readonly canDouble: boolean;
 }
@@ -58,7 +45,7 @@ export const NO_MARKS = {
     selected: null,
     targets: new Set<Place>(),
     trace: null,
-    diceAction: null,
+    canRoll: false,
     canDouble: false,
 } as const;
 
@@ -171,16 +158,9 @@ export function renderBoard(svg: SVGSVGElement, board: BoardModel, decor: BoardD
     if (decor.trace !== null) {
         drawTrace(svg, board, decor.trace);
     }
-    if (decor.diceAction !== null) {
-        if (decor.diceAction === "roll") {
-            waitingDice(svg);
-        }
-        // Une zone sur chaque moitié du plateau : les dés en attente (à
-        // gauche) comme le dernier jet (à droite) se touchent.
-        const label = decor.diceAction === "roll" ? TEXTS.roll : TEXTS.confirm;
-        for (const x of [FRAME + HALF_WIDTH / 2, RIGHT_HALF + HALF_WIDTH / 2]) {
-            addAction(hits, decor.diceAction, label, { x, y: MIDDLE }, HALF_WIDTH - 2 * FRAME);
-        }
+    if (decor.canRoll) {
+        const center = waitingDice(svg);
+        addAction(hits, "roll", TEXTS.roll, center, 2 * DIE + 8 + MIN_TARGET / 2);
     }
     if (decor.canDouble) {
         cube.classList.add("can-double");
@@ -227,7 +207,7 @@ function drawPoint(
     const base = top ? FRAME : HEIGHT - FRAME;
     const tip = top ? FRAME + POINT_HEIGHT : HEIGHT - FRAME - POINT_HEIGHT;
     add(svg, "polygon", {
-        class: pointColor(number),
+        class: column % 2 === 0 ? "point-a" : "point-b",
         points: `${left},${base} ${left + POINT_WIDTH},${base} ${center},${tip}`,
     });
     add(
@@ -513,9 +493,7 @@ function drawDice(svg: SVGSVGElement, dice: readonly ShownDie[]): void {
         const x = center - total / 2 + i * (DIE + gap);
         const y = MIDDLE - DIE / 2;
         const group = add(svg, "g", {
-            class: ["die", die.blocked ? "die-blocked" : "", die.used ? "die-used" : ""]
-                .filter(Boolean)
-                .join(" "),
+            class: die.blocked ? "die die-blocked" : "die",
             "data-value": die.value,
         });
         add(group, "rect", { class: `die-${die.side}`, x, y, width: DIE, height: DIE, rx: 6 });
@@ -557,8 +535,9 @@ function cubeCenter(cube: Cube): Spot {
 }
 
 /** Les dés du joueur en attente d'être lancés, faces vides, au milieu de la
- * moitié gauche (la droite garde le dernier jet de l'ordinateur). */
-function waitingDice(svg: SVGSVGElement): void {
+ * moitié gauche (la droite garde le dernier jet de l'ordinateur). Renvoie
+ * leur centre. */
+function waitingDice(svg: SVGSVGElement): Spot {
     const center = { x: FRAME + HALF_WIDTH / 2, y: MIDDLE };
     const gap = 8;
     const group = add(svg, "g", { class: "die die-waiting" });
@@ -572,13 +551,13 @@ function waitingDice(svg: SVGSVGElement): void {
             rx: 6,
         });
     }
+    return center;
 }
 
 /**
  * Une zone à toucher qui fait la même chose qu'un bouton (lancer les dés,
- * valider le coup, doubler) : au moins MIN_TARGET de côté, centrée sur ce
- * qu'on touche, avec un rôle et un nom accessibles. Les boutons restent
- * pour le clavier.
+ * doubler) : au moins MIN_TARGET de côté, centrée sur ce qu'on touche, avec
+ * un rôle et un nom accessibles. Les boutons restent pour le clavier.
  */
 function addAction(
     hits: Element,

app/src/ui/help.ts

@@ -91,8 +91,10 @@ export async function showHelp(container: HTMLElement): Promise<void> {
             renderFeature(container, feature);
         }
         renderGlossary(container, glossary);
-        const about = element(container, "p", TEXTS.about);
+        const about = element(container, "p", `${TEXTS.about} `);
         about.className = "about";
+        const link = element(about, "a", TEXTS.engineTestLink);
+        link.href = "moteur/";
         container.dataset.loaded = "true";
     } catch {
         status.textContent = TEXTS.helpFailed;

app/src/ui/texts.ts

@@ -36,7 +36,6 @@ export const TEXTS = {
     double: "Doubler",
     take: "Prendre",
     drop: "Passer",
-    confirm: "Valider",
     cancel: "Annuler",
     skip: "Continuer",
     replay: "Revoir",
@@ -61,8 +60,6 @@ export const TEXTS = {
     yourMove: (dice: readonly number[]) =>
         `Jouez ${roll(dice)} : touchez un pion, puis sa case d'arrivée.`,
     pickTarget: "Touchez une case d'arrivée en surbrillance, ou un autre pion.",
-    confirmOrUndo:
-        "Touchez vos dés ou « Valider » pour jouer ce coup, ou « Annuler » pour reprendre un pion.",
     youCannotMove: (dice: readonly number[]) => `Aucun coup possible avec ${roll(dice)}.`,
     pressContinue: "Touchez « Continuer » : le tour passe à l'ordinateur.",
     thinking: "L'ordinateur réfléchit…",
@@ -70,7 +67,6 @@ export const TEXTS = {
         `L'ordinateur a joué ${roll(dice)} : ${move} (${seconds(ms)}).`,
     computerCannotMove: (dice: readonly number[]) =>
         `L'ordinateur ne peut pas jouer ${roll(dice)}.`,
-    confirmDouble: (value: number) => `Doubler à ${value} ? L'ordinateur pourra prendre ou passer.`,
     computerDoubles: "L'ordinateur vous propose de doubler : prenez ou passez.",
     computerTakes: (value: number) =>
         `L'ordinateur prend : la partie vaut maintenant ${points(value)}.`,
@@ -94,4 +90,5 @@ export const TEXTS = {
     helpLoading: "Chargement de l'aide…",
     helpFailed: "L'aide n'a pas pu se charger.",
     about: "Ustagammon est un logiciel libre (GPLv3). L'ordinateur joue avec GNU Backgammon.",
+    engineTestLink: "Test du moteur",
 } as const;

app/tests/full-game.test.ts

@@ -45,8 +45,6 @@ async function playToTheEnd(game: Game, engine: Awaited<ReturnType<typeof loadNo
             for (const halfMove of first.halfMoves) {
                 assert.equal(await game.playHalfMove(halfMove), true);
             }
-            assert.equal(game.moveComplete, true);
-            await game.confirmMove();
         }
     }
     return actions;

app/tests/game.test.ts

@@ -78,111 +78,14 @@ test("un coup se saisit demi-coup par demi-coup ; un demi-coup refusé ne change
     assert.deepEqual(game.pendingHalfMoves, [{ from: 8, to: 5 }]);
     assert.equal(await game.playHalfMove({ from: 6, to: 5 }), true);
 
-    // Coup complet : il attend la validation, hors du journal.
-    assert.equal(game.moveComplete, true);
-    assert.equal(game.displayedPosition, "AFTER");
-    assert.equal(game.events.length, 2);
-    assert.equal(game.state.turn, "player");
-    assert.deepEqual(await game.nextHalfMoves(), []);
-    assert.equal(await game.playHalfMove({ from: 8, to: 7 }), false);
-
-    await game.confirmMove();
     const last = game.events.at(-1);
     assert.equal(last?.type, "MovePlayed");
     assert.deepEqual(game.pendingHalfMoves, []);
-    assert.equal(game.moveComplete, false);
     assert.equal(game.state.turn, "computer");
     assert.equal(game.state.phase, "rolling");
     assert.equal(game.state.position, "SWAPPED");
 });
 
-test("un coup incomplet ne se valide pas", async () => {
-    const game = Game.start(fakeEngine(), { dice: fixedDice([3, 1]) });
-    await assert.rejects(game.confirmMove(), /pas complet/);
-    await game.playHalfMove({ from: 8, to: 5 });
-    await assert.rejects(game.confirmMove(), /pas complet/);
-    assert.equal(game.events.length, 2);
-});
-
-test("Annuler défait les demi-coups un par un, sans toucher au journal", async () => {
-    const game = Game.start(fakeEngine(), { dice: fixedDice([3, 1]) });
-    await game.playHalfMove({ from: 8, to: 5 });
-    await game.playHalfMove({ from: 6, to: 5 });
-    const journal = game.journal;
-
-    game.undoLastHalfMove();
-    assert.deepEqual(game.pendingHalfMoves, [{ from: 8, to: 5 }]);
-    assert.equal(game.moveComplete, false);
-    assert.equal(game.displayedPosition, "HALF");
-
-    game.undoLastHalfMove();
-    assert.deepEqual(game.pendingHalfMoves, []);
-    assert.equal(game.displayedPosition, START_POSITION);
-    game.undoLastHalfMove(); // rien à défaire : sans effet
-    assert.equal(game.journal, journal);
-
-    // Le coup se ressaisit ensuite normalement.
-    assert.equal(await game.playHalfMove({ from: 8, to: 5 }), true);
-    assert.equal(await game.playHalfMove({ from: 6, to: 5 }), true);
-    assert.equal(game.moveComplete, true);
-});
-
-test("les dés utilisés par les demi-coups saisis sont marqués", async () => {
-    const game = Game.start(fakeEngine(), { dice: fixedDice([3, 1]) });
-    assert.deepEqual(game.diceToPlay, [
-        { value: 3, used: false },
-        { value: 1, used: false },
-    ]);
-    await game.playHalfMove({ from: 8, to: 5 });
-    assert.deepEqual(game.diceToPlay, [
-        { value: 3, used: true },
-        { value: 1, used: false },
-    ]);
-    await game.playHalfMove({ from: 6, to: 5 });
-    assert.deepEqual(
-        game.diceToPlay.map((d) => d.used),
-        [true, true],
-    );
-    await game.confirmMove();
-    assert.deepEqual(game.diceToPlay, []);
-});
-
-test("un double donne quatre dés, marqués un par un ; une sortie prend le plus petit dé suffisant", async () => {
-    const engine = fakeEngine({
-        checkHalfMoves: async () => ({ valid: true, complete: false, position: "P" }),
-    });
-    const double = Game.start(engine, {
-        dice: fixedDice([2, 2]),
-        setup: { position: "X", firstTurn: "player" },
-    });
-    await double.roll();
-    assert.equal(double.diceToPlay.length, 4);
-    await double.playHalfMove({ from: 13, to: 11 });
-    await double.playHalfMove({ from: 11, to: 9 });
-    assert.deepEqual(
-        double.diceToPlay.map((d) => d.used),
-        [true, true, false, false],
-    );
-
-    const bearOff = Game.start(engine, {
-        dice: fixedDice([6, 4]),
-        setup: { position: "X", firstTurn: "player" },
-    });
-    await bearOff.roll();
-    // 3/off : le 4 suffit, le 6 reste.
-    await bearOff.playHalfMove({ from: 3, to: 0 });
-    assert.deepEqual(bearOff.diceToPlay, [
-        { value: 6, used: false },
-        { value: 4, used: true },
-    ]);
-    // 6/2 demande le 4 : la sortie a donc pris le 6.
-    await bearOff.playHalfMove({ from: 6, to: 2 });
-    assert.deepEqual(
-        bearOff.diceToPlay.map((d) => d.used),
-        [true, true],
-    );
-});
-
 test("sans coup possible, le tour passe quand le joueur le laisse passer", async () => {
     const engine = fakeEngine({ legalMoves: async () => [] });
     const game = Game.start(engine, {
@@ -289,7 +192,6 @@ test("annuler repart du parent ; l'action suivante ouvre une branche", async ()
     const game = Game.start(fakeEngine(), { dice: fixedDice([3, 1, 6, 5, 4, 2]) });
     await game.playHalfMove({ from: 8, to: 5 });
     await game.playHalfMove({ from: 6, to: 5 });
-    await game.confirmMove();
     const played = game.events.at(-1);
     assert.equal(played?.type, "MovePlayed");
 
@@ -298,7 +200,6 @@ test("annuler repart du parent ; l'action suivante ouvre une branche", async ()
     assert.equal(game.state.turn, "player");
     await game.playHalfMove({ from: 8, to: 5 });
     await game.playHalfMove({ from: 6, to: 5 });
-    await game.confirmMove();
 
     // Deux coups accrochés au même jet : l'ancien reste dans le journal.
     const moves = game.journal.events.filter((e) => e.type === "MovePlayed");
@@ -343,7 +244,6 @@ test("une partie se reprend depuis son journal ; un journal d'une autre version
     const game = Game.start(fakeEngine(), { dice: fixedDice([3, 1]) });
     await game.playHalfMove({ from: 8, to: 5 });
     await game.playHalfMove({ from: 6, to: 5 });
-    await game.confirmMove();
     const saved = JSON.parse(JSON.stringify(game.journal));
 
     const resumed = Game.resume(fakeEngine(), saved);

app/tests/move-steps.test.ts

@@ -42,7 +42,6 @@ async function playerMove(position: PositionId, dice: [number, number], move: st
     for (const halfMove of parseHalfMoves(move)) {
         assert.equal(await game.playHalfMove(halfMove), true, formatHalfMoves([halfMove]));
     }
-    await game.confirmMove();
     return game;
 }
 
@@ -60,7 +59,6 @@ test("un coup simple : un plateau par demi-coup, sans pion frappé", async () =>
     for (const halfMove of parseHalfMoves("8/5 6/5")) {
         await game.playHalfMove(halfMove);
     }
-    await game.confirmMove();
     const steps = await game.lastMoveSteps();
     assert.ok(steps !== null);
     assert.equal(steps.side, "player");
@@ -123,7 +121,6 @@ test("le coup de l'ordinateur, vu dans sa propre numérotation", async () => {
     for (const halfMove of parseHalfMoves("8/5 6/5")) {
         await game.playHalfMove(halfMove);
     }
-    await game.confirmMove();
     await game.playComputerTurn();
     const steps = await game.lastMoveSteps();
     assert.ok(steps !== null);

app/tests/steps/jouer-une-partie.steps.ts

@@ -80,15 +80,6 @@ async function play(text: string): Promise<boolean> {
     return true;
 }
 
-/** Joue les demi-coups puis valide le coup, complet. */
-async function playAndConfirm(text: string): Promise<boolean> {
-    if (!(await play(text))) {
-        return false;
-    }
-    await game.confirmMove();
-    return true;
-}
-
 function lastEvent(): GameEvent {
     const event = game.events.at(-1);
     assert.ok(event !== undefined, "aucun événement");
@@ -169,62 +160,12 @@ Then("la position n'a pas changé", () => {
     assert.equal(lastEvent().type, "DiceRolled");
 });
 
-// ------------------------------------------ Valider ou reprendre son coup
-
-Then("votre coup attend votre validation", async () => {
-    assert.equal(accepted, true);
-    assert.equal(game.moveComplete, true);
-    // Rien n'est encore dans le journal, et plus aucun pion ne bouge.
-    assert.equal(lastEvent().type, "DiceRolled");
-    assert.equal(game.state.turn, "player");
-    assert.deepEqual(await game.nextHalfMoves(), []);
-});
-
-Then("vos dés sont tous marqués comme joués", () => {
-    assert.ok(game.diceToPlay.length > 0);
-    assert.ok(game.diceToPlay.every((die) => die.used));
-});
-
-When("vous validez votre coup", async () => {
-    await game.confirmMove();
-});
-
-Then("seul votre {int} est marqué comme joué", (value: number) => {
-    const used = game.diceToPlay.filter((die) => die.used);
-    assert.deepEqual(
-        used.map((die) => die.value),
-        [value],
-    );
-});
-
-Then("chacun de vos pions jouables n'a plus qu'une case d'arrivée", async () => {
-    const halfMoves = await game.nextHalfMoves();
-    assert.ok(halfMoves.length > 0);
-    const starts = halfMoves.map((h) => h.from);
-    assert.equal(new Set(starts).size, starts.length);
-});
-
-When("vous annulez le dernier demi-coup", () => {
-    game.undoLastHalfMove();
-});
-
-Then("il ne reste de joué que {word}", (text: string) => {
-    assert.deepEqual(game.pendingHalfMoves, parseHalfMoves(text));
-    assert.equal(game.moveComplete, false);
-    assert.equal(lastEvent().type, "DiceRolled");
-});
-
-Then("aucun de vos dés n'est marqué comme joué", () => {
-    assert.ok(game.diceToPlay.length > 0);
-    assert.ok(game.diceToPlay.every((die) => !die.used));
-});
-
 // ------------------------------------------------------- L'ordinateur joue
 
 Given("c'est au tour de l'ordinateur", async () => {
     // Vous commencez avec 3-1, puis l'ordinateur tirera 6-4.
     game = Game.start(engine, { dice: fixedDice([3, 1, 6, 4]) });
-    assert.equal(await playAndConfirm("8/5 6/5"), true);
+    assert.equal(await play("8/5 6/5"), true);
     assert.equal(game.state.turn, "computer");
 });
 
@@ -346,52 +287,6 @@ Then("vous pouvez revoir son coup", async () => {
 
 // ------------------------------------------------------------------ Videau
 
-// La confirmation elle-même est une question de l'interface (une fenêtre
-// « Doubler à 2 ? ») : ces étapes vérifient que rien n'est proposé tant que
-// vous n'avez pas confirmé, et ce qui suit votre confirmation.
-
-Given("vous pouvez doubler", async () => {
-    game = Game.start(engine, { setup: { position: START_POSITION, firstTurn: "player" } });
-    assert.equal(game.state.phase, "rolling");
-});
-
-When("vous demandez à doubler", async () => {
-    assert.equal(await game.canDouble(), true);
-});
-
-When("vous changez d'avis", () => {
-    // Vous refermez la question : la partie n'est pas touchée.
-});
-
-Then("rien n'est proposé à l'ordinateur", () => {
-    assert.ok(!game.events.some((e) => e.type === "CubeOffered"));
-    assert.equal(game.state.phase, "rolling");
-    assert.equal(game.state.turn, "player");
-    assert.deepEqual(game.state.cube, { value: 1, owner: null });
-});
-
-When("vous confirmez", async () => {
-    await game.double();
-});
-
-Then("l'ordinateur prend ou passe, comme le recommande le moteur", async () => {
-    const decision = await engine.cubeDecision(
-        START_POSITION,
-        { value: 1, owner: "centered" },
-        STANDARD_PLY,
-    );
-    const offered = game.events.findIndex((e) => e.type === "CubeOffered");
-    const answer = game.events[offered + 1];
-    assert.ok(offered >= 0 && answer !== undefined);
-    if (decision.take) {
-        assert.equal(answer.type, "CubeTaken");
-        assert.deepEqual(game.state.cube, { value: 2, owner: "computer" });
-    } else {
-        assert.equal(answer.type, "CubeDropped");
-        assert.deepEqual(game.state.result, { winner: "player", kind: "single", points: 1 });
-    }
-});
-
 Given("l'ordinateur vous propose de doubler", async () => {
     game = Game.start(engine, { setup: { position: COMPUTER_DOUBLES, firstTurn: "computer" } });
     await game.playComputerTurn();
@@ -451,7 +346,7 @@ Given("un joueur a sorti tous ses pions", async () => {
         dice: fixedDice([6, 5]),
     });
     await game.roll();
-    assert.equal(await playAndConfirm("6/off 5/off"), true);
+    assert.equal(await play("6/off 5/off"), true);
 });
 
 Then("le résultat indique le gagnant et les points gagnés", () => {

app/tests/ui.test.ts

@@ -12,15 +12,7 @@ import type { BoardSide } from "../src/domain/game/engine.js";
 import { appendEvent, EMPTY_JOURNAL } from "../src/domain/game/events.js";
 import { parseHalfMoves, START_POSITION } from "../src/domain/game/position.js";
 import { createGameStore } from "../src/storage/game-store.js";
-import {
-    boardModel,
-    moveTargets,
-    moveTrace,
-    onlyHalfMove,
-    placeOf,
-    pointColor,
-    pointSlot,
-} from "../src/ui/board-model.js";
+import { boardModel, moveTargets, moveTrace, placeOf, pointSlot } from "../src/ui/board-model.js";
 import { parseFeature, parseGlossaryEntry, parseGlossaryIndex } from "../src/ui/help-text.js";
 import { TEXTS } from "../src/ui/texts.js";
 
@@ -55,18 +47,6 @@ test("cases, barre et sortie de chaque camp", () => {
     assert.equal(placeOf("computer", 0), "off-computer");
 });
 
-test("couleur des flèches : impaires en point-a, paires en point-b, quelle que soit la colonne", () => {
-    for (const number of [1, 13, 23]) {
-        assert.equal(pointColor(number), "point-a", `flèche ${number}`);
-    }
-    for (const number of [2, 12, 24]) {
-        assert.equal(pointColor(number), "point-b", `flèche ${number}`);
-    }
-    // 12 et 13 partagent la colonne 0, mais pas la couleur.
-    assert.equal(pointSlot(12).column, pointSlot(13).column);
-    assert.notEqual(pointColor(12), pointColor(13));
-});
-
 test("disposition : 1 à 12 en bas de droite à gauche, 13 à 24 en haut de gauche à droite", () => {
     assert.deepEqual(pointSlot(1), { top: false, column: 11 });
     assert.deepEqual(pointSlot(7), { top: false, column: 5 });
@@ -85,11 +65,6 @@ test("les demi-coups possibles donnent les pions jouables et leurs cases d'arriv
     assert.deepEqual([...targets.keys()], ["p8", "bar-player", "p3"]);
     assert.deepEqual([...(targets.get("p8")?.keys() ?? [])], ["p5", "p7"]);
     assert.deepEqual(targets.get("p3")?.get("off-player"), { from: 3, to: 0 });
-    // Un seul toucher suffit pour un pion à destination unique.
-    assert.deepEqual(onlyHalfMove(targets, "p3"), { from: 3, to: 0 });
-    assert.deepEqual(onlyHalfMove(targets, "bar-player"), { from: 25, to: 22 });
-    assert.equal(onlyHalfMove(targets, "p8"), null);
-    assert.equal(onlyHalfMove(targets, "p13"), null);
 });
 
 test("traces d'un coup simple : une flèche par demi-coup, départs et arrivées", () => {

docs/adr/0004-outils-de-developpement-dans-docker.md

@@ -52,3 +52,9 @@ construire ou tester ; rien n'est embarqué dans l'application.
 Validés par Pierre avec l'ADR 0009, dans Docker, jamais embarqués :
 TypeScript (`tsc`, Apache-2.0), Biome (MIT ou Apache-2.0),
 `@cucumber/cucumber` (MIT), `dependency-cruiser` (MIT).
+
+### 2026-11-03 — Playwright pour les tests dans le navigateur
+
+Validé par Pierre : Playwright 1.48.2 (Apache-2.0), image
+`mcr.microsoft.com/playwright:v1.48.2-noble`, utilisé seulement par
+`make test-browser` (Chromium et Firefox sans écran). Rien n'est embarqué.

docs/adr/0009-socle-pwa-typescript.md

@@ -68,24 +68,3 @@ vérification des dépendances.
   standard ») est tenu même au niveau fort (2 plis) : c'est le niveau standard
   de l'ordinateur à l'étape 0d.
 - Firefox sur le téléphone reste à vérifier, sans bloquer.
-
-## Amendements
-
-### 2026-11-03 — Pages de test du moteur retirées du site
-
-Décidé par Pierre après son premier test sur le téléphone : « supprimer la
-partie test du moteur totalement ».
-
-- Les pages de test et de mesure de l'étape 0b (`web/moteur/` : `index.html`,
-  `bench.html` et leurs scripts) sont supprimées. Le site publié n'a plus rien
-  sous `/moteur/`, ni dans le cache du service worker ; `make deploy`
-  n'annonce plus que l'application, et l'aide ne renvoie plus vers le test du
-  moteur.
-- Les mesures du Fairphone 4 ci-dessus, faites avec `bench.html`, restent la
-  référence. Pour les refaire, la mesure se lance sous Node sur le PC
-  (`make bench`) : son code partagé est déplacé de `web/moteur/benchmark.mjs`
-  vers `engine-wasm/benchmark.mjs`. Une mesure sur le téléphone demanderait de
-  remettre une page de mesure, à décider le moment venu.
-- Le moteur reste vérifié par la suite de contrat sur WebAssembly
-  (`make test`) et, dans l'application, par la partie jouée dans un navigateur
-  (`make test-browser`).

docs/deploiement.md

@@ -2,8 +2,8 @@
 
 Ustagammon est un site statique (PWA, ADR 0009) : des fichiers HTML,
 JavaScript, le moteur en WebAssembly et ses données. L'application est à la
-racine ; les pages de test du moteur de l'étape 0b ont été retirées (ADR
-0009, amendement du 2026-11-03). Il est publié sur
+racine ; les pages de test du moteur de l'étape 0b restent publiées sous
+`/moteur/` (test du moteur) et `/moteur/bench.html` (mesure). Il est publié sur
 CapRover, machine `sans-pub` (https://captain.cloud.sans.pub), app
 `ustagammon`, sur https://ustagammon.sans.pub.
 
@@ -112,7 +112,8 @@ ssh sans.pub 'sudo docker service ps srv-captain--ustagammon --format "{{.Image}
 ```
 
 Puis ouvrir le site sur le téléphone : le plateau s'affiche et une consigne
-remplace « Chargement du moteur… ».
+remplace « Chargement du moteur… ». La page de test du moteur
+(https://ustagammon.sans.pub/moteur/) doit afficher « Moteur prêt ».
 
 ## Retour arrière
 

docs/feuille-de-route.md

@@ -21,7 +21,11 @@ garde-fous d'architecture (0d.1), déploiement sur https://ustagammon.sans.pub.
 | Sous-étape | Contenu | État | Plan |
 | --- | --- | --- | --- |
 | 0d.2 | Plateau minimal jouable (PWA hors ligne), publié ; reste la vérification avec Pierre sur le Fairphone 4 (`docs/guide-test-etape-0.md`, section « Étape 0d ») | 🔄 | |
-| 0d.2+ | Fluidité de la partie : supprimer ce qui interrompt le jeu sans nécessité (bouton « Nouvelle partie » toujours visible, confirmations, étapes inutiles) : demande de Pierre | ⏳ | |
+| 0e.1 | Saisie du coup : pion à destination unique joué en un toucher, coup à valider et annulable demi-coup par demi-coup, dés joués marqués, dés des deux côtés touchables, videau confirmé ; pages de test du moteur retirées | 🔄 | `plans/2026-11-03-saisie-du-coup.md` |
+| 0e.2 | Revue UX par un designer UI : compte de points, fluidité (bouton « Nouvelle partie », interruptions), paysage ; propositions à valider par Pierre | 🔄 | `plans/2026-11-03-revue-ux.md` |
+| 0e.3 | Paysage sur téléphone : plateau sur presque tout l'écran, contrôles en pictogrammes (ADR 0012 à amender), selon la revue validée | ⏳ | |
+| 0e.4 | Position dans l'adresse : chaque position du plateau a un lien direct (nouvel ADR pour le format) | ⏳ | |
+| 0e.5 | Page d'accueil, installation en un toucher (« Ajouter à l'écran d'accueil », proposée par l'app), tutoriel des règles très didactique avec plateaux illustrés, aide réécrite sur un ton plus humain ; textes à valider par Pierre | ⏳ | |
 
 **Critère de fin** : une partie complète jouée sur le Fairphone 4, moins de 2 s
 par coup de l'IA en niveau standard, tous les tests au vert.

docs/plans/2026-11-03-revue-ux.md

@@ -0,0 +1,37 @@
+# Revue UX : compte de points, fluidité, paysage
+
+- **Date** : 2026-11-03
+- **Étape** : 0e (retours du premier test de Pierre sur le téléphone)
+- **Statut** : en cours
+- **Exécutant** : sous-agent general-purpose, rôle de designer UI, en lecture
+  seule sur le code
+
+## Objectif
+
+Proposer à Pierre, avec maquettes, une meilleure présentation du compte de
+points et une revue de toute l'expérience de jeu (point 10 de son message du
+2026-11-03), en couvrant la fluidité (ligne 0d.2+ de la feuille de route) et le
+paysage sur téléphone (point 5).
+
+## Consignes
+
+- Partir de la charte (`docs/identite/`, ADR 0010), des ADR 0011 et 0012, et de
+  l'application publiée (https://ustagammon.sans.pub, ou `make site` puis les
+  captures de `make test-browser`).
+- Ne pas modifier le dépôt. Livrer un rapport en Markdown (chemin indiqué par
+  la session principale) et, si utile, une page de maquettes.
+- Pour chaque proposition : le problème observé, la solution, sa maquette, son
+  coût technique estimé, et ce qui relève d'un choix de Pierre.
+- Sujets imposés : compte de points ; bouton « Nouvelle partie » et tout ce qui
+  interrompt la partie ; paysage sur téléphone, plateau sur presque tout
+  l'écran, contrôles en pictogrammes.
+- Les changements de saisie du coup en cours (plan
+  `2026-11-03-saisie-du-coup.md`) sont acquis : ne pas les reproposer.
+
+## Critères de réussite
+
+Un rapport priorisé que Pierre peut valider point par point.
+
+## Résultat
+
+À remplir à la clôture.

docs/scenarios/jouer-une-partie.feature

@@ -11,40 +11,11 @@ Fonctionnalité: Jouer une partie contre l'ordinateur
     Et le premier jet de dés désigne qui commence
 
   Scénario: Jouer un coup permis
-    Touchez un pion, puis sa case d'arrivée ; s'il n'en a qu'une, il y va dès
-    que vous le touchez. Chaque dé joué s'estompe. Une fois tous vos dés
-    joués, votre coup attend que vous le validiez : touchez vos dés, d'un côté
-    ou de l'autre du plateau, ou « Valider ».
-
     Étant donné que c'est à vous de jouer avec le jet 3-1
     Quand vous jouez 8/5 6/5
-    Alors votre coup attend votre validation
-    Et vos dés sont tous marqués comme joués
-    Quand vous validez votre coup
     Alors votre coup est accepté
     Et c'est ensuite au tour de l'ordinateur
 
-  Scénario: Un pion qui n'a qu'une case d'arrivée
-    Après 8/5, il ne vous reste que le 1 : chaque pion jouable n'a plus
-    qu'une case d'arrivée, et il y va dès que vous le touchez.
-
-    Étant donné que c'est à vous de jouer avec le jet 3-1
-    Quand vous jouez 8/5
-    Alors seul votre 3 est marqué comme joué
-    Et chacun de vos pions jouables n'a plus qu'une case d'arrivée
-
-  Scénario: Reprendre un pion avant de valider
-    Tant que vous n'avez pas validé votre coup, « Annuler » reprend le
-    dernier pion déplacé ; touchez-le encore pour reprendre le précédent.
-
-    Étant donné que c'est à vous de jouer avec le jet 3-1
-    Quand vous jouez 8/5 6/5
-    Et que vous annulez le dernier demi-coup
-    Alors il ne reste de joué que 8/5
-    Quand vous annulez le dernier demi-coup
-    Alors la position n'a pas changé
-    Et aucun de vos dés n'est marqué comme joué
-
   Scénario: Un coup interdit est refusé
     La case 12 est tenue par l'ordinateur, qui y a cinq pions : vous ne
     pouvez pas vous y poser.
@@ -83,19 +54,6 @@ Fonctionnalité: Jouer une partie contre l'ordinateur
     Et votre pion frappé part sur la barre
     Et vous pouvez revoir son coup
 
-  Scénario: Doubler, après confirmation
-    Avant de lancer les dés, vous pouvez doubler en touchant le videau ou
-    « Doubler ». L'application vous demande de confirmer : une fois proposé,
-    un double ne se reprend pas.
-
-    Étant donné que vous pouvez doubler
-    Quand vous demandez à doubler
-    Mais que vous changez d'avis
-    Alors rien n'est proposé à l'ordinateur
-    Quand vous demandez à doubler
-    Et que vous confirmez
-    Alors l'ordinateur prend ou passe, comme le recommande le moteur
-
   Scénario: Prendre le double de l'ordinateur
     Étant donné que l'ordinateur vous propose de doubler
     Quand vous prenez

engine-wasm/bench.mjs

@@ -1,4 +1,4 @@
-// bench.mjs -- mesure du moteur WebAssembly sous Node, sur le PC
+// bench.mjs -- la mesure de la page bench.html, sous Node, sur le PC
 // (`make bench`). Premier ordre de grandeur seulement : le chiffre qui compte
 // est celui du téléphone.
 //
@@ -10,7 +10,7 @@ import os from "node:os";
 import { fileURLToPath } from "node:url";
 import { gzipSync } from "node:zlib";
 import createEngineModule from "../build/wasm/engine.mjs";
-import { DOWNLOADED_FILES, formatReport, measureTimes } from "./benchmark.mjs";
+import { DOWNLOADED_FILES, formatReport, measureTimes } from "../web/moteur/benchmark.mjs";
 import { commands, loadEngine } from "../web/engine-wasm.mjs";
 
 const root = new URL("../", import.meta.url);

tests/browser/play.mjs

@@ -1,7 +1,6 @@
 // play.mjs -- joue une partie complète par l'interface, dans un vrai
 // navigateur sans écran (Playwright), sur le site servi par l'image de
-// production : dés, coups au toucher (validés, annulés), coups de
-// l'ordinateur, videau (avec sa confirmation), reprise
+// production : dés, coups au toucher, coups de l'ordinateur, videau, reprise
 // après rechargement, aide, puis hors ligne (service worker).
 //
 // Copyright (C) 2026 les auteurs d'Ustagammon.
@@ -102,7 +101,7 @@ async function waitForPlayer() {
                 const b = document.getElementById(id);
                 return !b.hidden && !b.disabled;
             };
-            for (const id of ["again", "take", "skip", "confirm", "roll"]) {
+            for (const id of ["again", "take", "skip", "roll"]) {
                 if (usable(id)) {
                     return id;
                 }
@@ -162,8 +161,7 @@ async function checkTraces() {
         // L'ordinateur n'a pas pu jouer : son jet reste barré, avec un message.
         const info = await page.textContent("#info");
         const blocked = await page.locator(".die-blocked").count();
-        check(/^L'ordinateur ne peut pas jouer \d-\d\.$/.test(info ?? "") && blocked >= 2 &&
-            blocked === (await shownDice()).dice,
+        check(/^L'ordinateur ne peut pas jouer \d-\d\.$/.test(info ?? "") && blocked === 2,
             `jet de l'ordinateur sans coup mal montré : « ${info} », ${blocked} dés barrés`);
         log(`l'ordinateur ne peut pas jouer : « ${info} »`);
     }
@@ -177,35 +175,18 @@ async function checkTraces() {
     return traces;
 }
 
-/** Une zone à toucher d'une action du plateau (dés ou videau) : count zones
- * (les dés en ont une de chaque côté du plateau), chacune un bouton
- * accessible d'au moins 44 px de côté. Renvoie le locator de la zone index. */
-async function touchTarget(action, label, count = 1, index = 0) {
-    const zones = page.locator(`[data-action="${action}"]`);
-    check((await zones.count()) === count,
-        `zone ${action} : ${await zones.count()} sur le plateau, ${count} attendues`);
-    for (const zone of await zones.all()) {
-        check((await zone.getAttribute("role")) === "button" &&
-            (await zone.getAttribute("aria-label")) === label, `zone ${action} sans rôle accessible`);
-        const box = await zone.boundingBox();
-        check(box.width >= 44 && box.height >= 44,
-            `zone ${action} trop petite : ${Math.round(box.width)} x ${Math.round(box.height)} px`);
-    }
-    return zones.nth(index);
-}
-
-/** Le nombre de dés montrés, et de dés estompés (déjà joués). */
-async function shownDice() {
-    return {
-        dice: await page.locator("g.die[data-value]").count(),
-        used: await page.locator("g.die-used").count(),
-    };
-}
-
-/** Le dernier jet du joueur, d'après le journal. */
-function lastPlayerRoll(journal) {
-    const rolled = journal.events.filter((e) => e.type === "DiceRolled").at(-1);
-    return rolled?.roll ?? [];
+/** La zone à toucher d'une action du plateau (dés ou videau) : un bouton
+ * accessible, d'au moins 44 px de côté. Renvoie son sélecteur. */
+async function touchTarget(action, label) {
+    const selector = `[data-action="${action}"]`;
+    const zone = page.locator(selector);
+    check((await zone.count()) === 1, `zone ${action} absente du plateau`);
+    check((await zone.getAttribute("role")) === "button" &&
+        (await zone.getAttribute("aria-label")) === label, `zone ${action} sans rôle accessible`);
+    const box = await zone.boundingBox();
+    check(box.width >= 44 && box.height >= 44,
+        `zone ${action} trop petite : ${Math.round(box.width)} x ${Math.round(box.height)} px`);
+    return selector;
 }
 
 /** Observe la page pendant ms millisecondes : le plus grand nombre
@@ -275,24 +256,13 @@ let tracesSeen = 0;
 let replays = 0;
 let skips = 0;
 let rolls = 0;
-// Saisie du coup : demi-coups du coup en cours, pions avancés d'un seul
-// toucher ou en deux (pion, puis case), coups validés et annulations.
-let halfMoves = 0;
-let singleTouch = 0;
-let twoTouches = 0;
-let confirms = 0;
-let undone = 0;
-let doubles = 0;
-// Vrai dès que le joueur a touché un pion ou « Annuler » pendant son coup :
-// le coup de l'ordinateur n'est plus montré.
-let touched = false;
 for (let actions = 0; ; actions++) {
-    check(actions < 1500, "la partie ne finit pas");
+    check(actions < 800, "la partie ne finit pas");
     const todo = await waitForPlayer();
     step(`partie, action ${actions}`);
     // Le coup de l'ordinateur est montré jusqu'à l'action suivante du
     // joueur ; deux fois, on le revoit (la seconde en mouvement réduit).
-    const traces = touched ? null : await checkTraces();
+    const traces = await checkTraces();
     if (traces !== null) {
         tracesSeen++;
         if (replays < 2) {
@@ -322,8 +292,7 @@ for (let actions = 0; ; actions++) {
         // message, et le tour ne passe qu'en touchant « Continuer ».
         const info = await page.textContent("#info");
         const blocked = await page.locator(".die-blocked").count();
-        check(/^Aucun coup possible avec \d-\d\.$/.test(info ?? "") && blocked >= 2 &&
-            blocked === (await shownDice()).dice,
+        check(/^Aucun coup possible avec \d-\d\.$/.test(info ?? "") && blocked === 2,
             `aucun coup possible mal montré : « ${info} », ${blocked} dés barrés`);
         skips++;
         log(`aucun coup possible : « ${info} », vous continuez`);
@@ -335,115 +304,30 @@ for (let actions = 0; ; actions++) {
     } else if (todo === "roll") {
         if (!doubled && (await page.isEnabled("#double"))) {
             doubled = true;
-            // Toucher le videau demande confirmation ; « Annuler » ne
-            // propose rien, puis « Doubler » (le bouton) et confirmer.
-            const dialog = page.locator("#double-dialog");
-            const question = "Doubler à 2 ? L'ordinateur pourra prendre ou passer.";
-            await (await touchTarget("double", "Doubler")).click();
-            check(await dialog.isVisible(), "videau touché : pas de confirmation");
-            check((await page.textContent("#double-question")) === question,
-                `confirmation du videau : « ${await page.textContent("#double-question")} »`);
-            await shot("videau-confirmation");
-            await page.click("#double-cancel");
-            check(!(await dialog.isVisible()), "Annuler ne ferme pas la confirmation");
-            const offered = (await savedJournal()).events.some((e) => e.type === "CubeOffered");
-            check(!offered && (await page.isVisible("#roll")), "double proposé malgré Annuler");
-            await page.click("#double");
-            check(await dialog.isVisible(), "« Doubler » : pas de confirmation");
-            await page.click("#double-confirm");
+            log("vous doublez en touchant le videau");
+            await page.click(await touchTarget("double", "Doubler"));
             await waitForPlayer();
             const answer = (await page.textContent("#info")) || (await page.textContent("#prompt"));
-            log(`videau touché : confirmation demandée, annulée, puis double confirmé ; réponse : ${answer}`);
+            log(`réponse : ${answer}`);
             continue;
         }
-        // Une fois sur deux, en touchant les dés plutôt que le bouton, d'un
-        // côté puis de l'autre du plateau.
+        // Une fois sur deux, en touchant les dés en attente plutôt que le
+        // bouton.
         rolls++;
-        if (rolls % 2 === 0) {
-            await (await touchTarget("roll", "Lancer les dés", 2, (rolls / 2) % 2)).click();
-        } else {
-            await page.click("#roll");
-        }
-    } else if (todo === "confirm") {
-        // Coup complet : rien n'est joué tant qu'il n'est pas validé.
-        const journal = await savedJournal();
-        const last = journal.events.at(-1);
-        check(last?.type === "DiceRolled" && (await page.isEnabled("#cancel")),
-            `coup complet déjà joué ou non annulable (dernier événement ${last?.type})`);
-        check(/Valider/.test((await page.textContent("#prompt")) ?? ""),
-            `consigne de validation absente : « ${await page.textContent("#prompt")} »`);
-        const dice = await shownDice();
-        check(dice.used === halfMoves && dice.used > 0,
-            `dés estompés : ${dice.used} pour ${halfMoves} demi-coups`);
-        if (undone === 0 && halfMoves >= 2) {
-            // Une fois : « Annuler » défait les demi-coups un par un.
-            if (confirms === 0) {
-                await shot("2b-coup-a-valider");
-            }
-            for (let left = halfMoves - 1; left >= 0; left--) {
-                await page.click("#cancel");
-                await waitForPlayer();
-                const after = await shownDice();
-                check(after.used === left && (await page.isHidden("#confirm")),
-                    `Annuler : ${after.used} dés estompés, ${left} attendus`);
-                undone++;
-            }
-            check(await page.isDisabled("#cancel"), "Annuler reste actif sans demi-coup à défaire");
-            check((await savedJournal()).head === journal.head, "Annuler a touché au journal");
-            log(`Annuler : ${undone} demi-coups défaits un par un, journal intact`);
-            halfMoves = 0;
-            continue;
-        }
-        confirms++;
-        // Une fois sur trois avec le bouton, sinon en touchant les dés
-        // (d'un côté ou de l'autre).
-        if (confirms % 3 === 0) {
-            await page.click("#confirm");
-        } else {
-            await (await touchTarget("confirm", "Valider", 2, confirms % 2)).click();
-        }
-        await waitForPlayer();
-        const played = await savedJournal();
-        check(countMoves(played, "player") === countMoves(journal, "player") + 1,
-            "le coup validé n'est pas dans le journal");
-        halfMoves = 0;
-        touched = false;
+        await page.click(rolls % 2 === 0 ? await touchTarget("roll", "Lancer les dés") : "#roll");
     } else {
         check((await page.locator("[data-action]").count()) === 0,
             "dés ou videau touchables pendant que vous jouez votre coup");
-        if (halfMoves === 0) {
-            // Quatre dés pour un double, deux sinon.
-            const [a, b] = lastPlayerRoll(await savedJournal());
-            const dice = await shownDice();
-            check(dice.dice === (a === b ? 4 : 2) && dice.used === 0,
-                `jet ${a}-${b} : ${dice.dice} dés montrés, ${dice.used} estompés`);
-            if (a === b) {
-                doubles++;
-            }
-        }
-        touched = true;
-        // Un pion à destination unique avance dès qu'on le touche ; sinon,
-        // ses cases d'arrivée s'allument.
         await page.click(".hit.can-move");
-        if ((await page.locator(".hit.can-land").count()) > 0) {
-            twoTouches++;
-            if (!selectionShot) {
-                selectionShot = true;
-                await shot("2-pion-touche");
-            }
-            await page.click(".hit.can-land");
-        } else {
-            singleTouch++;
+        await page.waitForSelector(".hit.can-land");
+        if (!selectionShot) {
+            selectionShot = true;
+            await shot("2-pion-touche");
         }
-        halfMoves++;
-        await waitForPlayer();
-        const dice = await shownDice();
-        check(dice.used === halfMoves, `${dice.used} dés estompés après ${halfMoves} demi-coups`);
-        continue;
+        await page.click(".hit.can-land");
     }
 
-    // Une fois, au milieu de la partie, entre deux coups : fermer et rouvrir
-    // la page.
+    // Une fois, au milieu de la partie : fermer et rouvrir la page.
     const journal = await savedJournal();
     if (!reloaded && countMoves(journal, "computer") >= 3 && countMoves(journal, "player") >= 3) {
         reloaded = true;
@@ -471,14 +355,7 @@ check(countMoves(journal, "player") >= 3 && countMoves(journal, "computer") >= 3
 check(reloaded, "la reprise après rechargement n'a pas été essayée");
 check(replays === 2, "le coup de l'ordinateur n'a pas été revu");
 check(doubled && rolls >= 2, "dés ou videau jamais touchés sur le plateau");
-check(singleTouch > 0 && twoTouches > 0,
-    `saisie : ${singleTouch} pions avancés d'un toucher, ${twoTouches} en deux touchers`);
-check(undone >= 2, "Annuler n'a pas été essayé sur un coup complet");
-check(confirms >= 3, "trop peu de coups validés pour essayer dés et bouton");
-log(`dés lancés ${Math.floor(rolls / 2)} fois en les touchant, des deux côtés du plateau`);
-log(`demi-coups : ${singleTouch} d'un seul toucher (destination unique), ${twoTouches} en deux ` +
-    `touchers ; ${confirms} coups validés (${Math.floor(confirms / 3)} par le bouton, les autres ` +
-    `en touchant les dés) ; ${doubles} doubles montrés en quatre dés`);
+log(`dés lancés ${Math.floor(rolls / 2)} fois en les touchant, videau touché pour doubler`);
 log(`coup de l'ordinateur montré ${tracesSeen} fois, et effacé à chaque action suivante`);
 log(skips > 0 ? `« Continuer » demandé ${skips} fois` : "aucun jet sans coup possible dans cette partie");
 if (computerMs.length > 0) {

tests/test_site.sh

@@ -1,9 +1,8 @@
 #!/usr/bin/env bash
 # Vérifie l'image de production (deploy/) avec le site assemblé (make package) :
 # construit l'image en local, la lance, et contrôle ce que reçoit un
-# navigateur (application, aide, manifeste, service worker, types MIME,
-# compression, politique de sécurité, version), et l'absence des anciennes
-# pages de test du moteur.
+# navigateur (application, pages de test du moteur, aide, manifeste, service
+# worker, types MIME, compression, politique de sécurité, version).
 
 set -euo pipefail
 cd "$(dirname "$0")/.."
@@ -72,12 +71,10 @@ check "wasm/engine.mjs" "text/javascript"
 check "wasm/engine.wasm" "application/wasm"
 check "wasm/engine.data" "application/octet-stream"
 check "version.json" "application/json"
-# Les pages de test du moteur (étape 0b) sont retirées (ADR 0009,
-# amendement du 2026-11-03) : plus rien sous /moteur/.
-[ ! -e build/site/moteur ] || report "build/site/moteur/ existe encore"
-for gone in moteur/ moteur/bench.html; do
-	curl -s -o /dev/null -w "%{http_code}" "$base/$gone" | grep -qx 404 || report "/$gone : 404 attendu"
-done
+# Pages de test du moteur (étape 0b).
+check "moteur/" "text/html"
+check "moteur/bench.html" "text/html"
+check "moteur/engine-client.mjs" "text/javascript"
 # Aide : copies du glossaire et des scénarios (ADR 0008).
 check "docs/scenarios/jouer-une-partie.feature" "text/plain"
 check "docs/glossaire/README.md" "text/markdown"
@@ -97,16 +94,15 @@ done < <(grep -o '"src": "[^"]*"' <<<"$manifest" | sed 's/"src": "\(.*\)"/\1/')
 # Le service worker met en cache chaque fichier du site, avec une version.
 sw="$(curl -s "$base/sw.js")"
 grep -qE '^const VERSION = "[0-9a-f]{16}";' <<<"$sw" || report "sw.js : version absente"
-for file in ./ index.html app/main.js wasm/engine.data wasm/engine.wasm \
+for file in ./ index.html app/main.js wasm/engine.data wasm/engine.wasm moteur/ \
 	docs/glossaire/videau.md version.json fonts/AlegreyaSans-Bold.woff2 icons/favicon.svg; do
 	grep -qF "    \"$file\"," <<<"$sw" || report "sw.js : $file absent de la liste à mettre en cache"
 done
 listed="$(grep -c '^    "' <<<"$sw")"
 present="$(find build/site -type f ! -name sw.js | wc -l)"
-# Chaque fichier, plus « ./ » pour index.html.
-[ "$listed" -eq "$((present + 1))" ] \
-	|| report "sw.js liste $listed adresses pour $present fichiers (plus « ./ »)"
-grep -q '"moteur/' <<<"$sw" && report "sw.js met encore en cache des pages de test du moteur"
+# Chaque fichier, plus « ./ » et « moteur/ » pour les deux index.html.
+[ "$listed" -eq "$((present + 2))" ] \
+	|| report "sw.js liste $listed adresses pour $present fichiers (plus 2 dossiers)"
 grep -o '^    "[^"]*"' <<<"$sw" | tr -d ' "' | while read -r file; do
 	curl -sf -o /dev/null "$base/$file" || echo "sw.js : $file introuvable sur le site"
 done | grep . && report "sw.js liste des fichiers introuvables"

web/app.css

@@ -499,10 +499,6 @@ body.busy .prompt {
   stroke-linecap: round;
 }
 
-/* Dé déjà utilisé par un demi-coup du coup en cours : estompé, sans être
- * barré (il n'est pas perdu : « Annuler » le rend). */
-.die-used { opacity: 0.35; }
-
 .cube-face { fill: var(--cube); stroke: var(--checker-player-edge); stroke-width: 2; }
 
 .cube-value {
@@ -517,39 +513,6 @@ body.busy .prompt {
   cursor: pointer;
 }
 
-/* ------------------------------------------------ Confirmation (videau) */
-
-/* Une carte au milieu de l'écran, comme le glossaire ; le fond de la page
- * s'assombrit derrière. */
-.confirm {
-  width: min(22rem, calc(100vw - 2 * var(--space-4)));
-  padding: var(--space-4);
-  color: var(--text);
-  background: var(--surface);
-  border: 1px solid var(--border);
-  border-radius: var(--radius-md);
-  box-shadow: var(--shadow-raised);
-}
-
-.confirm::backdrop {
-  background: rgba(43, 29, 21, 0.5);
-}
-
-.confirm p {
-  margin: 0 0 var(--space-4);
-  font-weight: 700;
-}
-
-.confirm-actions {
-  display: flex;
-  flex-wrap: wrap;
-  gap: var(--space-2);
-}
-
-.confirm-actions button {
-  flex: 1 1 auto;
-}
-
 /* --------------------------------------------------------------- Aide */
 
 .help {
@@ -619,6 +582,12 @@ body.busy .prompt {
   color: var(--muted);
 }
 
+/* Une cible tactile confortable pour le lien. */
+.about a {
+  display: inline-block;
+  padding-block: 12px;
+}
+
 /* ------------------------------------------------------- Mode paysage */
 
 /* Téléphone tourné : le plateau prend toute la hauteur de l'écran, à

web/index.html

@@ -43,20 +43,11 @@
     <button id="double" type="button" class="secondary" hidden></button>
     <button id="take" type="button" hidden></button>
     <button id="drop" type="button" class="secondary" hidden></button>
-    <button id="confirm" type="button" hidden></button>
     <button id="cancel" type="button" class="secondary" hidden></button>
     <button id="skip" type="button" hidden></button>
     <button id="replay" type="button" class="secondary" hidden></button>
     <button id="again" type="button" hidden></button>
   </div>
-  <!-- Confirmation avant de doubler (ouverte par app/ui/app.js). -->
-  <dialog id="double-dialog" class="confirm" aria-labelledby="double-question">
-    <p id="double-question"></p>
-    <div class="confirm-actions">
-      <button id="double-confirm" type="button"></button>
-      <button id="double-cancel" type="button" class="secondary"></button>
-    </div>
-  </dialog>
   <noscript><p>Ustagammon a besoin de JavaScript.</p></noscript>
 </main>
 

web/moteur/bench-page.mjs

@@ -0,0 +1,98 @@
+// bench-page.mjs -- page de mesure (bench.html) : chronomètre le moteur
+// dans un Web Worker et produit le rapport à copier.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import { DOWNLOADED_FILES, DOWNLOAD_LIMIT_BYTES, formatReport, measureTimes, summarize }
+    from "./benchmark.mjs";
+import { startEngine } from "./engine-client.mjs";
+
+const $ = (id) => document.getElementById(id);
+
+// Taille d'un fichier du site, brute et compressée gzip (comme le ferait un
+// serveur qui compresse ses réponses).
+// name est relatif à la racine du site, un dossier au-dessus de cette page.
+async function fileSize(name) {
+    const blob = await (await fetch("../" + name, { cache: "no-store" })).blob();
+    const gzipped = blob.stream().pipeThrough(new CompressionStream("gzip"));
+    const gzipBytes = (await new Response(gzipped).arrayBuffer()).byteLength;
+    return { name, bytes: blob.size, gzipBytes };
+}
+
+function addRow(cells) {
+    const row = $("table").insertRow();
+    for (const text of cells) {
+        row.insertCell().textContent = text;
+    }
+}
+
+async function measure() {
+    $("start").disabled = true;
+    $("results").hidden = true;
+    $("table").replaceChildren();
+
+    $("status").textContent = "Chargement du moteur…";
+    const start = performance.now();
+    const engine = startEngine();
+    await engine.ready;
+    const loadMs = performance.now() - start;
+
+    const { positions } = await (await fetch("../wasm/positions.json")).json();
+    let memoryBytes = 0;
+    const times = await measureTimes({
+        bestMove: (...args) => engine.bestMove(...args).then(keepMemory),
+        cubeDecision: (...args) => engine.cubeDecision(...args).then(keepMemory),
+    }, positions, (done, total) => {
+        $("status").textContent = "Calcul " + done + " sur " + total + "…";
+    });
+    function keepMemory(answer) {
+        memoryBytes = answer.memoryBytes;
+        return answer;
+    }
+
+    $("status").textContent = "Mesure de la taille à télécharger…";
+    const files = await Promise.all(DOWNLOADED_FILES.map(fileSize));
+
+    for (const s of summarize(times)) {
+        addRow([s.label, Math.round(s.medianMs) + " ms", Math.round(s.maxMs) + " ms",
+            s.limitMs + " ms", s.ok ? "OK" : "dépassé"]);
+    }
+    const gzipTotal = files.reduce((sum, f) => sum + f.gzipBytes, 0);
+    addRow(["Taille compressée", "", (gzipTotal / 1e6).toFixed(1).replace(".", ",") + " Mo",
+        DOWNLOAD_LIMIT_BYTES / 1e6 + " Mo", gzipTotal < DOWNLOAD_LIMIT_BYTES ? "OK" : "dépassé"]);
+
+    $("report").value = formatReport({
+        environment: navigator.userAgent, files, loadMs, memoryBytes, times,
+    });
+    $("results").hidden = false;
+    $("status").textContent = "Mesure terminée.";
+}
+
+// Copie dans le presse-papiers. L'API moderne n'existe que sur les pages
+// sécurisées (https ou localhost) : sur le réseau local en http, on
+// sélectionne le texte et on utilise l'ancienne commande de copie.
+async function copyReport() {
+    try {
+        if (navigator.clipboard) {
+            await navigator.clipboard.writeText($("report").value);
+        } else {
+            $("report").select();
+            if (!document.execCommand("copy")) {
+                throw new Error();
+            }
+        }
+        $("copy-status").textContent = "Rapport copié : collez-le dans la conversation.";
+    } catch {
+        $("report").select();
+        $("copy-status").textContent = "Copie impossible : le texte est sélectionné, "
+            + "copiez-le à la main (appui long, puis Copier).";
+    }
+}
+
+$("start").onclick = () => measure().catch((error) => {
+    $("status").textContent = "La mesure a échoué : " + error.message;
+    $("status").classList.add("error");
+    $("start").disabled = false;
+});
+$("copy").onclick = copyReport;

web/moteur/bench.html

@@ -0,0 +1,35 @@
+<!doctype html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Ustagammon : mesure du moteur</title>
+<link rel="stylesheet" href="style.css">
+<script type="module" src="bench-page.mjs"></script>
+</head>
+<body>
+<main>
+  <h1>Mesure du moteur</h1>
+  <p>Cette page chronomètre le moteur sur les positions de référence : meilleur coup
+    aux niveaux rapide et fort, décision de videau au niveau fort. Elle mesure aussi
+    la taille à télécharger et la mémoire utilisée. Comptez une à quelques minutes ;
+    gardez l'écran allumé et la page au premier plan.</p>
+  <button id="start" type="button">Lancer la mesure</button>
+  <p id="status" class="status"></p>
+
+  <section id="results" hidden>
+    <h2>Résultats</h2>
+    <table>
+      <thead><tr><th>Mesure</th><th>Médiane</th><th>Maximum</th><th>Seuil</th><th></th></tr></thead>
+      <tbody id="table"></tbody>
+    </table>
+    <h2>Rapport</h2>
+    <button id="copy" type="button">Copier les résultats</button>
+    <p id="copy-status" class="status"></p>
+    <textarea id="report" readonly></textarea>
+  </section>
+
+  <p><a href="./">Page de test</a></p>
+</main>
+</body>
+</html>

web/moteur/benchmark.mjs

@@ -1,7 +1,5 @@
-// benchmark.mjs -- mesure du moteur WebAssembly sous Node, pour `make bench`
-// (engine-wasm/bench.mjs). Elle servait aussi à la page de mesure du site,
-// retirée avec les pages de test du moteur (ADR 0009, amendement du
-// 2026-11-03).
+// benchmark.mjs -- mesure du moteur WebAssembly, partagée par la page de
+// mesure (bench.html, dans le navigateur) et `make bench` (sous Node).
 //
 // Copyright (C) 2026 les auteurs d'Ustagammon.
 // Licence : GPLv3 ou ultérieure (voir LICENSE).
@@ -22,12 +20,13 @@ export const TIME_THRESHOLDS = [
 // Taille totale à télécharger, compressée : moins de 40 Mo.
 export const DOWNLOAD_LIMIT_BYTES = 40e6;
 
-// Fichiers téléchargés pour faire tourner le moteur dans l'application
-// (hors code de l'application elle-même, quelques dizaines de Ko), chemins
-// relatifs à la racine du site (web/ ; wasm/ est build/wasm/).
+// Fichiers téléchargés pour faire tourner le moteur dans la page de test,
+// chemins relatifs à la racine du site (web/ ; wasm/ est build/wasm/).
 export const DOWNLOADED_FILES = [
-    "index.html",
-    "app.css",
+    "moteur/index.html",
+    "moteur/style.css",
+    "moteur/page.mjs",
+    "moteur/engine-client.mjs",
     "engine-worker.mjs",
     "engine-wasm.mjs",
     "wasm/engine.mjs",

web/moteur/engine-client.mjs

@@ -0,0 +1,66 @@
+// engine-client.mjs -- le moteur vu depuis les pages de test : démarre le
+// Web Worker (../engine-worker.mjs, partagé avec l'application) et lui envoie
+// les commandes.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Toutes les fonctions renvoient une promesse de { result, ms, memoryBytes } :
+// result est l'objet JSON d'engine-cli, ms le temps de calcul mesuré dans le
+// Worker. La promesse est rejetée si le moteur signale une erreur.
+
+import { commands } from "../engine-wasm.mjs";
+
+export function startEngine() {
+    const worker = new Worker(new URL("../engine-worker.mjs", import.meta.url), { type: "module" });
+    const pending = new Map();
+    let nextId = 1;
+    let resolveReady, rejectReady;
+    const ready = new Promise((resolve, reject) => {
+        resolveReady = resolve;
+        rejectReady = reject;
+    });
+
+    worker.onmessage = (event) => {
+        const message = event.data;
+        if (message.type === "ready") {
+            resolveReady(message);
+        } else if (message.type === "failed") {
+            rejectReady(new Error(message.message));
+        } else {
+            const { resolve, reject } = pending.get(message.id);
+            pending.delete(message.id);
+            if (message.error) {
+                reject(new Error(message.error));
+            } else {
+                resolve(message);
+            }
+        }
+    };
+    // Erreur au chargement du Worker lui-même (fichier absent, navigateur
+    // trop ancien pour les Workers en module ES…).
+    worker.onerror = (event) => {
+        rejectReady(new Error(event.message || "le Web Worker du moteur n'a pas démarré"));
+    };
+
+    function run(args) {
+        const id = nextId++;
+        return new Promise((resolve, reject) => {
+            pending.set(id, { resolve, reject });
+            worker.postMessage({ id, args: args.map(String) });
+        });
+    }
+
+    return {
+        // Promesse de { loadMs, memoryBytes } une fois le moteur chargé.
+        ready,
+        bestMove: (positionId, matchId, dice, ply) =>
+            run(commands.bestMove(positionId, matchId, dice, ply)),
+        cubeDecision: (positionId, matchId, ply) =>
+            run(commands.cubeDecision(positionId, matchId, ply)),
+        evaluate: (positionId, matchId, ply) =>
+            run(commands.evaluate(positionId, matchId, ply)),
+        reference: (positionId, matchId, dice, ply) =>
+            run(commands.reference(positionId, matchId, dice, ply)),
+    };
+}

web/moteur/index.html

@@ -0,0 +1,48 @@
+<!doctype html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Ustagammon : test du moteur</title>
+<link rel="stylesheet" href="style.css">
+<script type="module" src="page.mjs"></script>
+</head>
+<body>
+<main>
+  <h1>Test du moteur</h1>
+  <p>Le moteur GNU Backgammon, compilé en WebAssembly, calcule dans le navigateur.</p>
+  <p id="status" class="status">Chargement du moteur…</p>
+
+  <form id="form">
+    <label>Exemple
+      <select id="example"><option value="">(choisir une position de référence)</option></select>
+    </label>
+    <label>Position ID
+      <input id="position-id" required autocomplete="off" spellcheck="false" value="4HPwATDgc/ABMA">
+    </label>
+    <label>Match ID
+      <input id="match-id" required autocomplete="off" spellcheck="false" value="cIkFAAAAAAAA">
+    </label>
+    <div class="row">
+      <label>Dé 1 <input id="die1" type="number" min="1" max="6" required value="3"></label>
+      <label>Dé 2 <input id="die2" type="number" min="1" max="6" required value="1"></label>
+      <label>Niveau
+        <select id="ply">
+          <option value="0">rapide (0 pli)</option>
+          <option value="2">fort (2 plis)</option>
+        </select>
+      </label>
+    </div>
+    <button id="best-move" type="submit" disabled>Meilleur coup</button>
+  </form>
+
+  <section id="result" class="result" hidden>
+    <p>Meilleur coup : <strong id="move"></strong></p>
+    <p id="details"></p>
+    <p>Temps de calcul : <strong id="time"></strong></p>
+  </section>
+
+  <p><a href="bench.html">Page de mesure</a> · <a href="../">L'application</a></p>
+</main>
+</body>
+</html>

web/moteur/page.mjs

@@ -0,0 +1,71 @@
+// page.mjs -- page de test du moteur (index.html) : meilleur coup d'une
+// position, avec son temps de calcul.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import { startEngine } from "./engine-client.mjs";
+
+const $ = (id) => document.getElementById(id);
+const engine = startEngine();
+
+engine.ready.then(
+    ({ loadMs }) => {
+        $("status").textContent = "Moteur prêt, chargé en " + Math.round(loadMs) + " ms.";
+        $("best-move").disabled = false;
+    },
+    (error) => {
+        $("status").textContent = "Le moteur n'a pas pu se charger : " + error.message;
+        $("status").classList.add("error");
+    },
+);
+
+// Exemples : les positions de référence avec des dés.
+fetch("../wasm/positions.json")
+    .then((response) => response.json())
+    .then(({ positions }) => {
+        for (const p of positions.filter((p) => p.type === "move")) {
+            const option = new Option(p.id + " : " + p.description, p.id);
+            option.position = p;
+            $("example").add(option);
+        }
+    })
+    .catch(() => {}); // la page reste utilisable sans les exemples
+
+$("example").onchange = () => {
+    const p = $("example").selectedOptions[0].position;
+    if (p) {
+        $("position-id").value = p.position_id;
+        $("match-id").value = p.match_id;
+        [$("die1").value, $("die2").value] = p.dice;
+    }
+};
+
+function showResult(move, details, time) {
+    $("move").textContent = move;
+    $("details").textContent = details;
+    $("time").textContent = time;
+    $("result").hidden = false;
+}
+
+$("form").onsubmit = async (event) => {
+    event.preventDefault();
+    $("best-move").disabled = true;
+    $("result").hidden = true;
+    try {
+        const { result, ms } = await engine.bestMove($("position-id").value.trim(),
+            $("match-id").value.trim(), [$("die1").value, $("die2").value], $("ply").value);
+        const best = result.best_move;
+        if (best) {
+            showResult(best.move, "Équité " + best.equity.toFixed(3).replace(".", ",")
+                + ", chances de gain " + (100 * best.probabilities.win).toFixed(1).replace(".", ",")
+                + " %, évalué à " + best.ply + " pli(s).", Math.round(ms) + " ms");
+        } else {
+            showResult("aucun coup possible", "", Math.round(ms) + " ms");
+        }
+    } catch (error) {
+        showResult("erreur", error.message, "");
+    } finally {
+        $("best-move").disabled = false;
+    }
+};

web/moteur/style.css

@@ -0,0 +1,113 @@
+/* Pages de test du moteur : mise en forme minimale, lisible sur téléphone. */
+
+:root {
+  --text: #1d1d1b;
+  --background: #fbfaf7;
+  --muted: #5f5e5a;
+  --accent: #1f5c4a;
+  --error: #a3261b;
+  --border: #cfccc4;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #ecebe6;
+    --background: #1b1c1a;
+    --muted: #a9a8a2;
+    --accent: #7cc4a8;
+    --error: #f08a7e;
+    --border: #4a4a46;
+  }
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  font: 17px/1.5 system-ui, sans-serif;
+  color: var(--text);
+  background: var(--background);
+}
+
+main {
+  max-width: 40rem;
+  margin: 0 auto;
+  padding: 1rem;
+}
+
+h1 {
+  font-size: 1.5rem;
+}
+
+label {
+  display: block;
+  margin-bottom: 0.75rem;
+}
+
+input,
+select,
+button,
+textarea {
+  display: block;
+  width: 100%;
+  margin-top: 0.25rem;
+  padding: 0.5rem;
+  font: inherit;
+  color: inherit;
+  background: transparent;
+  border: 1px solid var(--border);
+  border-radius: 6px;
+}
+
+.row {
+  display: flex;
+  gap: 0.75rem;
+}
+
+.row label {
+  flex: 1;
+}
+
+button {
+  margin: 0.5rem 0 1rem;
+  font-weight: 600;
+  color: var(--background);
+  background: var(--accent);
+  border-color: var(--accent);
+}
+
+button:disabled {
+  opacity: 0.5;
+}
+
+textarea {
+  height: 16rem;
+  font: 13px/1.4 monospace;
+}
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+th,
+td {
+  padding: 0.25rem;
+  text-align: left;
+  border-bottom: 1px solid var(--border);
+}
+
+.status {
+  color: var(--muted);
+}
+
+.error {
+  color: var(--error);
+}
+
+.result {
+  padding: 0.5rem 1rem;
+  border-left: 4px solid var(--accent);
+}