Recette design : tutoriel en paysage, sens du jeu, bandeau de mise à jour

- Sens du jeu (étape 2) : le tracé passe sous les pions et sous les
  numéros des flèches ; liseré ivoire de 8 px, points de 4 px à l'écran.
- Tutoriel en paysage : plateau à gauche sur toute la hauteur (géométrie
  du jeu en paysage, colonne gauche du cadre), colonne à droite avec la
  barre de progression, le titre, le texte, la consigne et les boutons ;
  seul le texte peut défiler. Tient en 915x412 et 844x320.
- Recette automatique étendue au tutoriel : numéros d'au moins 12 px,
  page sans défilement et boutons en vue en paysage, captures en 844x320.
- Boutons du videau « Prendre » et « Passer », lien « Quitter ».
- Bandeau « Nouvelle version prête. » en bas, au-dessus de la barre
  d'actions, seulement entre deux tours (betweenTurns, testé).
- Test des adresses : le lien Aide est lu au moment du toucher, la carte
  du terme ouvert est mesurée sous la barre de l'aide.

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

Makefile

@@ -30,7 +30,8 @@ CADDY_IMAGE := caddy:2.8.4-alpine
 # Navigateurs sans écran pour make test-browser (Playwright, Apache-2.0).
 PLAYWRIGHT_IMAGE := mcr.microsoft.com/playwright:v1.48.2-noble
 
-export SHELLCHECK_IMAGE GHERKIN_IMAGE BUILD_C_IMAGE WASM_IMAGE CADDY_IMAGE WEB_IMAGE PLAYWRIGHT_IMAGE
+export SHELLCHECK_IMAGE GHERKIN_IMAGE BUILD_C_IMAGE WASM_IMAGE CADDY_IMAGE WEB_IMAGE PLAYWRIGHT_IMAGE \
+	REFERENCE_IMAGE
 
 # Lance une commande dans la chaîne C, sous l'utilisateur courant pour que
 # build/ lui appartienne.
@@ -126,8 +127,9 @@ SITE_ICONS := icone.svg icone-192.png icone-512.png icone-maskable-192.png icone
 #   docs/identite/logo/ (une seule source, ADR 0010) ;
 # - l'application compilée (build/web/src/) sous app/ ;
 # - le moteur sous wasm/ ;
-# - les copies du glossaire et des scénarios sous docs/, lues par l'aide de
-#   l'application (ADR 0008 : jamais commitées ailleurs) ;
+# - les copies du glossaire, des scénarios et du tutoriel sous docs/, lues par
+#   l'aide et le tutoriel de l'application (ADR 0008 : jamais commitées
+#   ailleurs) ;
 # - version.json (commit publié) ;
 # - sw.js, complété par la liste de tous ces fichiers (scripts/service-worker.sh).
 site: engine-wasm web ## Assemble le site publié dans build/site/
@@ -139,7 +141,7 @@ site: engine-wasm web ## Assemble le site publié dans build/site/
 	cp -r $(BUILD_DIR)/web/src $(BUILD_DIR)/site/app
 	cp $(BUILD_DIR)/wasm/engine.mjs $(BUILD_DIR)/wasm/engine.wasm $(BUILD_DIR)/wasm/engine.data \
 		$(BUILD_DIR)/wasm/positions.json $(BUILD_DIR)/site/wasm/
-	cp -r docs/glossaire docs/scenarios $(BUILD_DIR)/site/docs/
+	cp -r docs/glossaire docs/scenarios docs/tutoriel $(BUILD_DIR)/site/docs/
 	printf '{"commit": "%s", "dirty": %s}\n' "$$(git rev-parse HEAD)" \
 		"$$(git diff --quiet HEAD && echo false || echo true)" > $(BUILD_DIR)/site/version.json
 	scripts/service-worker.sh $(BUILD_DIR)/site

app/src/domain/game/branches.ts

@@ -0,0 +1,91 @@
+// Les branches d'une partie : les lignes de jeu de son journal.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Le journal est un arbre (events.ts) : chaque événement pointe vers son
+// parent, et « Rejouer d'ici » accroche un nouvel événement à un ancien. Une
+// branche est le chemin du premier événement jusqu'à une feuille de l'arbre.
+// Les identifiants des événements sont attribués dans l'ordre d'ajout : de
+// deux enfants d'un même événement, le plus ancien a le plus petit indice
+// dans le journal, et c'est lui qui continue la ligne d'origine.
+
+import { currentLine, type GameEvent, type GameJournal, goBackTo } from "./events.js";
+import { replay } from "./state.js";
+
+/**
+ * Une branche de la partie : la suite d'événements du début jusqu'à head.
+ *
+ * Glossaire : docs/glossaire/branche.md
+ */
+export interface Branch {
+    /** Le dernier événement de la branche (une feuille de l'arbre). */
+    readonly head: string;
+    /** L'événement à partir duquel elle a été rejouée (« Rejouer d'ici ») ;
+     * null pour la ligne d'origine de la partie. */
+    readonly forkedFrom: string | null;
+    /** Les coups joués avant de rejouer (0 : depuis le début) ; 0 aussi pour
+     * la ligne d'origine. */
+    readonly forkMoveCount: number;
+    /** Les coups joués sur toute la branche, depuis le début. */
+    readonly moveCount: number;
+    /** La partie est finie au bout de cette branche. */
+    readonly over: boolean;
+    /** L'événement courant de la partie est sur cette branche. */
+    readonly containsHead: boolean;
+}
+
+/**
+ * Les branches de la partie, dans l'ordre de leur création (celui de leur
+ * premier événement propre) : la ligne d'origine d'abord. Liste vide pour un
+ * journal vide.
+ */
+export function branches(journal: GameJournal): Branch[] {
+    const order = new Map(journal.events.map((event, index) => [event.id, index]));
+    const children = new Map<string, GameEvent[]>();
+    for (const event of journal.events) {
+        if (event.parent !== null) {
+            children.set(event.parent, [...(children.get(event.parent) ?? []), event]);
+        }
+    }
+    const leaves = journal.events.filter((event) => !children.has(event.id));
+    return leaves
+        .map((leaf) => {
+            const line = currentLine({ events: journal.events, head: leaf.id });
+            // Le point de départ de la branche : le parent de l'événement le
+            // plus récent du chemin qui n'est pas le premier enfant de son
+            // parent (la ligne d'origine n'en a aucun).
+            let forkIndex = -1;
+            for (let i = line.length - 1; i > 0; i--) {
+                const event = line[i] as GameEvent;
+                const first = children.get(event.parent as string)?.[0];
+                if (first !== undefined && first.id !== event.id) {
+                    forkIndex = i - 1;
+                    break;
+                }
+            }
+            const moves = (events: readonly GameEvent[]) =>
+                events.filter((event) => event.type === "MovePlayed").length;
+            const fork = forkIndex >= 0 ? (line[forkIndex] as GameEvent) : null;
+            const start = line[forkIndex + 1] as GameEvent;
+            return {
+                created: order.get(start.id) ?? 0,
+                head: leaf.id,
+                forkedFrom: fork?.id ?? null,
+                forkMoveCount: fork === null ? 0 : moves(line.slice(0, forkIndex + 1)),
+                moveCount: moves(line),
+                over: replay(line).phase === "over",
+                containsHead: line.some((event) => event.id === journal.head),
+            };
+        })
+        .sort((a, b) => a.created - b.created)
+        .map(({ created: _, ...branch }) => branch);
+}
+
+/** Passe à une autre branche : la partie reprend au bout de celle-ci. */
+export function switchToBranch(journal: GameJournal, head: string): GameJournal {
+    if (!branches(journal).some((branch) => branch.head === head)) {
+        throw new Error(`branche introuvable : ${head}`);
+    }
+    return goBackTo(journal, head);
+}

app/src/domain/game/engine.ts

@@ -74,6 +74,36 @@ export interface Engine {
 
     /** La chance d'un jet pour le joueur au trait. */
     luck(position: PositionId, cube: EngineCube, roll: Roll): Promise<Luck>;
+
+    /** Le Match ID d'une partie libre, joueur 0 au trait, avec ce videau vu
+     * de lui, sans dés. */
+    encodeMatch(cube: EngineCube): Promise<MatchId>;
+
+    /** Un Match ID décodé ; erreur s'il est illisible pour le moteur. */
+    decodeMatch(matchId: MatchId): Promise<MatchDescription>;
+}
+
+/**
+ * Identifiant de match (Match ID de gnubg, 12 caractères) : score, longueur
+ * du match, videau, joueur au trait. Le domaine ne le décode jamais
+ * lui-même : il le passe au moteur.
+ *
+ * Glossaire : docs/glossaire/identifiant-de-match.md
+ */
+export type MatchId = string;
+
+/** Un Match ID décodé par le moteur. Les joueurs sont numérotés 0 et 1,
+ * comme dans gnubg. Les dés qu'il peut contenir ne sont pas lus. */
+export interface MatchDescription {
+    /** 0 : partie libre. */
+    readonly matchLength: number;
+    readonly score: readonly [number, number];
+    readonly cubeValue: number;
+    /** -1 : videau au centre ; sinon le joueur qui le possède. */
+    readonly cubeOwner: -1 | 0 | 1;
+    readonly playerOnRoll: 0 | 1;
+    readonly crawford: boolean;
+    readonly jacoby: boolean;
 }
 
 /**

app/src/domain/game/game.ts

@@ -8,6 +8,7 @@
 // (state.ts). Les règles viennent toutes du moteur : coups légaux, coup de
 // l'ordinateur, videau, fin de partie et points.
 
+import { type Branch, branches, switchToBranch } from "./branches.js";
 import { CENTERED_CUBE, type Cube } from "./cube.js";
 import type { BoardSide, Engine, EngineCube, Ply } from "./engine.js";
 import {
@@ -415,6 +416,19 @@ export class Game {
         this.#journal = goBackTo(this.#journal, eventId);
     }
 
+    /** Les branches de la partie (voir branches.ts), la ligne d'origine
+     * d'abord. */
+    get branches(): Branch[] {
+        return branches(this.#journal);
+    }
+
+    /** Passe à une autre branche, désignée par son dernier événement : la
+     * partie reprend au bout de celle-ci ; les autres restent intactes. */
+    switchBranch(head: string): void {
+        this.cancelHalfMoves();
+        this.#journal = switchToBranch(this.#journal, head);
+    }
+
     /** Annule le dernier événement : la partie repart de son parent. */
     undo(): void {
         const last = this.events.at(-1);

app/src/domain/game/position-link.ts

@@ -0,0 +1,126 @@
+// Une position du plateau dans un lien (ADR 0013) : le Position ID et le
+// Match ID de GNU Backgammon, lus et écrits par le moteur.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Un lien décrit la position du point de vue du joueur au trait : c'est lui
+// qu'on montre en bas (« vous »), et c'est lui que l'on joue avec « Jouer à
+// partir d'ici ». Rien n'est décodé ici : le moteur valide et décode les deux
+// identifiants (aucune règle de représentation n'est réimplémentée).
+
+import type { Cube } from "./cube.js";
+import type { BoardResult, Engine, EngineCube, MatchId } from "./engine.js";
+import type { GameSetup, SideBoards } from "./game.js";
+import type { PositionId } from "./position.js";
+import type { Side } from "./side.js";
+import type { GameState } from "./state.js";
+
+/**
+ * Ce que porte l'adresse d'une position : son Position ID, et son Match ID
+ * s'il est donné (sans lui : partie libre, videau au centre).
+ *
+ * Glossaire : docs/glossaire/lien-de-position.md
+ */
+export interface PositionLink {
+    readonly position: PositionId;
+    readonly matchId: MatchId | null;
+}
+
+/** Une position partagée, lue par le moteur. Le camp « player » est celui
+ * au trait. */
+export interface SharedPosition {
+    readonly link: PositionLink;
+    readonly sides: SideBoards;
+    readonly cube: Cube;
+    /** null en partie libre ; sinon la longueur du match et le score. */
+    readonly match: {
+        readonly length: number;
+        readonly score: Readonly<Record<Side, number>>;
+    } | null;
+    /** La partie est déjà finie dans cette position (null sinon). */
+    readonly result: BoardResult | null;
+}
+
+/** Un lien que le moteur ne sait pas lire. */
+export class UnreadableLinkError extends Error {
+    constructor(reason: string) {
+        super(reason);
+        this.name = "UnreadableLinkError";
+    }
+}
+
+/**
+ * Lit une position partagée : le moteur décode le Match ID (s'il est
+ * donné), puis la position avec son videau. Erreur UnreadableLinkError si
+ * l'un des deux est illisible.
+ */
+export async function readPosition(engine: Engine, link: PositionLink): Promise<SharedPosition> {
+    let cube: EngineCube = { value: 1, owner: "centered" };
+    let match: SharedPosition["match"] = null;
+    if (link.matchId !== null) {
+        const description = await engine.decodeMatch(link.matchId).catch((error: unknown) => {
+            throw new UnreadableLinkError(`Match ID illisible : ${message(error)}`);
+        });
+        const onRoll = description.playerOnRoll;
+        cube = {
+            value: description.cubeValue,
+            owner:
+                description.cubeOwner === -1
+                    ? "centered"
+                    : description.cubeOwner === onRoll
+                      ? "onRoll"
+                      : "opponent",
+        };
+        if (description.matchLength > 0) {
+            match = {
+                length: description.matchLength,
+                score: {
+                    player: description.score[onRoll],
+                    computer: description.score[onRoll === 0 ? 1 : 0],
+                },
+            };
+        }
+    }
+    const board = await engine.board(link.position, cube).catch((error: unknown) => {
+        throw new UnreadableLinkError(`Position ID illisible : ${message(error)}`);
+    });
+    return {
+        link,
+        sides: { player: board.onRoll, computer: board.opponent },
+        cube: {
+            value: cube.value,
+            owner:
+                cube.owner === "centered" ? null : cube.owner === "onRoll" ? "player" : "computer",
+        },
+        match,
+        result: board.result,
+    };
+}
+
+/**
+ * Le lien de la position d'une partie : la position vue du camp au trait,
+ * et le Match ID que le moteur écrit pour son videau (partie libre, sans
+ * dés). Pendant le jet d'ouverture, la position de départ, vue du joueur.
+ */
+export async function linkOf(engine: Engine, state: GameState): Promise<PositionLink> {
+    const onRoll: Side = state.turn ?? "player";
+    const cube: EngineCube =
+        state.cube.owner === null
+            ? { value: state.cube.value, owner: "centered" }
+            : {
+                  value: state.cube.value,
+                  owner: state.cube.owner === onRoll ? "onRoll" : "opponent",
+              };
+    return { position: state.position, matchId: await engine.encodeMatch(cube) };
+}
+
+/** La partie à commencer avec « Jouer à partir d'ici » : le joueur prend la
+ * place du camp au trait, avec le même videau ; partie libre. */
+export function setupOf(shared: SharedPosition): GameSetup {
+    return { position: shared.link.position, firstTurn: "player", cube: shared.cube };
+}
+
+function message(error: unknown): string {
+    return error instanceof Error ? error.message : String(error);
+}

app/src/domain/game/saved-game.ts

@@ -0,0 +1,64 @@
+// Une partie enregistrée, telle que la liste « Mes parties » la présente.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Le journal reste la source (ADR 0007, point 3) : le résumé n'en est qu'une
+// lecture, recalculée à chaque enregistrement, pour afficher la liste sans
+// relire tous les journaux.
+
+import { branches } from "./branches.js";
+import type { Level } from "./engine.js";
+import { currentLine, type GameJournal } from "./events.js";
+import { type GameResult, replay } from "./state.js";
+
+/**
+ * Le résumé d'une partie enregistrée.
+ *
+ * Glossaire : docs/glossaire/partie-enregistree.md
+ */
+export interface SavedGameSummary {
+    /** Identifiant de la partie, unique sur l'appareil. */
+    readonly id: string;
+    /** Début de la partie et dernière action, en millisecondes depuis 1970. */
+    readonly startedAt: number;
+    readonly updatedAt: number;
+    /** Niveau de l'ordinateur, l'adversaire. */
+    readonly level: Level;
+    /** En cours ou finie, sur la branche courante. */
+    readonly status: "playing" | "over";
+    /** Le résultat sur la branche courante (null si elle n'est pas finie). */
+    readonly result: GameResult | null;
+    /** Coups joués sur la branche courante. */
+    readonly moveCount: number;
+    /** Nombre de branches (1 : jamais rejouée). */
+    readonly branchCount: number;
+}
+
+/** Ce qu'il faut savoir d'une partie pour l'enregistrer, en plus de son
+ * journal. */
+export interface SavedGameDetails {
+    readonly level: Level;
+}
+
+/** Le résumé d'un journal ; startedAt et updatedAt viennent de l'appelant
+ * (le domaine ne lit pas l'horloge). */
+export function summarizeGame(
+    id: string,
+    journal: GameJournal,
+    details: SavedGameDetails,
+    times: { readonly startedAt: number; readonly updatedAt: number },
+): SavedGameSummary {
+    const line = currentLine(journal);
+    const state = replay(line);
+    return {
+        id,
+        startedAt: times.startedAt,
+        updatedAt: times.updatedAt,
+        level: details.level,
+        status: state.phase === "over" ? "over" : "playing",
+        result: state.result,
+        moveCount: line.filter((event) => event.type === "MovePlayed").length,
+        branchCount: branches(journal).length,
+    };
+}

app/src/domain/game/sgf.ts

@@ -0,0 +1,226 @@
+// Export d'une partie au format SGF de GNU Backgammon.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Le SGF (Smart Game Format, FF[4], GM[6] pour le backgammon) est le format
+// de fichier de GNU Backgammon : une suite de nœuds, un par coup ou décision
+// de videau, et des variantes entre parenthèses. Le journal étant un arbre,
+// l'export en est un simple parcours (ADR 0007, point 3) : chaque branche
+// devient une variante. GNU Backgammon ne lit que la première variante de
+// chaque embranchement ; la branche courante de la partie vient donc en
+// premier, pour que gnubg ouvre la partie telle que le joueur la voit.
+//
+// Conventions de gnubg (sgf.c, au commit figé par l'ADR 0005) :
+// - le joueur est « B » (le joueur 1 de gnubg, l'humain), l'ordinateur « W » ;
+// - un coup s'écrit [dés][départ arrivée]… ; une case c (1 à 24, vue de celui
+//   qui joue) s'écrit 'x' - (c - 1) pour B et 'a' + (c - 1) pour W ; la barre
+//   s'écrit 'y', la sortie 'z' ; un coup impossible n'a que ses dés ;
+// - [double], [take], [drop] pour le videau ;
+// - une position de départ autre que l'habituelle se pose par AE, AW, AB et
+//   PL, le videau par CV et CP.
+// Aucune règle n'est jugée ici : les coups et positions viennent du journal,
+// et une position de départ particulière est décodée par le moteur.
+
+import type { Engine } from "./engine.js";
+import { currentLine, type GameEvent, type GameJournal } from "./events.js";
+import { BAR, type HalfMove, OFF, START_POSITION } from "./position.js";
+import type { Side } from "./side.js";
+import { replay } from "./state.js";
+
+export interface SgfOptions {
+    /** Nom du joueur (PB). */
+    readonly playerName: string;
+    /** Nom de l'ordinateur (PW). */
+    readonly computerName: string;
+    /** Date de la partie, AAAA-MM-JJ (DT) ; absente si non fournie. */
+    readonly date?: string;
+}
+
+/** Un nœud SGF et les variantes qui le suivent. */
+interface SgfNode {
+    readonly properties: string;
+    readonly children: SgfNode[];
+}
+
+/**
+ * La partie au format SGF de GNU Backgammon, branches comprises (en
+ * variantes, la branche courante d'abord). Le moteur ne sert qu'à décoder
+ * une position de départ particulière. (Le format : docs/glossaire/sgf.md.)
+ */
+export async function exportSgf(
+    engine: Engine,
+    journal: GameJournal,
+    options: SgfOptions,
+): Promise<string> {
+    const start = journal.events[0];
+    if (start?.type !== "GameStarted") {
+        throw new Error("journal de partie vide ou mal formé");
+    }
+    const byId = new Map(journal.events.map((event) => [event.id, event]));
+    const onHeadLine = new Set(currentLine(journal).map((event) => event.id));
+    const children = new Map<string, GameEvent[]>();
+    for (const event of journal.events) {
+        if (event.parent !== null) {
+            children.set(event.parent, [...(children.get(event.parent) ?? []), event]);
+        }
+    }
+    // La branche courante d'abord, puis les autres dans l'ordre du journal.
+    for (const list of children.values()) {
+        list.sort((a, b) => Number(onHeadLine.has(b.id)) - Number(onHeadLine.has(a.id)));
+    }
+
+    /** Les variantes qui suivent un événement. */
+    const variations = (id: string): SgfNode[] =>
+        (children.get(id) ?? []).flatMap((child) => {
+            const properties = nodeProperties(child, byId, children.has(child.id));
+            const below = variations(child.id);
+            return properties === null ? below : [{ properties, children: below }];
+        });
+
+    // La partie telle que la voit gnubg : la ligne courante.
+    const result = replay(currentLine(journal)).result;
+    const root = [
+        "FF[4]GM[6]CA[UTF-8]AP[Ustagammon]",
+        "MI[length:0][game:0][ws:0][bs:0]",
+        `PW[${escapeText(options.computerName)}]PB[${escapeText(options.playerName)}]`,
+        options.date === undefined ? "" : `DT[${escapeText(options.date)}]`,
+        result === null ? "" : `RE[${letter(result.winner)}+${result.points}]`,
+    ].join("");
+    // Les nœuds d'installation, à la suite l'un de l'autre, puis la partie.
+    const setup = await setupProperties(engine, start);
+    const tree = setup.reduceRight<SgfNode[]>(
+        (below, properties) => [{ properties, children: below }],
+        variations(start.id),
+    );
+    return `(;${root}${sequence(tree)})\n`;
+}
+
+/** Écrit des nœuds : une suite tant qu'il n'y a qu'une variante, puis
+ * chaque variante entre parenthèses. */
+function sequence(nodes: readonly SgfNode[]): string {
+    if (nodes.length === 1) {
+        const [node] = nodes as [SgfNode];
+        return `\n;${node.properties}${sequence(node.children)}`;
+    }
+    return nodes.map((node) => `(\n;${node.properties}${sequence(node.children)})`).join("");
+}
+
+/** Les propriétés du nœud d'un événement, ou null s'il n'en fait pas
+ * (début, dés suivis d'un coup, fin de partie). */
+function nodeProperties(
+    event: GameEvent,
+    byId: ReadonlyMap<string, GameEvent>,
+    hasChildren: boolean,
+): string | null {
+    switch (event.type) {
+        case "MovePlayed": {
+            const rolled = event.parent === null ? undefined : byId.get(event.parent);
+            if (rolled?.type !== "DiceRolled") {
+                throw new Error(`coup sans jet de dés : ${event.id}`);
+            }
+            const moves = event.halfMoves.map((h) => halfMove(h, event.side)).join("");
+            return `${letter(event.side)}[${rolled.roll[0]}${rolled.roll[1]}${moves}]`;
+        }
+        case "CubeOffered":
+            return `${letter(event.side)}[double]`;
+        case "CubeTaken":
+            return `${letter(event.side)}[take]`;
+        case "CubeDropped":
+            return `${letter(event.side)}[drop]`;
+        case "DiceRolled": {
+            // Des dés pas encore joués, au bout d'une branche.
+            if (hasChildren) {
+                return null;
+            }
+            const [a, b] = event.roll;
+            const side = event.side ?? (a > b ? "player" : a < b ? "computer" : null);
+            return side === null ? null : `PL[${letter(side)}]DI[${a}${b}]`;
+        }
+        case "GameStarted":
+        case "GameEnded":
+            return null;
+    }
+}
+
+/** Les propriétés des nœuds qui posent une position de départ particulière
+ * (aucun pour la position habituelle, videau au centre, jet d'ouverture à
+ * faire). */
+async function setupProperties(
+    engine: Engine,
+    start: Extract<GameEvent, { type: "GameStarted" }>,
+): Promise<string[]> {
+    const usual =
+        start.position === START_POSITION &&
+        start.firstTurn === null &&
+        start.cube.value === 1 &&
+        start.cube.owner === null;
+    if (usual) {
+        return [];
+    }
+    const onRoll: Side = start.firstTurn ?? "player";
+    const owner =
+        start.cube.owner === null
+            ? "centered"
+            : start.cube.owner === onRoll
+              ? "onRoll"
+              : "opponent";
+    const board = await engine.board(start.position, { value: start.cube.value, owner });
+    // Chaque camp avec sa propre numérotation : W en 'a' + (c - 1), B en
+    // 'x' - (c - 1), la barre en 'y' (comme les coups).
+    const stones = (side: Side, points: readonly number[], bar: number) => {
+        const out: string[] = [];
+        points.forEach((count, i) => {
+            for (let k = 0; k < count; k++) {
+                out.push(`[${pointLetter(i + 1, side)}]`);
+            }
+        });
+        for (let k = 0; k < bar; k++) {
+            out.push("[y]");
+        }
+        return out.join("");
+    };
+    const other: Side = onRoll === "player" ? "computer" : "player";
+    const sides = { [onRoll]: board.onRoll, [other]: board.opponent } as Record<
+        Side,
+        typeof board.onRoll
+    >;
+    const white = stones("computer", sides.computer.points, sides.computer.bar);
+    const black = stones("player", sides.player.points, sides.player.bar);
+    const nodes = [
+        `PL[${letter(onRoll)}]AE[a:y]${white === "" ? "" : `AW${white}`}${black === "" ? "" : `AB${black}`}`,
+    ];
+    if (start.cube.value !== 1) {
+        nodes.push(`CV[${start.cube.value}]`);
+    }
+    if (start.cube.owner !== null) {
+        nodes.push(`CP[${start.cube.owner === "player" ? "b" : "w"}]`);
+    }
+    return nodes;
+}
+
+function letter(side: Side): "B" | "W" {
+    return side === "player" ? "B" : "W";
+}
+
+function halfMove(h: HalfMove, side: Side): string {
+    return pointLetter(h.from, side) + pointLetter(h.to, side);
+}
+
+/** Une case vue du camp side : 1 à 24, BAR ou OFF. */
+function pointLetter(point: number, side: Side): string {
+    if (point === BAR) {
+        return "y";
+    }
+    if (point === OFF) {
+        return "z";
+    }
+    const code =
+        side === "player" ? "x".charCodeAt(0) - (point - 1) : "a".charCodeAt(0) + point - 1;
+    return String.fromCharCode(code);
+}
+
+/** Échappe un texte libre dans une valeur SGF. */
+function escapeText(text: string): string {
+    return text.replace(/[\\\]]/g, (c) => `\\${c}`);
+}

app/src/domain/learning/tutorial.ts

@@ -0,0 +1,241 @@
+// Le tutoriel des règles, côté domaine : les positions illustrées et les
+// écrans « à vous », vérifiés par le moteur.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Le texte du tutoriel vit dans docs/tutoriel/ (ADR 0008 : une seule
+// source) ; il donne pour chaque écran une position par son identifiant
+// gnubg (ADR 0013), un jet, et les coups attendus en notation de gnubg.
+// Rien n'est jugé ici : le moteur dit quels coups sont légaux, où mène
+// chaque demi-coup, et s'il faut prendre un double. Le domaine ne fait que
+// comparer ce qu'a joué le joueur aux coups attendus que le moteur a
+// reconnus.
+
+import { CENTERED_CUBE, type Cube } from "../game/cube.js";
+import type { BoardResult, Engine, EngineCube, Move } from "../game/engine.js";
+import { Game, type MoveSteps, type SideBoards, STANDARD_PLY } from "../game/game.js";
+import type { HalfMove, PositionId } from "../game/position.js";
+import { fixedDice, type Roll } from "../game/roll.js";
+import type { Side } from "../game/side.js";
+
+/** Un plateau du tutoriel, décodé par le moteur, et le résultat si la
+ * partie y est finie (vu du camp « player »). */
+export interface TutorialBoard {
+    readonly sides: SideBoards;
+    readonly result: { readonly winner: Side; readonly kind: BoardResult["kind"] } | null;
+}
+
+/** Le videau vu du camp au trait. */
+function engineCube(cube: Cube, onRoll: Side): EngineCube {
+    return {
+        value: cube.value,
+        owner: cube.owner === null ? "centered" : cube.owner === onRoll ? "onRoll" : "opponent",
+    };
+}
+
+/** Le plateau d'une position vue de onRoll, décodé par le moteur (erreur si
+ * l'identifiant est illisible). */
+export async function tutorialBoard(
+    engine: Engine,
+    position: PositionId,
+    onRoll: Side = "player",
+    cube: Cube = CENTERED_CUBE,
+): Promise<TutorialBoard> {
+    const board = await engine.board(position, engineCube(cube, onRoll));
+    const sides =
+        onRoll === "player"
+            ? { player: board.onRoll, computer: board.opponent }
+            : { player: board.opponent, computer: board.onRoll };
+    const result =
+        board.result === null
+            ? null
+            : {
+                  winner:
+                      (board.result.winner === "onRoll") === (onRoll === "player")
+                          ? ("player" as const)
+                          : ("computer" as const),
+                  kind: board.result.kind,
+              };
+    return { sides, result };
+}
+
+/** Les coups du jet que le moteur déclare légaux et dont la notation est
+ * l'une des notations données. Erreur si l'une d'elles n'est pas un coup
+ * légal : le texte du tutoriel ne correspond plus au moteur. */
+export async function expectedMoves(
+    engine: Engine,
+    position: PositionId,
+    roll: Roll,
+    notations: readonly string[],
+): Promise<Move[]> {
+    const legal = await engine.legalMoves(position, roll);
+    return notations.map((notation) => {
+        const move = legal.find((m) => m.notation === notation);
+        if (move === undefined) {
+            throw new Error(
+                `${notation} n'est pas un coup légal de ${roll.join("-")} dans ${position}`,
+            );
+        }
+        return move;
+    });
+}
+
+/** Le coup illustré d'un écran d'explication, demi-coup par demi-coup :
+ * les plateaux successifs, donnés par le moteur, et le résultat si le coup
+ * finit la partie. */
+export async function illustratedMove(
+    engine: Engine,
+    position: PositionId,
+    roll: Roll,
+    notation: string,
+): Promise<{ steps: MoveSteps; after: TutorialBoard }> {
+    const [move] = await expectedMoves(engine, position, roll, [notation]);
+    if (move === undefined) {
+        throw new Error(`coup illustré introuvable : ${notation}`);
+    }
+    const positions = [position];
+    for (let i = 1; i <= move.halfMoves.length; i++) {
+        const check = await engine.checkHalfMoves(position, roll, move.halfMoves.slice(0, i));
+        if (check.position === null) {
+            throw new Error(`demi-coup refusé par le moteur : ${notation}`);
+        }
+        positions.push(check.position);
+    }
+    const boards = await Promise.all(positions.map((p) => tutorialBoard(engine, p)));
+    const hits = move.halfMoves.map(
+        (_, i) => (boards[i + 1]?.sides.computer.bar ?? 0) > (boards[i]?.sides.computer.bar ?? 0),
+    );
+    const after = boards.at(-1) ?? boards[0];
+    if (after === undefined) {
+        throw new Error("aucun plateau");
+    }
+    return {
+        steps: {
+            side: "player",
+            halfMoves: move.halfMoves,
+            boards: boards.map((b) => b.sides),
+            hits,
+        },
+        after,
+    };
+}
+
+/**
+ * Les demi-coups saisis peuvent-ils encore mener à l'un des coups attendus ?
+ * Oui s'ils font tous partie (comme multiensemble) des demi-coups de l'un
+ * d'eux, tels que le moteur les donne. Un coup complet est jugé sur sa
+ * position (verdict de MovePractice).
+ */
+export function canStillLeadTo(played: readonly HalfMove[], expected: readonly Move[]): boolean {
+    return expected.some((move) => {
+        const left = [...move.halfMoves];
+        return played.every((h) => {
+            const i = left.findIndex((m) => m.from === h.from && m.to === h.to);
+            if (i < 0) {
+                return false;
+            }
+            left.splice(i, 1);
+            return true;
+        });
+    });
+}
+
+/** Ce que devient un écran « à vous » après un demi-coup. */
+export type PracticeVerdict = "continue" | "right" | "wrong";
+
+/**
+ * Un écran « à vous » où le joueur joue un coup : une partie d'un seul jet,
+ * commencée à la position de l'écran, jamais enregistrée. Le joueur saisit
+ * ses demi-coups comme en partie (le moteur dit lesquels sont permis) ; le
+ * coup est juste s'il mène à la position de l'un des coups attendus.
+ */
+export class MovePractice {
+    readonly #game: Game;
+    readonly #expected: readonly Move[];
+    readonly roll: Roll;
+
+    private constructor(game: Game, expected: readonly Move[], roll: Roll) {
+        this.#game = game;
+        this.#expected = expected;
+        this.roll = roll;
+    }
+
+    /** Prépare l'écran : la position, le jet, et les coups attendus,
+     * reconnus par le moteur (erreur sinon). */
+    static async start(
+        engine: Engine,
+        position: PositionId,
+        roll: Roll,
+        notations: readonly string[],
+    ): Promise<MovePractice> {
+        const expected = await expectedMoves(engine, position, roll, notations);
+        const game = Game.start(engine, {
+            setup: { position, firstTurn: "player" },
+            dice: fixedDice(roll),
+            ply: 0,
+        });
+        await game.roll();
+        return new MovePractice(game, expected, roll);
+    }
+
+    /** Le plateau affiché, demi-coups saisis compris. */
+    board(): Promise<SideBoards> {
+        return this.#game.displayedBoard();
+    }
+
+    /** Les demi-coups permis maintenant (le moteur le dit). */
+    nextHalfMoves(): Promise<HalfMove[]> {
+        return this.#game.nextHalfMoves();
+    }
+
+    get pendingHalfMoves(): readonly HalfMove[] {
+        return this.#game.pendingHalfMoves;
+    }
+
+    /** Les dés du jet, et ceux déjà utilisés. */
+    get diceToPlay(): { value: number; used: boolean }[] {
+        return this.#game.diceToPlay;
+    }
+
+    /**
+     * Joue un demi-coup. « wrong » si le moteur le refuse, ou s'il ne peut
+     * plus mener à un coup attendu, ou si le coup complet n'est pas l'un
+     * d'eux : le demi-coup reste affiché, à l'appelant de revenir en
+     * arrière (reset). « right » quand le coup complet est l'un des coups
+     * attendus.
+     */
+    async play(halfMove: HalfMove): Promise<PracticeVerdict> {
+        if (!(await this.#game.playHalfMove(halfMove))) {
+            return "wrong";
+        }
+        if (this.#game.moveComplete) {
+            const position = this.#game.displayedPosition;
+            return this.#expected.some((m) => m.position === position) ? "right" : "wrong";
+        }
+        return canStillLeadTo(this.#game.pendingHalfMoves, this.#expected) ? "continue" : "wrong";
+    }
+
+    /** Le pion revient : tous les demi-coups saisis sont oubliés. */
+    reset(): void {
+        this.#game.cancelHalfMoves();
+    }
+}
+
+/**
+ * Un écran « à vous » de videau : l'ordinateur, au trait dans position (vue
+ * de lui), double. Le moteur dit, au niveau standard de l'ordinateur, si le
+ * joueur doit prendre (vrai) ou passer (faux). Erreur si l'ordinateur ne
+ * peut pas doubler dans cette position.
+ */
+export async function shouldTake(engine: Engine, position: PositionId): Promise<boolean> {
+    const decision = await engine.cubeDecision(
+        position,
+        { value: 1, owner: "centered" },
+        STANDARD_PLY,
+    );
+    if (!decision.available) {
+        throw new Error(`l'ordinateur ne peut pas doubler dans ${position}`);
+    }
+    return decision.take;
+}

app/src/engine/wasm-engine.ts

@@ -22,12 +22,19 @@ import type {
     Level,
     Luck,
     LuckRating,
+    MatchDescription,
+    MatchId,
     Move,
     MoveAnalysis,
     Ply,
     Skill,
 } from "../domain/game/engine.js";
-import { formatHalfMoves, type HalfMove, type PositionId } from "../domain/game/position.js";
+import {
+    formatHalfMoves,
+    type HalfMove,
+    type PositionId,
+    START_POSITION,
+} from "../domain/game/position.js";
 import type { Roll } from "../domain/game/roll.js";
 
 /** Exécute une commande d'engine-cli et renvoie son JSON décodé ; la
@@ -208,6 +215,35 @@ export function createWasmEngine(run: RunCommand): Engine {
             return { value: answer.luck, rating };
         },
 
+        encodeMatch: matchId,
+
+        async decodeMatch(id: MatchId): Promise<MatchDescription> {
+            // engine-cli n'a pas de commande qui décode seule un Match ID :
+            // l'évaluation à 0 pli (quelques millisecondes) le décode, le
+            // valide (SetCubeInfo de gnubg) et le renvoie lisible.
+            const answer = (await run(["--ply", "0", "eval", START_POSITION, id])) as {
+                match: {
+                    match_length: number;
+                    score: [number, number];
+                    cube_value: number;
+                    cube_owner: number;
+                    player_on_roll: number;
+                    crawford: boolean;
+                    jacoby: boolean;
+                };
+            };
+            const m = answer.match;
+            return {
+                matchLength: m.match_length,
+                score: m.score,
+                cubeValue: m.cube_value,
+                cubeOwner: m.cube_owner === 0 || m.cube_owner === 1 ? m.cube_owner : -1,
+                playerOnRoll: m.player_on_roll === 1 ? 1 : 0,
+                crawford: m.crawford,
+                jacoby: m.jacoby,
+            };
+        },
+
         async checkHalfMoves(
             position: PositionId,
             roll: Roll,

app/src/main.ts

@@ -6,43 +6,129 @@
 // Licence : GPLv3 ou ultérieure (voir LICENSE).
 
 import { Game } from "./domain/game/game.js";
+import { linkOf, readPosition } from "./domain/game/position-link.js";
+import { exportSgf } from "./domain/game/sgf.js";
+import {
+    illustratedMove,
+    MovePractice,
+    shouldTake,
+    tutorialBoard,
+} from "./domain/learning/tutorial.js";
 import { createWasmEngine } from "./engine/wasm-engine.js";
 import { startEngineWorker } from "./engine/worker-run.js";
-import { createGameStore } from "./storage/game-store.js";
+import { createGameSession } from "./storage/game-session.js";
+import { memoryStorage, openGameLibrary } from "./storage/open-library.js";
+import { createSettingsStore } from "./storage/settings-store.js";
 import { startApp } from "./ui/app.js";
+import { startUpdates } from "./ui/updates.js";
 
 // Ce fichier est servi sous app/ ; le Worker et le service worker sont à la
 // racine du site.
 const worker = startEngineWorker(new URL("../engine-worker.mjs", import.meta.url));
 const engine = createWasmEngine(worker.run);
-const store = createGameStore(window.localStorage);
+
+// Chaque accès au stockage du navigateur peut lever une exception (stockage
+// interdit) : on fait alors sans.
+const localStorage = attempt(() => window.localStorage);
+const settings = createSettingsStore(localStorage ?? memoryStorage());
+
+// Les parties enregistrées (IndexedDB, ou localStorage en repli), ouvertes
+// pendant que le moteur se charge : le plateau est dessiné sans les
+// attendre. L'écran de jeu ne s'en sert qu'une fois engineReady résolue.
+const opening = (async () => {
+    const { library } = await openGameLibrary({
+        indexedDB: attempt(() => window.indexedDB),
+        localStorage,
+    });
+    // Le niveau de l'ordinateur : celui de Game.start (STANDARD_PLY).
+    const session = createGameSession(
+        library,
+        {
+            start: (setup) => Game.start(engine, setup === undefined ? {} : { setup }),
+            resume: (journal) => Game.resume(engine, journal),
+        },
+        "2ply",
+    );
+    const saved = await session.restore();
+    return { library, session, saved };
+})();
+let stored: Awaited<typeof opening> | null = null;
+/** Le stockage, ouvert (toujours le cas une fois engineReady résolue). */
+function storage(): Awaited<typeof opening> {
+    if (stored === null) {
+        throw new Error("stockage pas encore ouvert");
+    }
+    return stored;
+}
 
 startApp({
-    engineReady: worker.ready,
-    newGame: () => Game.start(engine),
-    savedGame: () => {
-        const journal = store.load();
-        if (journal === null) {
-            return null;
-        }
-        try {
-            return Game.resume(engine, journal);
-        } catch {
-            return null; // partie illisible : on en commence une nouvelle
-        }
+    engineReady: Promise.all([
+        worker.ready,
+        opening.then((opened) => {
+            stored = opened;
+        }),
+    ]),
+    newGame: (setup) => storage().session.newGame(setup),
+    positions: {
+        read: (link) => readPosition(engine, link),
+        linkOf: (game) => linkOf(engine, game.state),
     },
-    saveGame: (journal) => store.save(journal),
-    confirm: (question) => window.confirm(question),
+    savedGame: () => storage().saved,
+    resumePrevious: () => storage().session.resumePrevious(),
+    saveGame: (journal) => storage().session.save(journal),
+    games: {
+        list: () => storage().library.list(),
+        journal: async (id) => (await storage().library.load(id))?.journal ?? null,
+        shownId: () => storage().session.shownId,
+        open: (id, branchHead) => storage().session.open(id, branchHead),
+        remove: (id) => storage().library.remove(id),
+        exportSgf: async (id) => {
+            const game = await storage().library.load(id);
+            if (game === null) {
+                throw new Error("partie introuvable");
+            }
+            const started = new Date(game.summary.startedAt);
+            const two = (n: number) => String(n).padStart(2, "0");
+            const date = `${started.getFullYear()}-${two(started.getMonth() + 1)}-${two(started.getDate())}`;
+            const text = await exportSgf(engine, game.journal, {
+                playerName: "Vous",
+                computerName: "Ustagammon",
+                date,
+            });
+            const time = `${two(started.getHours())}${two(started.getMinutes())}`;
+            return { fileName: `ustagammon-${date}-${time}.sgf`, text };
+        },
+    },
+    cachedBoard: () => settings.loadBoard(),
+    saveBoard: (board) => settings.saveBoard(board),
+    loadSettings: () => settings.loadSettings(),
+    saveSettings: (json) => settings.saveSettings(json),
+    // Le tutoriel : positions, coups illustrés et gestes jugés par le
+    // domaine, sur le moteur.
+    tutorial: {
+        board: (position, onRoll) => tutorialBoard(engine, position, onRoll),
+        illustrate: (position, roll, move) => illustratedMove(engine, position, roll, move),
+        practice: (position, roll, expected) =>
+            MovePractice.start(engine, position, roll, expected),
+        shouldTake: (position) => shouldTake(engine, position),
+    },
+    // Hors ligne : le service worker met tout le site en cache. Le navigateur
+    // le refuse hors https (sauf localhost) : l'application marche alors sans.
+    // Il est enregistré une fois le moteur chargé : si le Worker et le service
+    // worker téléchargent les données du moteur (8,7 Mo) en même temps,
+    // Chromium fait échouer l'installation (« Cache.add() encountered a
+    // network error »), et l'application n'est pas disponible hors ligne.
+    // Cela évite aussi de télécharger deux fois ces données à la première
+    // visite.
+    startUpdates: (onAvailable) =>
+        startUpdates(new URL("../sw.js", import.meta.url), worker.ready, onAvailable),
 });
 
-// Hors ligne : le service worker met tout le site en cache. Le navigateur le
-// refuse hors https (sauf localhost) : l'application marche alors sans.
-// Il est enregistré une fois le moteur chargé : si le Worker et le service
-// worker téléchargent les données du moteur (8,7 Mo) en même temps, Chromium
-// fait échouer l'installation (« Cache.add() encountered a network error »),
-// et l'application n'est pas disponible hors ligne. Cela évite aussi de
-// télécharger deux fois ces données à la première visite.
-if ("serviceWorker" in navigator) {
-    const sw = new URL("../sw.js", import.meta.url);
-    worker.ready.then(() => navigator.serviceWorker.register(sw)).catch(() => {});
+/** La valeur, ou undefined si l'obtenir lève une exception. */
+function attempt<T>(get: () => T): T | undefined {
+    try {
+        return get();
+    } catch {
+        return undefined;
+    }
 }

app/src/storage/game-library.ts

@@ -0,0 +1,140 @@
+// Les parties enregistrées sur l'appareil : leur résumé, leur journal
+// d'événements, et laquelle est la partie en cours.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Deux stockages derrière la même interface (GameLibrary) :
+// - IndexedDB, le stockage normal du navigateur (indexeddb-backend.ts) ;
+// - un stockage clé-valeur (localStorage), en repli quand IndexedDB est
+//   indisponible, par exemple en navigation privée de certains navigateurs.
+// Les opérations sont exécutées l'une après l'autre, dans l'ordre des
+// appels : un enregistrement lancé sans être attendu est donc toujours fait
+// avant la lecture qui suit.
+
+import type { GameJournal } from "../domain/game/events.js";
+import {
+    type SavedGameDetails,
+    type SavedGameSummary,
+    summarizeGame,
+} from "../domain/game/saved-game.js";
+
+/** Une partie enregistrée : son résumé et son journal. */
+export interface SavedGame {
+    readonly summary: SavedGameSummary;
+    readonly journal: GameJournal;
+}
+
+export interface GameLibrary {
+    /** Les parties, la dernière jouée d'abord. */
+    list(): Promise<SavedGameSummary[]>;
+    /** Une partie, ou null si elle n'existe pas ou est illisible. */
+    load(id: string): Promise<SavedGame | null>;
+    /** Enregistre la partie id (nouvelle ou non), qui devient la partie en
+     * cours. Renvoie son résumé. */
+    save(id: string, journal: GameJournal, details: SavedGameDetails): Promise<SavedGameSummary>;
+    /** Supprime une partie (rien si elle n'existe pas). */
+    remove(id: string): Promise<void>;
+    /** La partie en cours : la dernière enregistrée ou choisie (setCurrent),
+     * si elle existe encore ; sinon la dernière jouée ; null s'il n'y en a
+     * aucune. */
+    current(): Promise<SavedGame | null>;
+    /** Fait d'une partie enregistrée la partie en cours, sans la modifier
+     * (pour la reprendre). */
+    setCurrent(id: string): Promise<void>;
+}
+
+/** Ce que chaque stockage sait faire ; GameLibrary ajoute l'ordre des
+ * opérations, les dates et la validation. */
+export interface LibraryBackend {
+    summaries(): Promise<SavedGameSummary[]>;
+    summary(id: string): Promise<SavedGameSummary | undefined>;
+    journal(id: string): Promise<unknown>;
+    /** Écrit le résumé et le journal ensemble. */
+    write(summary: SavedGameSummary, journal: GameJournal): Promise<void>;
+    remove(id: string): Promise<void>;
+    currentId(): Promise<string | undefined>;
+    setCurrentId(id: string): Promise<void>;
+}
+
+export interface LibraryOptions {
+    /** L'horloge, en millisecondes ; Date.now par défaut. */
+    readonly now?: () => number;
+}
+
+/** Un identifiant de partie : la date et du hasard, sans dépendre de
+ * crypto.randomUUID, absent hors https. */
+export function newGameId(now: number = Date.now()): string {
+    const random = Math.floor(Math.random() * 36 ** 6)
+        .toString(36)
+        .padStart(6, "0");
+    return `${now.toString(36)}-${random}`;
+}
+
+/** Un journal lisible : la forme attendue, sans juger de son contenu (le
+ * domaine le vérifie en reprenant la partie). */
+export function isJournal(value: unknown): value is GameJournal {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const journal = value as { events?: unknown; head?: unknown };
+    return (
+        Array.isArray(journal.events) && (journal.head === null || typeof journal.head === "string")
+    );
+}
+
+export function createGameLibrary(
+    backend: LibraryBackend,
+    options: LibraryOptions = {},
+): GameLibrary {
+    const now = options.now ?? Date.now;
+    let queue: Promise<unknown> = Promise.resolve();
+    /** Exécute op après toutes les opérations déjà demandées. */
+    const enqueue = <T>(op: () => Promise<T>): Promise<T> => {
+        const result = queue.then(op, op);
+        queue = result.catch(() => {});
+        return result;
+    };
+
+    const load = async (id: string): Promise<SavedGame | null> => {
+        const summary = await backend.summary(id);
+        const journal = await backend.journal(id);
+        return summary === undefined || !isJournal(journal) ? null : { summary, journal };
+    };
+    const list = async () => (await backend.summaries()).sort((a, b) => b.updatedAt - a.updatedAt);
+
+    return {
+        list: () => enqueue(list),
+        load: (id) => enqueue(() => load(id)),
+        save: (id, journal, details) =>
+            enqueue(async () => {
+                const time = now();
+                const startedAt = (await backend.summary(id))?.startedAt ?? time;
+                const summary = summarizeGame(id, journal, details, {
+                    startedAt,
+                    updatedAt: Math.max(time, startedAt),
+                });
+                await backend.write(summary, journal);
+                await backend.setCurrentId(id);
+                return summary;
+            }),
+        remove: (id) => enqueue(() => backend.remove(id)),
+        current: () =>
+            enqueue(async () => {
+                const id = await backend.currentId();
+                const chosen = id === undefined ? null : await load(id);
+                if (chosen !== null) {
+                    return chosen;
+                }
+                const latest = (await list())[0];
+                return latest === undefined ? null : load(latest.id);
+            }),
+        setCurrent: (id) =>
+            enqueue(async () => {
+                if ((await backend.summary(id)) === undefined) {
+                    throw new Error(`partie introuvable : ${id}`);
+                }
+                await backend.setCurrentId(id);
+            }),
+    };
+}

app/src/storage/game-session.ts

@@ -0,0 +1,131 @@
+// La partie à l'écran et son enregistrement : quel identifiant elle porte,
+// la nouvelle partie qu'on peut annuler (« Reprendre l'ancienne »), la
+// reprise d'une partie enregistrée ou de l'une de ses branches.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// main.ts la branche sur l'écran de jeu ; les scénarios l'utilisent telle
+// quelle, sur un stockage en mémoire.
+
+import { switchToBranch } from "../domain/game/branches.js";
+import type { Level } from "../domain/game/engine.js";
+import type { GameJournal } from "../domain/game/events.js";
+import type { Game, GameSetup } from "../domain/game/game.js";
+import { type GameLibrary, newGameId } from "./game-library.js";
+
+/** Comment créer une partie : commencée, ou reprise d'un journal (erreur si
+ * le journal est illisible). */
+export interface GameFactory {
+    readonly start: (setup?: GameSetup) => Game;
+    readonly resume: (journal: GameJournal) => Game;
+}
+
+export interface GameSession {
+    /** L'identifiant de la partie à l'écran (null avant la première). */
+    readonly shownId: string | null;
+    /** La partie en cours enregistrée, reprise ; null s'il n'y en a pas ou
+     * si elle est illisible. */
+    restore(): Promise<Game | null>;
+    /** Une nouvelle partie (depuis la position de setup si elle est donnée) ;
+     * celle qu'elle remplace reste reprenable par resumePrevious, jusqu'au
+     * prochain changement de partie. */
+    newGame(setup?: GameSetup): Game;
+    /** Enregistre la partie à l'écran (sans attendre la fin de l'écriture ;
+     * un échec est ignoré : la partie continue). */
+    save(journal: GameJournal): void;
+    /** « Reprendre l'ancienne » : la partie quittée par newGame, relue dans
+     * le stockage ; la nouvelle est supprimée. null s'il n'y en a pas. */
+    resumePrevious(): Promise<Game | null>;
+    /** Reprend une partie enregistrée, au bout de la branche branchHead si
+     * elle est donnée. Erreur si elle n'existe pas ou est illisible. */
+    open(id: string, branchHead?: string): Promise<Game>;
+}
+
+export function createGameSession(
+    library: GameLibrary,
+    games: GameFactory,
+    level: Level,
+): GameSession {
+    let shownId: string | null = null;
+    let previousId: string | null = null;
+
+    /** Une partie enregistrée, reprise ; null si absente ou illisible. */
+    const resume = async (id: string): Promise<Game | null> => {
+        const saved = await library.load(id);
+        if (saved === null) {
+            return null;
+        }
+        try {
+            return games.resume(saved.journal);
+        } catch {
+            return null;
+        }
+    };
+
+    return {
+        get shownId() {
+            return shownId;
+        },
+        async restore() {
+            const saved = await library.current().catch(() => null);
+            if (saved === null) {
+                return null;
+            }
+            try {
+                const game = games.resume(saved.journal);
+                shownId = saved.summary.id;
+                return game;
+            } catch {
+                return null; // partie illisible : on en commencera une nouvelle
+            }
+        },
+        newGame(setup) {
+            previousId = shownId;
+            shownId = newGameId();
+            return games.start(setup);
+        },
+        save(journal) {
+            if (shownId !== null) {
+                library.save(shownId, journal, { level }).catch(() => {});
+            }
+        },
+        async resumePrevious() {
+            const id = previousId;
+            if (id === null) {
+                return null;
+            }
+            const resumed = await resume(id);
+            if (resumed === null) {
+                return null;
+            }
+            const abandoned = shownId;
+            previousId = null;
+            shownId = id;
+            await library.setCurrent(id);
+            if (abandoned !== null) {
+                await library.remove(abandoned);
+            }
+            return resumed;
+        },
+        async open(id, branchHead) {
+            const saved = await library.load(id);
+            if (saved === null) {
+                throw new Error("partie introuvable");
+            }
+            const journal =
+                branchHead === undefined
+                    ? saved.journal
+                    : switchToBranch(saved.journal, branchHead);
+            const game = games.resume(journal);
+            previousId = null;
+            shownId = id;
+            if (branchHead === undefined) {
+                await library.setCurrent(id);
+            } else {
+                await library.save(id, journal, { level: saved.summary.level });
+            }
+            return game;
+        },
+    };
+}

app/src/storage/game-store.ts

@@ -1,47 +0,0 @@
-// L'enregistrement de la partie en cours, pour la reprendre après fermeture
-// de la page : son journal d'événements, en JSON, dans un stockage clé-valeur
-// (localStorage dans le navigateur).
-//
-// Copyright (C) 2026 les auteurs d'Ustagammon.
-// Licence : GPLv3 ou ultérieure (voir LICENSE).
-
-import type { GameJournal } from "../domain/game/events.js";
-
-/** Ce qu'il faut d'un stockage clé-valeur (localStorage en a davantage). */
-export interface KeyValueStorage {
-    getItem(key: string): string | null;
-    setItem(key: string, value: string): void;
-}
-
-export interface GameStore {
-    /** Le journal enregistré, ou null s'il n'y en a pas de lisible. */
-    load(): GameJournal | null;
-    save(journal: GameJournal): void;
-}
-
-const KEY = "ustagammon.current-game";
-
-export function createGameStore(storage: KeyValueStorage): GameStore {
-    return {
-        load() {
-            try {
-                const journal = JSON.parse(storage.getItem(KEY) ?? "null");
-                const valid =
-                    journal !== null &&
-                    Array.isArray(journal.events) &&
-                    (journal.head === null || typeof journal.head === "string");
-                return valid ? journal : null;
-            } catch {
-                return null;
-            }
-        },
-        save(journal) {
-            try {
-                storage.setItem(KEY, JSON.stringify(journal));
-            } catch {
-                // Stockage plein ou interdit (navigation privée) : la partie
-                // continue, elle ne pourra seulement pas être reprise.
-            }
-        },
-    };
-}

app/src/storage/indexeddb-backend.ts

@@ -0,0 +1,81 @@
+// Les parties dans IndexedDB, le stockage de données du navigateur.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Base « ustagammon », trois magasins d'objets :
+// - games : les résumés des parties (SavedGameSummary), clé id ;
+// - journals : leurs journaux, { id, journal }, clé id ;
+// - settings : { key, value }, dont la partie en cours (key « current »).
+// Le résumé et le journal d'une partie sont écrits dans la même transaction.
+// L'API IndexedDB est utilisée directement, sans bibliothèque.
+
+import type { GameJournal } from "../domain/game/events.js";
+import type { SavedGameSummary } from "../domain/game/saved-game.js";
+import type { LibraryBackend } from "./game-library.js";
+
+const DATABASE = "ustagammon";
+const VERSION = 1;
+const GAMES = "games";
+const JOURNALS = "journals";
+const SETTINGS = "settings";
+
+/** Le résultat d'une requête IndexedDB, en promesse. */
+function done<T>(request: IDBRequest<T>): Promise<T> {
+    return new Promise((resolve, reject) => {
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+}
+
+/** La fin d'une transaction (toutes ses écritures faites), en promesse. */
+function committed(transaction: IDBTransaction): Promise<void> {
+    return new Promise((resolve, reject) => {
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => reject(transaction.error);
+        transaction.onabort = () => reject(transaction.error ?? new Error("transaction annulée"));
+    });
+}
+
+/** Ouvre la base, en la créant au besoin. Rejetée si IndexedDB est
+ * indisponible ou refusé. */
+export async function openIndexedDbBackend(factory: IDBFactory): Promise<LibraryBackend> {
+    const request = factory.open(DATABASE, VERSION);
+    request.onupgradeneeded = () => {
+        const db = request.result;
+        db.createObjectStore(GAMES, { keyPath: "id" });
+        db.createObjectStore(JOURNALS, { keyPath: "id" });
+        db.createObjectStore(SETTINGS, { keyPath: "key" });
+    };
+    const db = await done(request);
+
+    const get = async <T>(store: string, key: string): Promise<T | undefined> =>
+        done(db.transaction(store).objectStore(store).get(key));
+
+    return {
+        summaries: async () => done(db.transaction(GAMES).objectStore(GAMES).getAll()),
+        summary: (id) => get<SavedGameSummary>(GAMES, id),
+        journal: async (id) => (await get<{ journal: unknown }>(JOURNALS, id))?.journal,
+        write: async (summary: SavedGameSummary, journal: GameJournal) => {
+            const transaction = db.transaction([GAMES, JOURNALS], "readwrite");
+            transaction.objectStore(JOURNALS).put({ id: summary.id, journal });
+            transaction.objectStore(GAMES).put(summary);
+            await committed(transaction);
+        },
+        remove: async (id) => {
+            const transaction = db.transaction([GAMES, JOURNALS], "readwrite");
+            transaction.objectStore(GAMES).delete(id);
+            transaction.objectStore(JOURNALS).delete(id);
+            await committed(transaction);
+        },
+        currentId: async () => {
+            const setting = await get<{ value: unknown }>(SETTINGS, "current");
+            return typeof setting?.value === "string" ? setting.value : undefined;
+        },
+        setCurrentId: async (id) => {
+            const transaction = db.transaction(SETTINGS, "readwrite");
+            transaction.objectStore(SETTINGS).put({ key: "current", value: id });
+            await committed(transaction);
+        },
+    };
+}

app/src/storage/key-value-backend.ts

@@ -0,0 +1,99 @@
+// Les parties dans un stockage clé-valeur (localStorage), en JSON : le
+// repli quand IndexedDB est indisponible, et la lecture de la partie
+// enregistrée par les versions précédentes, pour la migrer.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import type { GameJournal } from "../domain/game/events.js";
+import type { SavedGameSummary } from "../domain/game/saved-game.js";
+import { type GameLibrary, isJournal, type LibraryBackend, newGameId } from "./game-library.js";
+
+/** Ce qu'il faut d'un stockage clé-valeur (localStorage en a davantage). */
+export interface KeyValueStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+
+const SUMMARIES = "ustagammon.games";
+const CURRENT = "ustagammon.current-game-id";
+const journalKey = (id: string) => `ustagammon.game.${id}`;
+
+/** La partie unique des versions précédentes (étape 0), à migrer. */
+const LEGACY_GAME = "ustagammon.current-game";
+
+/** Lit une clé en JSON ; undefined si elle est absente, illisible, ou si le
+ * stockage est interdit. */
+function read(storage: KeyValueStorage, key: string): unknown {
+    try {
+        const text = storage.getItem(key);
+        return text === null ? undefined : JSON.parse(text);
+    } catch {
+        return undefined;
+    }
+}
+
+export function createKeyValueBackend(storage: KeyValueStorage): LibraryBackend {
+    const summaries = (): SavedGameSummary[] => {
+        const value = read(storage, SUMMARIES);
+        return Array.isArray(value) ? value : [];
+    };
+    const writeSummaries = (list: readonly SavedGameSummary[]) =>
+        storage.setItem(SUMMARIES, JSON.stringify(list));
+    return {
+        summaries: async () => summaries(),
+        summary: async (id) => summaries().find((s) => s.id === id),
+        journal: async (id) => read(storage, journalKey(id)),
+        write: async (summary, journal) => {
+            // Le journal d'abord : un résumé ne désigne jamais un journal
+            // absent.
+            storage.setItem(journalKey(summary.id), JSON.stringify(journal));
+            writeSummaries([...summaries().filter((s) => s.id !== summary.id), summary]);
+        },
+        remove: async (id) => {
+            writeSummaries(summaries().filter((s) => s.id !== id));
+            storage.removeItem(journalKey(id));
+        },
+        currentId: async () => {
+            const id = read(storage, CURRENT);
+            return typeof id === "string" ? id : undefined;
+        },
+        setCurrentId: async (id) => storage.setItem(CURRENT, JSON.stringify(id)),
+    };
+}
+
+/**
+ * Reprend dans library la partie enregistrée par les versions précédentes
+ * (une seule partie, sous une clé de localStorage), qui devient la partie
+ * en cours ; puis efface l'ancienne clé. Sans effet s'il n'y en a pas. Un
+ * journal illisible est effacé. Renvoie l'identifiant de la partie migrée.
+ */
+export async function migrateLegacyGame(
+    storage: KeyValueStorage,
+    library: GameLibrary,
+    now: number = Date.now(),
+): Promise<string | null> {
+    let present: boolean;
+    try {
+        present = storage.getItem(LEGACY_GAME) !== null;
+    } catch {
+        return null;
+    }
+    if (!present) {
+        return null;
+    }
+    const journal: unknown = read(storage, LEGACY_GAME);
+    let id: string | null = null;
+    if (isJournal(journal) && journal.events.length > 0) {
+        id = newGameId(now);
+        // Les parties de l'étape 0 se jouaient toutes au niveau standard.
+        await library.save(id, journal as GameJournal, { level: "2ply" });
+    }
+    try {
+        storage.removeItem(LEGACY_GAME);
+    } catch {
+        // Stockage interdit : la migration sera refaite, sans dommage.
+    }
+    return id;
+}

app/src/storage/open-library.ts

@@ -0,0 +1,96 @@
+// Ouverture des parties enregistrées au démarrage : IndexedDB si possible,
+// sinon localStorage, puis migration de la partie des versions précédentes.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import { createGameLibrary, type GameLibrary, type LibraryOptions } from "./game-library.js";
+import { openIndexedDbBackend } from "./indexeddb-backend.js";
+import {
+    createKeyValueBackend,
+    type KeyValueStorage,
+    migrateLegacyGame,
+} from "./key-value-backend.js";
+
+/** Les stockages du navigateur ; chacun peut manquer ou être refusé. */
+export interface BrowserStorage {
+    readonly indexedDB?: IDBFactory;
+    readonly localStorage?: KeyValueStorage;
+}
+
+export interface OpenedLibrary {
+    readonly library: GameLibrary;
+    /** Le stockage retenu : IndexedDB, son repli localStorage, ou la seule
+     * mémoire de la page (rien n'est gardé après sa fermeture). */
+    readonly kind: "indexeddb" | "localStorage" | "memory";
+}
+
+/** Au-delà, IndexedDB est tenu pour indisponible (une ouverture bloquée ne
+ * doit pas empêcher de jouer). */
+const OPEN_TIMEOUT_MS = 5000;
+
+export async function openGameLibrary(
+    storage: BrowserStorage,
+    options: LibraryOptions = {},
+): Promise<OpenedLibrary> {
+    const opened = await open(storage, options);
+    if (storage.localStorage !== undefined) {
+        try {
+            await migrateLegacyGame(storage.localStorage, opened.library);
+        } catch {
+            // Migration impossible (stockage plein ou refusé) : l'ancienne
+            // partie reste où elle est, on la retentera au prochain démarrage.
+        }
+    }
+    return opened;
+}
+
+async function open(storage: BrowserStorage, options: LibraryOptions): Promise<OpenedLibrary> {
+    if (storage.indexedDB !== undefined) {
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        try {
+            const backend = await Promise.race([
+                openIndexedDbBackend(storage.indexedDB),
+                new Promise<never>((_, reject) => {
+                    timer = setTimeout(() => reject(new Error("IndexedDB muet")), OPEN_TIMEOUT_MS);
+                }),
+            ]);
+            return { library: createGameLibrary(backend, options), kind: "indexeddb" };
+        } catch {
+            // Indisponible (navigation privée de certains navigateurs) : repli.
+        } finally {
+            clearTimeout(timer);
+        }
+    }
+    if (storage.localStorage !== undefined && usable(storage.localStorage)) {
+        return {
+            library: createGameLibrary(createKeyValueBackend(storage.localStorage), options),
+            kind: "localStorage",
+        };
+    }
+    return {
+        library: createGameLibrary(createKeyValueBackend(memoryStorage()), options),
+        kind: "memory",
+    };
+}
+
+/** localStorage peut exister et refuser toute écriture. */
+function usable(storage: KeyValueStorage): boolean {
+    try {
+        storage.setItem("ustagammon.probe", "1");
+        storage.removeItem("ustagammon.probe");
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/** Un stockage clé-valeur en mémoire. */
+export function memoryStorage(): KeyValueStorage {
+    const items = new Map<string, string>();
+    return {
+        getItem: (key) => items.get(key) ?? null,
+        setItem: (key, value) => void items.set(key, value),
+        removeItem: (key) => void items.delete(key),
+    };
+}

app/src/storage/settings-store.ts

@@ -0,0 +1,83 @@
+// Ce que l'application garde en plus de la partie, dans le même stockage
+// clé-valeur (localStorage) : les réglages du menu, en JSON, et le dernier
+// plateau affiché, pour le redessiner dès l'ouverture de la page, avant que
+// le moteur soit chargé (il est déjà décodé : aucune règle n'est rejouée).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import type { Cube } from "../domain/game/cube.js";
+import type { SideBoards } from "../domain/game/game.js";
+import type { KeyValueStorage } from "./key-value-backend.js";
+
+const SETTINGS_KEY = "ustagammon.settings";
+const BOARD_KEY = "ustagammon.last-board";
+
+/** Le dernier plateau affiché, tel que le moteur l'a décodé. */
+export interface CachedBoard {
+    readonly sides: SideBoards;
+    readonly cube: Cube;
+}
+
+export interface SettingsStore {
+    /** Le texte JSON des réglages (null : jamais enregistrés). */
+    loadSettings(): string | null;
+    saveSettings(json: string): void;
+    loadBoard(): CachedBoard | null;
+    saveBoard(board: CachedBoard): void;
+}
+
+function isSide(value: unknown): boolean {
+    const side = value as Record<string, unknown> | null;
+    return (
+        side !== null &&
+        typeof side === "object" &&
+        Array.isArray(side.points) &&
+        side.points.length === 24 &&
+        side.points.every((n) => Number.isInteger(n) && n >= 0) &&
+        Number.isInteger(side.bar) &&
+        Number.isInteger(side.off) &&
+        Number.isInteger(side.pipCount)
+    );
+}
+
+export function createSettingsStore(
+    storage: Pick<KeyValueStorage, "getItem" | "setItem">,
+): SettingsStore {
+    const write = (key: string, value: string) => {
+        try {
+            storage.setItem(key, value);
+        } catch {
+            // Stockage plein ou interdit : l'application marche sans.
+        }
+    };
+    return {
+        loadSettings() {
+            try {
+                return storage.getItem(SETTINGS_KEY);
+            } catch {
+                return null;
+            }
+        },
+        saveSettings(json) {
+            write(SETTINGS_KEY, json);
+        },
+        loadBoard() {
+            try {
+                const board = JSON.parse(storage.getItem(BOARD_KEY) ?? "null");
+                const valid =
+                    board !== null &&
+                    isSide(board.sides?.player) &&
+                    isSide(board.sides?.computer) &&
+                    Number.isInteger(board.cube?.value) &&
+                    [null, "player", "computer"].includes(board.cube?.owner);
+                return valid ? board : null;
+            } catch {
+                return null;
+            }
+        },
+        saveBoard(board) {
+            write(BOARD_KEY, JSON.stringify(board));
+        },
+    };
+}

app/src/ui/board-model.ts

@@ -155,3 +155,26 @@ export function pointSlot(number: number): { top: boolean; column: number } {
     }
     return { top: true, column: number - 13 };
 }
+
+/** Le plateau de la position de départ, pour le dessiner avant que le
+ * moteur soit chargé (première ouverture) : chaque camp a 2 pions sur sa case
+ * 24, 5 sur la 13, 3 sur la 8 et 5 sur la 6 ; 167 points chacun. Une donnée,
+ * comme dans le dessin de référence de la charte (board.js), pas une règle. */
+export const OPENING_BOARDS: SideBoards = (() => {
+    const points = Array.from({ length: 24 }, (_, i) => ({ 5: 5, 7: 3, 12: 5, 23: 2 })[i] ?? 0);
+    const side = { points, bar: 0, off: 0, pipCount: 167 };
+    return { player: side, computer: side };
+})();
+
+/** Qui mène la course, et de combien : le plus petit compte de points
+ * (leader null : égalité). */
+export function pipLead(pipCount: Readonly<Record<Side, number>>): {
+    leader: Side | null;
+    by: number;
+} {
+    const by = Math.abs(pipCount.player - pipCount.computer);
+    if (by === 0) {
+        return { leader: null, by };
+    }
+    return { leader: pipCount.player < pipCount.computer ? "player" : "computer", by };
+}

app/src/ui/board-view.ts

@@ -7,7 +7,14 @@
 // il n'y a aucun état caché dans le dessin. Les couleurs viennent des
 // variables CSS (app.css), par des classes : aucun style dans le SVG. Chaque
 // endroit qu'on peut toucher est un rectangle transparent, posé par-dessus
-// le reste, qui porte son nom dans data-place.
+// le reste, qui porte son nom dans data-place (une case, la barre, la
+// sortie) ou data-action (dés, videau, commandes).
+//
+// Les mesures viennent de la géométrie (geometry.ts), calculée d'après la
+// forme de l'écran. En paysage, le plateau porte aussi les commandes : la
+// colonne de gauche (menu, videau, annuler ou revoir), les comptes de
+// points en pastilles aux bouts de la barre et la consigne dans la bande
+// centrale.
 
 import type { Cube } from "../domain/game/cube.js";
 import type { Side } from "../domain/game/side.js";
@@ -18,6 +25,8 @@ import {
     pointColor,
     pointSlot,
 } from "./board-model.js";
+import { columnLeft, type Geometry, MAX_STACK, stackY } from "./geometry.js";
+import { ICON_PATHS, type IconName } from "./icons.js";
 import { TEXTS } from "./texts.js";
 
 /** Un dé affiché, de la couleur du camp qui l'a lancé. */
@@ -30,8 +39,17 @@ export interface ShownDie {
     readonly used: boolean;
 }
 
-/** Ce que fait un toucher sur les dés : lancer, ou valider le coup saisi. */
-export type DiceAction = "roll" | "confirm";
+/** Ce que fait un toucher sur les dés : lancer, jouer le coup saisi, ou
+ * passer son tour quand aucun coup n'est possible. */
+export type DiceAction = "roll" | "confirm" | "skip";
+
+/** Les commandes de la colonne de gauche, en paysage. */
+export interface BoardControls {
+    /** En bas : annuler le demi-coup, ou revoir le coup de l'ordinateur. */
+    readonly back: "undo" | "replay";
+    readonly backEnabled: boolean;
+    readonly menuEnabled: boolean;
+}
 
 /** Ce qui s'ajoute aux pions : dés, videau, mises en évidence. */
 export interface BoardDecor {
@@ -44,12 +62,16 @@ 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. */
+    /** Ce que fait un toucher sur la bande centrale, d'un côté ou de
+     * l'autre du plateau (null : rien). En portrait, pour « roll », les dés
+     * du joueur en attente sont dessinés. */
     readonly diceAction: DiceAction | null;
     /** Le joueur peut doubler : le videau se touche. */
     readonly canDouble: boolean;
+    /** Paysage : la consigne courte, dans la bande centrale. */
+    readonly band: string | null;
+    /** Paysage : la colonne de commandes (null : pas de colonne). */
+    readonly controls: BoardControls | null;
 }
 
 /** Ce qui ne s'ajoute pas aux pions pendant l'animation d'un coup. */
@@ -62,30 +84,7 @@ export const NO_MARKS = {
     canDouble: false,
 } as const;
 
-/** Taille minimale d'une cible à toucher, en unités du dessin : au moins
- * 44 px sur un téléphone de 360 px de large, où le plateau en fait 344
- * (640 unités). */
-const MIN_TARGET = 88;
-
-// Géométrie, en unités du viewBox (le SVG s'adapte à la largeur de l'écran).
-const WIDTH = 640;
-const HEIGHT = 520;
-const FRAME = 8;
-const POINT_WIDTH = 44;
-const HALF_WIDTH = 6 * POINT_WIDTH;
-const BAR_LEFT = FRAME + HALF_WIDTH;
-const BAR_WIDTH = 40;
-const RIGHT_HALF = BAR_LEFT + BAR_WIDTH;
-const TRAY_LEFT = RIGHT_HALF + HALF_WIDTH + FRAME;
-const TRAY_WIDTH = 48;
-const POINT_HEIGHT = 190;
-const MIDDLE = HEIGHT / 2;
-const RADIUS = 20;
-const STEP = 42; // d'un pion au suivant dans une pile
-const MAX_STACK = 5; // au-delà, un nombre sur le dernier pion
 const OFF_SLAB = 12; // épaisseur d'un pion sorti
-const DIE = 36;
-const CUBE = 34;
 
 const SVG_NS = "http://www.w3.org/2000/svg";
 
@@ -103,11 +102,6 @@ function add(parent: Element, name: string, attributes: Attributes, text?: strin
     return element;
 }
 
-/** Abscisse du bord gauche d'une colonne (0 à 11). */
-function columnLeft(column: number): number {
-    return column < 6 ? FRAME + column * POINT_WIDTH : RIGHT_HALF + (column - 6) * POINT_WIDTH;
-}
-
 /** Un point du dessin. */
 export interface Spot {
     readonly x: number;
@@ -120,27 +114,24 @@ export interface Spot {
  * joueur dans la moitié haute, où il rentre, l'ordinateur en bas) ; dans la
  * sortie, une tranche de pion vu de profil (l'ordinateur en haut).
  */
-function slotCenter(place: Place, index: number): Spot {
+function slotCenter(g: Geometry, place: Place, index: number): Spot {
+    const middle = g.height / 2;
     if (place === "bar-player" || place === "bar-computer") {
-        const offset = RADIUS + 4 + Math.min(index, MAX_STACK) * STEP;
+        const offset = g.radius + 4 + Math.min(index, g.barStack - 1) * g.step;
         return {
-            x: BAR_LEFT + BAR_WIDTH / 2,
-            y: place === "bar-player" ? MIDDLE - offset : MIDDLE + offset,
+            x: g.barLeft + g.bar / 2,
+            y: place === "bar-player" ? middle - offset : middle + offset,
         };
     }
     if (place === "off-player" || place === "off-computer") {
         const y =
             place === "off-computer"
-                ? FRAME + index * OFF_SLAB
-                : HEIGHT - FRAME - (index + 1) * OFF_SLAB;
-        return { x: TRAY_LEFT + TRAY_WIDTH / 2, y: y + OFF_SLAB / 2 };
+                ? g.edge + index * OFF_SLAB
+                : g.height - g.edge - (index + 1) * OFF_SLAB;
+        return { x: g.trayLeft + g.tray / 2, y: y + OFF_SLAB / 2 };
     }
     const { top, column } = pointSlot(Number(place.slice(1)));
-    const offset = RADIUS + 1 + Math.min(index, MAX_STACK) * STEP;
-    return {
-        x: columnLeft(column) + POINT_WIDTH / 2,
-        y: top ? FRAME + offset : HEIGHT - FRAME - offset,
-    };
+    return { x: columnLeft(g, column) + g.pointWidth / 2, y: stackY(g, top, index) };
 }
 
 /** Le nombre de pions de side à un endroit. */
@@ -155,63 +146,111 @@ function countAt(board: BoardModel, side: Side, place: Place): number {
     return point?.owner === side ? point.count : 0;
 }
 
+/** Le nombre de pions dessinés au plus à un endroit. */
+function stackLimit(g: Geometry, place: Place): number {
+    return place.startsWith("bar-") ? g.barStack : MAX_STACK;
+}
+
 /** Redessine tout le plateau dans svg. */
-export function renderBoard(svg: SVGSVGElement, board: BoardModel, decor: BoardDecor): void {
+export function renderBoard(
+    svg: SVGSVGElement,
+    g: Geometry,
+    board: BoardModel,
+    decor: BoardDecor,
+): void {
     svg.replaceChildren();
-    svg.setAttribute("viewBox", `0 0 ${WIDTH} ${HEIGHT}`);
-    drawFrame(svg);
+    svg.setAttribute("viewBox", `0 0 ${g.width} ${g.height}`);
+    svg.dataset.layout = g.layout;
+    drawFrame(svg, g);
     const hits = add(svg, "g", {});
+    // Les pions, dessinés à part puis posés par-dessus les flèches du coup
+    // de l'ordinateur : une flèche ne cache jamais un pion.
+    const pieces = document.createElementNS(SVG_NS, "g");
+    pieces.setAttribute("class", "pieces");
     for (const point of board.points) {
-        drawPoint(svg, hits, board, point.number, decor);
+        drawPoint(svg, pieces, g, hits, board, point.number, decor);
     }
-    drawBar(svg, hits, board, decor);
-    drawTray(svg, hits, board, decor);
-    drawDice(svg, decor.dice);
-    const cube = drawCube(svg, decor.cube);
+    drawBar(svg, pieces, g, hits, board, decor);
+    drawTray(svg, pieces, g, hits, board, decor);
     if (decor.trace !== null) {
-        drawTrace(svg, board, decor.trace);
+        drawTraceArrows(svg, g, board, decor.trace);
+    }
+    svg.append(pieces);
+    drawLandings(svg, g, board, decor.targets);
+    if (decor.band !== null) {
+        drawBand(svg, g, decor.band);
+    }
+    drawDice(svg, g, decor.dice);
+    const cube = drawCube(svg, g, decor.cube);
+    if (decor.trace !== null) {
+        drawTraceRings(svg, g, board, decor.trace);
     }
     if (decor.diceAction !== null) {
-        if (decor.diceAction === "roll") {
-            waitingDice(svg);
+        if (decor.diceAction === "roll" && g.layout === "portrait") {
+            waitingDice(svg, g);
         }
-        // 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);
+        // Une zone sur chaque moitié de la bande centrale : les dés en
+        // attente (à gauche) comme le dernier jet (à droite) se touchent.
+        const label = TEXTS.diceActions[decor.diceAction];
+        const width = 6 * g.pointWidth - 2 * g.frame;
+        for (const x of [g.x0 + 3 * g.pointWidth, g.rightHalf + 3 * g.pointWidth]) {
+            addAction(g, hits, decor.diceAction, label, { x, y: g.height / 2 }, width);
         }
     }
     if (decor.canDouble) {
         cube.classList.add("can-double");
-        addAction(hits, "double", TEXTS.double, cubeCenter(decor.cube), MIN_TARGET);
+        addAction(g, hits, "double", TEXTS.double, cubeCenter(g, decor.cube), g.target);
+    }
+    if (decor.controls !== null) {
+        drawControls(svg, g, hits, decor.controls);
     }
     // Les zones à toucher passent devant tout le reste.
     svg.append(hits);
 }
 
-function drawFrame(svg: SVGSVGElement): void {
-    add(svg, "rect", { class: "board-frame", x: 0, y: 0, width: WIDTH, height: HEIGHT, rx: 6 });
-    for (const left of [FRAME, RIGHT_HALF]) {
+function drawFrame(svg: SVGSVGElement, g: Geometry): void {
+    const landscape = g.layout === "landscape";
+    add(svg, "rect", {
+        class: "board-frame",
+        x: 0,
+        y: 0,
+        width: g.width,
+        height: g.height,
+        rx: landscape ? 0 : 6,
+    });
+    for (const left of [g.x0, g.rightHalf]) {
         add(svg, "rect", {
             class: "board-bed",
             x: left,
-            y: FRAME,
-            width: HALF_WIDTH,
-            height: HEIGHT - 2 * FRAME,
+            y: g.edge,
+            width: 6 * g.pointWidth,
+            height: g.height - 2 * g.edge,
         });
     }
     add(svg, "rect", {
         class: "board-tray",
-        x: TRAY_LEFT,
-        y: FRAME,
-        width: TRAY_WIDTH,
-        height: HEIGHT - 2 * FRAME,
+        x: g.trayLeft,
+        y: g.edge,
+        width: g.tray,
+        height: g.height - 2 * g.edge,
+        rx: landscape ? 4 : 0,
     });
+    if (g.left > 0) {
+        add(svg, "rect", {
+            class: "board-tray",
+            x: g.frame,
+            y: g.edge,
+            width: g.left - 4,
+            height: g.height - 2 * g.edge,
+            rx: 4,
+        });
+    }
 }
 
 function drawPoint(
     svg: SVGSVGElement,
+    pieces: Element,
+    g: Geometry,
     hits: Element,
     board: BoardModel,
     number: number,
@@ -222,38 +261,54 @@ function drawPoint(
         return;
     }
     const { top, column } = pointSlot(number);
-    const left = columnLeft(column);
-    const center = left + POINT_WIDTH / 2;
-    const base = top ? FRAME : HEIGHT - FRAME;
-    const tip = top ? FRAME + POINT_HEIGHT : HEIGHT - FRAME - POINT_HEIGHT;
+    const left = columnLeft(g, column);
+    const center = left + g.pointWidth / 2;
+    const middle = g.height / 2;
+    const base = top ? g.edge : g.height - g.edge;
+    const length = middle - g.edge - g.band / 2 + 6;
+    const tip = top ? base + length : base - length;
     add(svg, "polygon", {
         class: pointColor(number),
-        points: `${left},${base} ${left + POINT_WIDTH},${base} ${center},${tip}`,
+        "data-point": number,
+        points: `${left},${base} ${left + g.pointWidth},${base} ${center},${tip}`,
     });
+    // Numéros : sur le cadre en paysage, dans la bande centrale en
+    // portrait. Leur taille (12 px au moins à l'écran) dépend de l'échelle
+    // du dessin : c'est une mesure du dessin, comme x et y.
+    const size = g.numberSize;
+    let y: number;
+    if (g.layout === "landscape") {
+        y = top ? g.edge / 2 + size * 0.36 : g.height - g.edge / 2 + size * 0.36;
+    } else {
+        y = top ? middle - g.die / 2 - 4 : middle + g.die / 2 + 4 + size * 0.72;
+    }
     add(
         svg,
         "text",
-        { class: "point-number", x: center, y: top ? MIDDLE - 26 : MIDDLE + 34 },
+        {
+            class: g.layout === "landscape" ? "point-number on-frame" : "point-number",
+            x: center,
+            y,
+            "font-size": size,
+        },
         String(number),
     );
+    // Case d'arrivée possible : la flèche seule est voilée (son triangle) ;
+    // l'endroit où le pion se posera est marqué plus loin (drawLandings).
     if (decor.targets.has(point.place)) {
-        add(svg, "rect", {
+        add(svg, "polygon", {
             class: "target-zone",
-            x: left + 2,
-            y: top ? FRAME : MIDDLE,
-            width: POINT_WIDTH - 4,
-            height: HEIGHT / 2 - FRAME,
-            rx: 4,
+            points: `${left},${base} ${left + g.pointWidth},${base} ${center},${tip}`,
         });
     }
     if (point.owner !== null) {
-        drawStack(svg, point.owner, point.count, point.place, decor);
+        drawStack(pieces, g, point.owner, point.count, point.place, decor);
     }
     addHit(hits, point.place, decor, {
         x: left,
-        y: top ? 0 : MIDDLE,
-        width: POINT_WIDTH,
-        height: MIDDLE,
+        y: top ? 0 : middle,
+        width: g.pointWidth,
+        height: middle,
     });
 }
 
@@ -261,13 +316,15 @@ function drawPoint(
  * pour les montrer tous. Le pion du dessus porte son endroit dans
  * data-checker : c'est lui qu'on fait glisser quand un pion arrive. */
 function drawStack(
-    svg: SVGSVGElement,
+    svg: Element,
+    g: Geometry,
     side: Side,
     count: number,
     place: Place,
     decor: BoardDecor,
 ): void {
-    const shown = Math.min(count, MAX_STACK);
+    const limit = stackLimit(g, place);
+    const shown = Math.min(count, limit);
     for (let i = 0; i < shown; i++) {
         const last = i === shown - 1;
         const classes = [`checker checker-${side}`];
@@ -276,119 +333,289 @@ function drawStack(
         } else if (last && decor.movable.has(place)) {
             classes.push("movable");
         }
-        const { x, y } = slotCenter(place, i);
-        const checker = add(svg, "circle", { class: classes.join(" "), cx: x, cy: y, r: RADIUS });
+        const { x, y } = slotCenter(g, place, i);
+        const checker = add(svg, "circle", {
+            class: classes.join(" "),
+            cx: x,
+            cy: y,
+            r: g.radius,
+        });
         if (last) {
             checker.setAttribute("data-checker", place);
         }
-        if (last && count > MAX_STACK) {
-            add(svg, "text", { class: `checker-count count-${side}`, x, y: y + 6 }, String(count));
+        if (last && count > limit) {
+            add(
+                svg,
+                "text",
+                {
+                    class: `checker-count count-${side}`,
+                    x,
+                    y: y + g.countFont * 0.35,
+                    "font-size": g.countFont,
+                },
+                String(count),
+            );
         }
     }
 }
 
-function drawBar(svg: SVGSVGElement, hits: Element, board: BoardModel, decor: BoardDecor): void {
-    add(svg, "rect", {
-        class: "board-bar",
-        x: BAR_LEFT,
-        y: 0,
-        width: BAR_WIDTH,
-        height: HEIGHT,
-    });
+function drawBar(
+    svg: SVGSVGElement,
+    pieces: Element,
+    g: Geometry,
+    hits: Element,
+    board: BoardModel,
+    decor: BoardDecor,
+): void {
+    add(svg, "rect", { class: "board-bar", x: g.barLeft, y: 0, width: g.bar, height: g.height });
     // Les pions du joueur sur la barre entrent en haut à droite : on les met
     // dans la moitié haute, en partant du milieu ; ceux de l'ordinateur en bas.
     for (const side of ["player", "computer"] as const) {
-        drawStack(svg, side, board.bar[side], `bar-${side}`, decor);
+        drawStack(pieces, g, side, board.bar[side], `bar-${side}`, decor);
     }
-    addHit(hits, "bar-player", decor, { x: BAR_LEFT, y: 0, width: BAR_WIDTH, height: MIDDLE });
+    if (g.layout === "landscape") {
+        drawChips(svg, g, board);
+    }
+    addHit(hits, "bar-player", decor, {
+        x: g.barLeft,
+        y: 0,
+        width: g.bar,
+        height: g.height / 2,
+    });
 }
 
-function drawTray(svg: SVGSVGElement, hits: Element, board: BoardModel, decor: BoardDecor): void {
+/** Paysage : les comptes de points en pastilles aux deux bouts de la barre,
+ * aux couleurs du camp (l'ordinateur en haut, vous en bas). */
+function drawChips(svg: SVGSVGElement, g: Geometry, board: BoardModel): void {
+    const width = g.bar - 6;
+    const h = g.chipHeight;
+    for (const side of ["computer", "player"] as const) {
+        const y = side === "computer" ? g.edge + 4 : g.height - g.edge - 4 - h;
+        add(svg, "rect", {
+            class: `pip-chip chip-${side}`,
+            x: g.barLeft + 3,
+            y,
+            width,
+            height: h,
+            rx: h / 2,
+        });
+        add(
+            svg,
+            "text",
+            {
+                class: `pip-chip-text chip-text-${side}`,
+                "data-pips": side,
+                x: g.barLeft + g.bar / 2,
+                y: y + h / 2 + g.chipFont * 0.35,
+                "font-size": g.chipFont,
+            },
+            String(board.pipCount[side]),
+        );
+    }
+}
+
+function drawTray(
+    svg: SVGSVGElement,
+    pieces: Element,
+    g: Geometry,
+    hits: Element,
+    board: BoardModel,
+    decor: BoardDecor,
+): void {
     // Pions sortis, vus de profil : l'ordinateur en haut, le joueur en bas.
     for (const side of ["player", "computer"] as const) {
         const count = board.off[side];
         for (let i = 0; i < count; i++) {
-            const slab = addSlab(svg, `checker checker-${side}`, slotCenter(`off-${side}`, i));
+            const slab = addSlab(
+                pieces,
+                g,
+                `checker checker-${side}`,
+                slotCenter(g, `off-${side}`, i),
+            );
             if (i === count - 1) {
                 slab.setAttribute("data-checker", `off-${side}`);
             }
         }
     }
+    const middle = g.height / 2;
     if (decor.targets.has("off-player")) {
         add(svg, "rect", {
             class: "target-zone",
-            x: TRAY_LEFT + 2,
-            y: MIDDLE,
-            width: TRAY_WIDTH - 4,
-            height: MIDDLE - FRAME,
+            x: g.trayLeft + 2,
+            y: middle,
+            width: g.tray - 4,
+            height: middle - g.edge,
             rx: 4,
         });
     }
     addHit(hits, "off-player", decor, {
-        x: TRAY_LEFT,
-        y: MIDDLE,
-        width: TRAY_WIDTH,
-        height: MIDDLE,
+        x: g.trayLeft,
+        y: middle,
+        width: g.width - g.trayLeft,
+        height: middle,
     });
 }
 
 /** Une tranche de pion sorti, centrée en spot. */
-function addSlab(svg: Element, cssClass: string, spot: Spot): SVGElement {
+function addSlab(svg: Element, g: Geometry, cssClass: string, spot: Spot): SVGElement {
     return add(svg, "rect", {
         class: cssClass,
-        x: TRAY_LEFT + 4,
+        x: g.trayLeft + 4,
         y: spot.y - OFF_SLAB / 2 + 1,
-        width: TRAY_WIDTH - 8,
+        width: g.tray - 8,
         height: OFF_SLAB - 2,
         rx: 3,
     });
 }
 
 /** Un cercle de rayon r autour d'un pion (un cadre pour un pion sorti). */
-function addRing(svg: Element, cssClass: string, place: Place, spot: Spot, r: number): void {
+function addRing(
+    svg: Element,
+    g: Geometry,
+    cssClass: string,
+    place: Place,
+    spot: Spot,
+    r: number,
+): void {
     if (place.startsWith("off-")) {
-        addSlab(svg, cssClass, spot);
+        addSlab(svg, g, cssClass, spot);
     } else {
         add(svg, "circle", { class: cssClass, cx: spot.x, cy: spot.y, r });
     }
 }
 
+/** Paysage : la consigne courte, dans la moitié gauche de la bande
+ * centrale, sur une pastille accent-soft. */
+function drawBand(svg: SVGSVGElement, g: Geometry, text: string): void {
+    const middle = g.height / 2;
+    const width = 6 * g.pointWidth - 24;
+    const height = Math.max(44, g.bandFont + 20);
+    const x = g.x0 + 12;
+    add(svg, "rect", {
+        class: "band-pill",
+        x,
+        y: middle - height / 2,
+        width,
+        height,
+        rx: height / 2,
+    });
+    add(
+        svg,
+        "text",
+        {
+            class: "band-text",
+            id: "band-text",
+            x: x + width / 2,
+            y: middle + g.bandFont * 0.35,
+            "font-size": g.bandFont,
+        },
+        text,
+    );
+}
+
+/** Paysage : la colonne de commandes à gauche, dans le cadre. */
+function drawControls(
+    svg: SVGSVGElement,
+    g: Geometry,
+    hits: Element,
+    controls: BoardControls,
+): void {
+    const x = g.frame + (g.left - 4) / 2;
+    const r = (g.left - 4) / 2 - 6;
+    const top = g.edge + g.target / 2 + 2;
+    const bottom = g.height - g.edge - g.target / 2 - 2;
+    const control = (name: IconName, action: string, label: string, y: number, on: boolean) => {
+        const group = add(svg, "g", { class: on ? "control" : "control disabled" });
+        add(group, "circle", { class: "control-circle", cx: x, cy: y, r });
+        const size = r * 1.1;
+        const scale = size / 24;
+        const icon = add(group, "g", {
+            transform: `translate(${x - size / 2},${y - size / 2}) scale(${scale})`,
+        });
+        add(icon, "path", { class: "control-icon", d: ICON_PATHS[name] });
+        if (!on) {
+            return;
+        }
+        if (action === "menu") {
+            // Le menu a son adresse (ADR 0013) : un vrai lien, comme dans
+            // la barre haute du portrait.
+            const link = add(hits, "a", {
+                href: "#/menu",
+                "data-action": action,
+                role: "link",
+                "aria-label": label,
+            });
+            add(link, "rect", {
+                class: "hit action",
+                x: Math.max(0, x - g.target / 2),
+                y: Math.max(0, y - g.target / 2),
+                width: g.target,
+                height: g.target,
+            });
+        } else {
+            addAction(g, hits, action, label, { x, y }, g.target);
+        }
+    };
+    control("menu", "menu", TEXTS.menu, top, controls.menuEnabled);
+    if (controls.back === "replay") {
+        control("replay", "replay", TEXTS.replayTitle, bottom, controls.backEnabled);
+    } else {
+        control("undo", "undo", TEXTS.undoTitle, bottom, controls.backEnabled);
+    }
+}
+
 // ------------------------------------------------------ Coup de l'ordinateur
 
 /**
- * Les traces d'un coup : un pion fantôme (contour seul) là où chaque pion
+ * Les traces d'un coup (sauf ses flèches, dessinées sous les pions) : un pion fantôme (contour seul) là où chaque pion
  * est parti, un cercle autour de chaque pion arrivé et de chaque pion frappé
  * (sur la barre), et une flèche par demi-coup.
  */
-function drawTrace(svg: SVGSVGElement, board: BoardModel, trace: MoveTrace): void {
+function drawTraceRings(
+    svg: SVGSVGElement,
+    g: Geometry,
+    board: BoardModel,
+    trace: MoveTrace,
+): void {
     const side = trace.side;
+    const R = g.radius;
     for (const [place, n] of trace.left) {
         // Au-dessus des pions restés sur la case.
         const remaining = countAt(board, side, place);
         for (let k = 0; k < n; k++) {
-            addRing(svg, "trace-ghost", place, slotCenter(place, remaining + k), RADIUS - 1);
+            addRing(svg, g, "trace-ghost", place, slotCenter(g, place, remaining + k), R - 1);
         }
     }
     for (const [place, n] of trace.landed) {
-        const top = topIndex(board, side, place);
+        const top = topIndex(g, board, side, place);
         for (let k = 0; k < n && top - k >= 0; k++) {
-            addRing(svg, "trace-landed", place, slotCenter(place, top - k), RADIUS + 3);
+            addRing(svg, g, "trace-landed", place, slotCenter(g, place, top - k), R + 3);
         }
     }
     const opponent: Side = side === "player" ? "computer" : "player";
     const bar: Place = `bar-${opponent}`;
-    const top = topIndex(board, opponent, bar);
+    const top = topIndex(g, board, opponent, bar);
     for (let k = 0; k < trace.hits && top - k >= 0; k++) {
-        addRing(svg, "trace-hit", bar, slotCenter(bar, top - k), RADIUS + 3);
+        addRing(svg, g, "trace-hit", bar, slotCenter(g, bar, top - k), R + 3);
     }
+}
+
+/** Les flèches d'un coup, une par demi-coup : sous les pions. */
+function drawTraceArrows(
+    svg: SVGSVGElement,
+    g: Geometry,
+    board: BoardModel,
+    trace: MoveTrace,
+): void {
+    const side = trace.side;
     const defs = add(svg, "defs", {});
     const marker = add(defs, "marker", {
         id: "trace-head",
         viewBox: "0 0 10 10",
         refX: 8,
         refY: 5,
-        markerWidth: 3.5,
-        markerHeight: 3.5,
+        markerWidth: 3,
+        markerHeight: 3,
         orient: "auto",
     });
     add(marker, "path", { class: "trace-head", d: "M0,0 L10,5 L0,10 z" });
@@ -398,20 +625,35 @@ function drawTrace(svg: SVGSVGElement, board: BoardModel, trace: MoveTrace): voi
         // d'arrivée.
         const k = departures.get(from) ?? 0;
         departures.set(from, k + 1);
-        const start = slotCenter(from, countAt(board, side, from) + k);
-        const end = slotCenter(to, Math.max(topIndex(board, side, to), 0));
-        drawArrow(svg, start, end, to.startsWith("off-") ? OFF_SLAB : RADIUS + 4);
+        const start = slotCenter(g, from, countAt(board, side, from) + k);
+        const end = slotCenter(g, to, Math.max(topIndex(g, board, side, to), 0));
+        drawArrow(svg, g, start, end, to.startsWith("off-") ? OFF_SLAB : g.radius + 4);
+    }
+}
+
+/** Les cases d'arrivée du pion touché : un anneau pointillé là où il se
+ * posera (sur la pile du joueur, ou au pied de la flèche). */
+function drawLandings(
+    svg: SVGSVGElement,
+    g: Geometry,
+    board: BoardModel,
+    targets: ReadonlySet<Place>,
+): void {
+    for (const place of targets) {
+        const count = countAt(board, "player", place);
+        const index = place.startsWith("off-") ? count : Math.min(count, MAX_STACK - 1);
+        addRing(svg, g, "landing", place, slotCenter(g, place, index), g.radius);
     }
 }
 
 /** L'indice du pion du dessus dessiné à un endroit (-1 s'il n'y en a pas). */
-function topIndex(board: BoardModel, side: Side, place: Place): number {
+function topIndex(g: Geometry, board: BoardModel, side: Side, place: Place): number {
     const count = countAt(board, side, place);
-    return place.startsWith("off-") ? count - 1 : Math.min(count, MAX_STACK) - 1;
+    return place.startsWith("off-") ? count - 1 : Math.min(count, stackLimit(g, place)) - 1;
 }
 
 /** Une flèche de start vers end, arrêtée à gap du centre d'arrivée. */
-function drawArrow(svg: SVGSVGElement, start: Spot, end: Spot, gap: number): void {
+function drawArrow(svg: SVGSVGElement, g: Geometry, start: Spot, end: Spot, gap: number): void {
     const dx = end.x - start.x;
     const dy = end.y - start.y;
     const length = Math.hypot(dx, dy);
@@ -422,6 +664,7 @@ function drawArrow(svg: SVGSVGElement, start: Spot, end: Spot, gap: number): voi
         y1: start.y,
         x2: start.x + dx * keep,
         y2: start.y + dy * keep,
+        "stroke-width": g.arrowWidth,
         "marker-end": "url(#trace-head)",
     });
 }
@@ -440,6 +683,9 @@ export function checkerSpot(svg: SVGSVGElement, place: Place): Spot | null {
     return { x: number("x") + number("width") / 2, y: number("y") + number("height") / 2 };
 }
 
+/** Courbe de tout ce qui se déplace (interaction.md, easing-standard). */
+export const EASING_STANDARD = "cubic-bezier(0.2, 0, 0, 1)";
+
 /**
  * Fait glisser le pion du dessus de place depuis from jusqu'à sa position
  * dessinée, en ms millisecondes (animation du navigateur, sans bibliothèque).
@@ -464,7 +710,7 @@ export async function slideChecker(
             { transform: `translate(${from.x - to.x}px, ${from.y - to.y}px)` },
             { transform: "translate(0px, 0px)" },
         ],
-        { duration: ms, easing: "ease-in-out" },
+        { duration: ms, easing: EASING_STANDARD },
     );
     await animation.finished.catch(() => undefined);
 }
@@ -505,70 +751,90 @@ const PIPS: Record<number, [number, number][]> = {
 };
 
 /** Les dés, au milieu de la moitié droite. */
-function drawDice(svg: SVGSVGElement, dice: readonly ShownDie[]): void {
-    const center = RIGHT_HALF + HALF_WIDTH / 2;
+function drawDice(svg: SVGSVGElement, g: Geometry, dice: readonly ShownDie[]): void {
+    const center = g.rightHalf + 3 * g.pointWidth;
+    const size = g.die;
     const gap = 8;
-    const total = dice.length * DIE + (dice.length - 1) * gap;
+    const total = dice.length * size + (dice.length - 1) * gap;
     dice.forEach((die, i) => {
-        const x = center - total / 2 + i * (DIE + gap);
-        const y = MIDDLE - DIE / 2;
+        const x = center - total / 2 + i * (size + gap);
+        const y = g.height / 2 - size / 2;
         const group = add(svg, "g", {
             class: ["die", die.blocked ? "die-blocked" : "", die.used ? "die-used" : ""]
                 .filter(Boolean)
                 .join(" "),
             "data-value": die.value,
         });
-        add(group, "rect", { class: `die-${die.side}`, x, y, width: DIE, height: DIE, rx: 6 });
+        add(group, "rect", { class: `die-${die.side}`, x, y, width: size, height: size, rx: 6 });
         for (const [px, py] of PIPS[die.value] ?? []) {
             add(group, "circle", {
                 class: `pip-${die.side}`,
-                cx: x + px * DIE,
-                cy: y + py * DIE,
-                r: 3.5,
+                cx: x + px * size,
+                cy: y + py * size,
+                r: size / 10,
             });
         }
         if (die.blocked) {
-            add(group, "line", { class: "die-strike", x1: x, y1: y + DIE, x2: x + DIE, y2: y });
+            add(group, "line", { class: "die-strike", x1: x, y1: y + size, x2: x + size, y2: y });
         }
     });
 }
 
-/** Le videau, dans le plateau de sortie : au milieu s'il est au centre,
- * sinon du côté de son propriétaire. Au centre, il montre 64. */
-function drawCube(svg: SVGSVGElement, cube: Cube): SVGElement {
-    const center = cubeCenter(cube);
-    const x = center.x - CUBE / 2;
-    const y = center.y - CUBE / 2;
+/** Le videau : dans la colonne des sorties en portrait, dans la colonne de
+ * commandes en paysage ; au milieu s'il est au centre (il montre alors 64),
+ * sinon du côté de son propriétaire. */
+function drawCube(svg: SVGSVGElement, g: Geometry, cube: Cube): SVGElement {
+    const center = cubeCenter(g, cube);
+    const size = g.cube;
+    const x = center.x - size / 2;
+    const y = center.y - size / 2;
     const group = add(svg, "g", { class: "cube", "data-owner": cube.owner ?? "center" });
-    add(group, "rect", { class: "cube-face", x, y, width: CUBE, height: CUBE, rx: 4 });
+    add(group, "rect", { class: "cube-face", x, y, width: size, height: size, rx: 4 });
     add(
         group,
         "text",
-        { class: "cube-value", x: center.x, y: center.y + 6 },
+        {
+            class: "cube-value",
+            x: center.x,
+            y: center.y + g.cubeFont * 0.35,
+            "font-size": g.cubeFont,
+        },
         String(cube.owner === null ? 64 : cube.value),
     );
     return group;
 }
 
-/** Le centre du videau dans le plateau de sortie. */
-function cubeCenter(cube: Cube): Spot {
+/** Le centre du videau. */
+function cubeCenter(g: Geometry, cube: Cube): Spot {
+    const middle = g.height / 2;
+    if (g.layout === "landscape") {
+        const shift = g.target + 6;
+        const y =
+            cube.owner === "computer"
+                ? middle - shift
+                : cube.owner === "player"
+                  ? middle + shift
+                  : middle;
+        return { x: g.frame + (g.left - 4) / 2, y };
+    }
     const shift = cube.owner === "computer" ? -48 : cube.owner === "player" ? 48 : 0;
-    return { x: TRAY_LEFT + TRAY_WIDTH / 2, y: MIDDLE + shift };
+    return { x: g.trayLeft + g.tray / 2, y: middle + shift };
 }
 
-/** 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 {
-    const center = { x: FRAME + HALF_WIDTH / 2, y: MIDDLE };
+/** Portrait : 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, g: Geometry): void {
+    const center = g.x0 + 3 * g.pointWidth;
     const gap = 8;
     const group = add(svg, "g", { class: "die die-waiting" });
-    for (const x of [center.x - gap / 2 - DIE, center.x + gap / 2]) {
+    for (const x of [center - gap / 2 - g.die, center + gap / 2]) {
         add(group, "rect", {
             class: "die-player",
             x,
-            y: MIDDLE - DIE / 2,
-            width: DIE,
-            height: DIE,
+            y: g.height / 2 - g.die / 2,
+            width: g.die,
+            height: g.die,
             rx: 6,
         });
     }
@@ -576,27 +842,28 @@ function waitingDice(svg: SVGSVGElement): void {
 
 /**
  * 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.
+ * jouer le coup, doubler, menu…) : au moins g.target de côté (44 px à
+ * l'écran), centrée sur ce qu'on touche, avec un rôle et un nom accessibles.
  */
 function addAction(
+    g: Geometry,
     hits: Element,
     action: string,
     label: string,
     center: Spot,
     width: number,
 ): void {
+    const w = Math.max(width, g.target);
     add(hits, "rect", {
         class: "hit action",
         "data-action": action,
         role: "button",
         "aria-label": label,
-        // Sans déborder du dessin à droite (le videau est contre le bord).
-        x: Math.min(center.x - width / 2, WIDTH - width),
-        y: center.y - MIN_TARGET / 2,
-        width,
-        height: MIN_TARGET,
+        // Sans déborder du dessin (le videau est contre le bord).
+        x: Math.max(0, Math.min(center.x - w / 2, g.width - w)),
+        y: center.y - g.target / 2,
+        width: w,
+        height: g.target,
     });
 }
 

app/src/ui/games-texts.ts

@@ -0,0 +1,66 @@
+// Les textes de « Mes parties » (ADR 0007, point 5), à part de texts.ts le
+// temps que l'écran rejoigne le menu de l'application.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import type { ResultKind } from "../domain/game/engine.js";
+import type { Side } from "../domain/game/side.js";
+
+const RESULT_KIND: Record<ResultKind, string> = {
+    single: "partie simple",
+    gammon: "gammon",
+    backgammon: "backgammon",
+};
+
+function moves(n: number): string {
+    return n > 1 ? `${n} coups` : `${n} coup`;
+}
+
+function points(n: number): string {
+    return n > 1 ? `${n} points` : `${n} point`;
+}
+
+export const GAMES_TEXTS = {
+    button: "Mes parties",
+    title: "Mes parties",
+    empty: "Aucune partie enregistrée.",
+    close: "Fermer",
+    resume: "Reprendre",
+    showBranches: "Branches",
+    resumeBranch: "Reprendre cette branche",
+    exportSgf: "Exporter (SGF)",
+    remove: "Supprimer",
+    confirmRemove: "Supprimer pour de bon (branches comprises)",
+    shown: "partie affichée",
+    busy: "Attendez la fin du coup en cours.",
+    failed: (message: string) => `Erreur : ${message}`,
+
+    /** « 3 nov. 2026, 14:05 ». */
+    date: (ms: number) =>
+        new Date(ms).toLocaleString("fr-FR", { dateStyle: "medium", timeStyle: "short" }),
+
+    status: (
+        result: { winner: Side; kind: ResultKind; points: number } | null,
+        moveCount: number,
+    ) => {
+        if (result === null) {
+            return `En cours, ${moves(moveCount)}`;
+        }
+        const who = result.winner === "player" ? "Gagnée" : "Perdue";
+        return `${who} (${RESULT_KIND[result.kind]}, ${points(result.points)}), ${moves(moveCount)}`;
+    },
+    branchCount: (n: number) => (n > 1 ? `${n} branches` : ""),
+
+    /** Une branche : d'où elle part et où elle en est. */
+    branch: (forkMoveCount: number | null, moveCount: number, over: boolean) => {
+        const start =
+            forkMoveCount === null
+                ? "Partie d'origine"
+                : forkMoveCount === 0
+                  ? "Rejouée depuis le début"
+                  : `Rejouée après le coup ${forkMoveCount}`;
+        return `${start} : ${moves(moveCount)}${over ? ", finie" : ""}`;
+    },
+    currentBranch: " (branche courante)",
+};

app/src/ui/games-view.ts

@@ -0,0 +1,278 @@
+// « Mes parties » : la liste des parties enregistrées, pour en reprendre une
+// (ou l'une de ses branches), l'exporter en SGF ou la supprimer.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Une feuille qui monte du bas, comme le menu, créée ici même : elle ne
+// dépend pas de index.html. Comme tout l'écran, elle ne connaît ni le
+// stockage ni le moteur : l'écran de jeu (app.ts) lui passe les opérations
+// (GamesViewOptions), et change lui-même de partie quand on en reprend une.
+//
+// La feuille a son adresse (#/parties), et chaque partie la sienne
+// (#/parties/<id>, ses branches dépliées) : l'écran de jeu l'ouvre et la
+// ferme selon l'adresse (show, hide), et « Branches » est un vrai lien.
+
+import { branches } from "../domain/game/branches.js";
+import type { GameJournal } from "../domain/game/events.js";
+import type { SavedGameSummary } from "../domain/game/saved-game.js";
+import { GAMES_TEXTS } from "./games-texts.js";
+import { icon } from "./icons.js";
+import { routeHash } from "./router.js";
+
+export interface GamesViewOptions {
+    /** Les parties, la dernière jouée d'abord. */
+    readonly list: () => Promise<SavedGameSummary[]>;
+    /** Le journal d'une partie (null si elle a disparu). */
+    readonly journal: (id: string) => Promise<GameJournal | null>;
+    /** L'identifiant de la partie affichée à l'écran. */
+    readonly shownId: () => string | null;
+    /** Reprend une partie, au bout de la branche branchHead si elle est
+     * donnée (sinon là où elle en était), et quitte la feuille. */
+    readonly resume: (id: string, branchHead?: string) => Promise<void>;
+    readonly remove: (id: string) => Promise<void>;
+    /** Le fichier SGF d'une partie : son nom et son contenu. */
+    readonly exportSgf: (id: string) => Promise<{ fileName: string; text: string }>;
+    /** La croix ou le voile touché : quitter la feuille (l'écran de jeu
+     * change d'adresse, puis appelle hide). */
+    readonly onClose: () => void;
+}
+
+export interface GamesView {
+    /** Ouvre la feuille (la liste, à jour, si elle était fermée), avec les
+     * branches de la partie expanded dépliées. */
+    show(expanded: string | null): Promise<void>;
+    hide(): void;
+    readonly isOpen: boolean;
+}
+
+/** Crée la feuille « Mes parties » (fermée) dans la page. */
+export function createGamesView(options: GamesViewOptions): GamesView {
+    const veil = element("div", "veil sheet-veil");
+    veil.id = "games-veil";
+    veil.hidden = true;
+    const sheet = element("div", "sheet games");
+    sheet.id = "games";
+    sheet.setAttribute("role", "dialog");
+    sheet.setAttribute("aria-modal", "true");
+    sheet.setAttribute("aria-labelledby", "games-title");
+    const head = element("div", "sheet-head");
+    const title = element("h2", "sheet-title");
+    title.id = "games-title";
+    title.textContent = GAMES_TEXTS.title;
+    const close = button("", () => options.onClose(), "icon-button");
+    close.id = "games-close";
+    close.setAttribute("aria-label", GAMES_TEXTS.close);
+    close.append(icon("close"));
+    head.append(title, close);
+    const list = element("ul", "games-list");
+    const message = element("p", "games-message");
+    message.setAttribute("aria-live", "polite");
+    sheet.append(head, message, list);
+    veil.append(sheet);
+    document.body.append(veil);
+    veil.addEventListener("click", (event) => {
+        if (event.target === veil) {
+            options.onClose();
+        }
+    });
+
+    // La partie dont les branches sont dépliées (adresse #/parties/<id>).
+    let expanded: string | null = null;
+
+    /** Lance une action ; une erreur s'affiche dans la fenêtre. */
+    const run = (action: () => Promise<void>) => async () => {
+        message.textContent = "";
+        try {
+            await action();
+        } catch (error) {
+            message.textContent = GAMES_TEXTS.failed(
+                error instanceof Error ? error.message : String(error),
+            );
+        }
+    };
+
+    async function render(): Promise<void> {
+        const games = await options.list();
+        list.replaceChildren(...games.map((game) => gameItem(game, game.id === options.shownId())));
+        if (games.length === 0) {
+            message.textContent = GAMES_TEXTS.empty;
+        }
+    }
+
+    function gameItem(game: SavedGameSummary, shown: boolean): HTMLElement {
+        const item = element("li", "games-item");
+        item.dataset.id = game.id;
+        const heading = element("p");
+        heading.textContent = [
+            GAMES_TEXTS.date(game.startedAt),
+            GAMES_TEXTS.status(game.result, game.moveCount),
+            GAMES_TEXTS.branchCount(game.branchCount),
+            shown ? GAMES_TEXTS.shown : "",
+        ]
+            .filter((part) => part !== "")
+            .join(" · ");
+        const branchList = element("ul", "games-branches");
+        branchList.hidden = true;
+        const actions = element("div", "games-actions");
+        actions.append(
+            button(
+                GAMES_TEXTS.resume,
+                run(() => options.resume(game.id)),
+                "",
+                "resume",
+            ),
+            branchesLink(game.id),
+            button(
+                GAMES_TEXTS.exportSgf,
+                run(async () => download(await options.exportSgf(game.id))),
+                "secondary",
+                "export",
+            ),
+            // Supprimer se fait en deux touchers, sans boîte du navigateur :
+            // le premier change le bouton en demande de confirmation.
+            button(
+                GAMES_TEXTS.remove,
+                run(async () => {
+                    const remove = item.querySelector<HTMLElement>('[data-action="remove"]');
+                    if (remove?.dataset.armed !== "true") {
+                        if (remove !== null) {
+                            remove.dataset.armed = "true";
+                            remove.textContent = GAMES_TEXTS.confirmRemove;
+                        }
+                        return;
+                    }
+                    await options.remove(game.id);
+                    await render();
+                    await expand();
+                }),
+                "secondary",
+                "remove",
+            ),
+        );
+        // La partie à l'écran ne se supprime pas : elle continue d'être
+        // enregistrée.
+        const remove = actions.querySelector<HTMLElement>('[data-action="remove"]');
+        if (remove !== null) {
+            remove.hidden = shown;
+        }
+        item.append(heading, actions, branchList);
+        return item;
+    }
+
+    /** « Branches » : le lien qui déplie les branches d'une partie (ou les
+     * replie, quand elles le sont déjà). */
+    function branchesLink(id: string): HTMLAnchorElement {
+        const link = element("a", "button secondary");
+        link.textContent = GAMES_TEXTS.showBranches;
+        link.dataset.action = "branches";
+        link.href = routeHash({ screen: "games", game: id });
+        link.setAttribute("aria-expanded", "false");
+        return link;
+    }
+
+    async function renderBranches(id: string, target: HTMLElement): Promise<void> {
+        const journal = await options.journal(id);
+        const all = journal === null ? [] : branches(journal);
+        target.replaceChildren(
+            ...all.map((branch) => {
+                const item = element("li", "games-branch");
+                item.dataset.head = branch.head;
+                const text = element("span");
+                text.textContent =
+                    GAMES_TEXTS.branch(
+                        branch.forkedFrom === null ? null : branch.forkMoveCount,
+                        branch.moveCount,
+                        branch.over,
+                    ) + (branch.containsHead ? GAMES_TEXTS.currentBranch : "");
+                item.append(
+                    text,
+                    button(
+                        GAMES_TEXTS.resumeBranch,
+                        run(() => options.resume(id, branch.head)),
+                        "secondary",
+                        "resume-branch",
+                    ),
+                );
+                return item;
+            }),
+        );
+    }
+
+    /** Déplie les branches de la partie expanded, replie les autres. */
+    async function expand(): Promise<void> {
+        for (const item of list.querySelectorAll<HTMLElement>(".games-item")) {
+            const id = item.dataset.id ?? "";
+            const open = id === expanded;
+            const link = item.querySelector<HTMLAnchorElement>('[data-action="branches"]');
+            link?.setAttribute("aria-expanded", String(open));
+            link?.setAttribute("href", routeHash({ screen: "games", game: open ? null : id }));
+            const branchList = item.querySelector<HTMLElement>(".games-branches");
+            if (branchList === null) {
+                continue;
+            }
+            if (open && branchList.hidden) {
+                await run(() => renderBranches(id, branchList))();
+            }
+            branchList.hidden = !open;
+        }
+    }
+
+    return {
+        async show(next) {
+            expanded = next;
+            if (veil.hidden) {
+                message.textContent = "";
+                veil.hidden = false;
+                await run(render)();
+                close.focus();
+            }
+            await expand();
+        },
+        hide() {
+            veil.hidden = true;
+        },
+        get isOpen() {
+            return !veil.hidden;
+        },
+    };
+}
+
+function element<K extends keyof HTMLElementTagNameMap>(
+    tag: K,
+    className = "",
+): HTMLElementTagNameMap[K] {
+    const created = document.createElement(tag);
+    if (className !== "") {
+        created.className = className;
+    }
+    return created;
+}
+
+function button(
+    text: string,
+    onClick: () => unknown,
+    className = "",
+    action = "",
+): HTMLButtonElement {
+    const created = element("button", className);
+    created.type = "button";
+    created.textContent = text;
+    if (action !== "") {
+        created.dataset.action = action;
+    }
+    created.onclick = () => void onClick();
+    return created;
+}
+
+/** Fait télécharger un fichier texte au navigateur. */
+function download(file: { fileName: string; text: string }): void {
+    const url = URL.createObjectURL(new Blob([file.text], { type: "application/x-go-sgf" }));
+    const link = element("a");
+    link.href = url;
+    link.download = file.fileName;
+    document.body.append(link);
+    link.click();
+    link.remove();
+    setTimeout(() => URL.revokeObjectURL(url), 10_000);
+}

app/src/ui/geometry.ts

@@ -0,0 +1,191 @@
+// La géométrie du plateau, calculée d'après la forme de l'écran (fonction
+// pure, testée sous Node).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Le dessin est en unités du viewBox, de hauteur fixe (520). En portrait, le
+// plateau garde ses proportions habituelles (640 × 520) et suit la largeur de
+// l'écran. En paysage, « le plateau est l'écran » (ADR 0012, amendements du
+// 2026-11-03) : sa largeur suit le rapport largeur/hauteur de l'écran, et les
+// flèches s'élargissent d'autant. Formules du composant Board des maquettes
+// « Révision UX » : largeur d'une flèche = ce qui reste une fois ôtés le
+// cadre, les colonnes et la barre, divisé par 12 ; rayon d'un pion = le plus
+// petit de la demi-largeur d'une flèche (moins 2) et du dixième de la
+// hauteur d'une demi-table (hors bande des numéros et bande centrale).
+
+/** Portrait : barre haute, bandeaux et barre d'actions autour du plateau ;
+ * paysage : le plateau seul, commandes comprises. */
+export type Layout = "portrait" | "landscape";
+
+export interface Geometry {
+    readonly layout: Layout;
+    /** Taille du dessin, en unités du viewBox. */
+    readonly width: number;
+    readonly height: number;
+    /** Épaisseur du cadre sur les côtés. */
+    readonly frame: number;
+    /** Hauteur du cadre en haut et en bas : la bande des numéros en paysage. */
+    readonly edge: number;
+    /** Colonne de commandes à gauche (0 en portrait). */
+    readonly left: number;
+    /** Colonne des sorties, à droite. */
+    readonly tray: number;
+    readonly bar: number;
+    /** Bande centrale, entre les pointes des flèches (dés, consigne). */
+    readonly band: number;
+    readonly pointWidth: number;
+    readonly radius: number;
+    /** D'un pion au suivant dans une pile. */
+    readonly step: number;
+    /** Bord gauche de la première colonne de flèches. */
+    readonly x0: number;
+    readonly barLeft: number;
+    /** Bord gauche de la moitié droite. */
+    readonly rightHalf: number;
+    readonly trayLeft: number;
+    /** Côté minimal d'une zone à toucher : 44 px à l'écran. */
+    readonly target: number;
+    /** Tailles de texte, en unités : numéros des flèches (12 px au moins à
+     * l'écran), consigne de la bande et pastilles des comptes (13 px). */
+    readonly numberSize: number;
+    readonly bandFont: number;
+    readonly chipFont: number;
+    /** Videau : côté et taille du chiffre ; nombre posé sur une pile trop
+     * haute (13 px au moins à l'écran). */
+    readonly cube: number;
+    readonly cubeFont: number;
+    readonly countFont: number;
+    /** Épaisseur des flèches du coup de l'ordinateur : 2,5 px à l'écran. */
+    readonly arrowWidth: number;
+    readonly die: number;
+    /** Nombre de pions dessinés au plus sur la barre, par camp (au-delà, un
+     * nombre sur le dernier) : en paysage, ils s'arrêtent avant les
+     * pastilles des comptes. */
+    readonly barStack: number;
+    /** Hauteur d'une pastille de compte, au bout de la barre (paysage). */
+    readonly chipHeight: number;
+}
+
+export const BOARD_HEIGHT = 520;
+/** Rapport largeur / hauteur du plateau en portrait. */
+export const PORTRAIT_ASPECT = 640 / 520;
+/** Pions dessinés au plus sur une flèche ; au-delà, un nombre sur le dernier. */
+export const MAX_STACK = 5;
+
+/** Une taille en unités qui fait au moins px pixels à l'écran. */
+function atLeast(px: number, pxPerUnit: number, min: number): number {
+    return Math.max(min, Math.ceil(px / pxPerUnit));
+}
+
+/**
+ * La géométrie du plateau pour une mise en page. aspect : rapport largeur /
+ * hauteur de la place offerte (ignoré en portrait) ; pxPerUnit : pixels à
+ * l'écran par unité du dessin, pour les tailles minimales (textes, cibles).
+ */
+export function boardGeometry(layout: Layout, aspect: number, pxPerUnit: number): Geometry {
+    const height = BOARD_HEIGHT;
+    const target = atLeast(46, pxPerUnit, 40);
+    const numberSize = atLeast(12.5, pxPerUnit, 13);
+    const text = atLeast(13.5, pxPerUnit, 17);
+    const sizes = {
+        cubeFont: text,
+        cube: Math.max(36, text + 20),
+        countFont: Math.max(18, text),
+        arrowWidth: 2.5 / pxPerUnit,
+    };
+    if (layout === "portrait") {
+        // Les mesures du plateau d'origine : flèches de 44, pions de 20.
+        const frame = 8;
+        const tray = 48;
+        const bar = 40;
+        const width = 640;
+        const pointWidth = (width - 3 * frame - tray - bar) / 12;
+        const band = 84;
+        const radius = Math.min(pointWidth / 2 - 2, (height / 2 - frame - band / 2) / 10);
+        const x0 = frame;
+        const barLeft = x0 + 6 * pointWidth;
+        return {
+            layout,
+            width,
+            height,
+            frame,
+            edge: frame,
+            left: 0,
+            tray,
+            bar,
+            band,
+            pointWidth,
+            radius,
+            step: 2 * radius + 2,
+            x0,
+            barLeft,
+            rightHalf: barLeft + bar,
+            trayLeft: barLeft + bar + 6 * pointWidth + frame,
+            target,
+            numberSize,
+            bandFont: atLeast(13.5, pxPerUnit, 17),
+            chipFont: atLeast(13.5, pxPerUnit, 17),
+            ...sizes,
+            die: 36,
+            barStack: MAX_STACK,
+            chipHeight: 0,
+        };
+    }
+    const width = Math.round(height * aspect);
+    const frame = 6;
+    const edge = Math.max(24, numberSize + 8);
+    const left = target + 4;
+    const tray = 56;
+    const bar = 64;
+    const band = 80;
+    const pointWidth = (width - 2 * frame - left - tray - bar) / 12;
+    const radius = Math.min(pointWidth / 2 - 2, (height / 2 - edge - band / 2 - 4) / 10);
+    const step = 2 * radius + 1;
+    const chipFont = atLeast(13.5, pxPerUnit, 18);
+    const chipHeight = chipFont + 12;
+    // Pions de la barre, depuis le milieu (voir board-view) : le dernier
+    // s'arrête à 2 unités de la pastille.
+    const room = height / 2 - edge - 4 - chipHeight - 2 - (radius + 4) - radius;
+    const barStack = Math.max(1, Math.min(MAX_STACK, Math.floor(room / step) + 1));
+    const x0 = frame + left;
+    const barLeft = x0 + 6 * pointWidth;
+    return {
+        layout,
+        width,
+        height,
+        frame,
+        edge,
+        left,
+        tray,
+        bar,
+        band,
+        pointWidth,
+        radius,
+        step,
+        x0,
+        barLeft,
+        rightHalf: barLeft + bar,
+        trayLeft: barLeft + bar + 6 * pointWidth,
+        target,
+        numberSize,
+        bandFont: atLeast(13.5, pxPerUnit, 22),
+        chipFont,
+        ...sizes,
+        die: Math.min(40, band - 12),
+        barStack,
+        chipHeight,
+    };
+}
+
+/** Abscisse du bord gauche d'une colonne de flèches (0 à 11). */
+export function columnLeft(g: Geometry, column: number): number {
+    return column < 6 ? g.x0 + column * g.pointWidth : g.rightHalf + (column - 6) * g.pointWidth;
+}
+
+/** Ordonnée du centre du pion numéro index (0 : contre le bord) d'une pile
+ * de la rangée du haut ou du bas. */
+export function stackY(g: Geometry, top: boolean, index: number): number {
+    const offset = g.radius + 1 + Math.min(index, MAX_STACK) * g.step;
+    return top ? g.edge + offset : g.height - g.edge - offset;
+}

app/src/ui/haptics.ts

@@ -0,0 +1,47 @@
+// Les vibrations (docs/identite/charte/interaction.md) : elles doublent un
+// événement visible, jamais seules, et se coupent dans le menu. Rien ne vibre
+// pour un toucher de bouton ni pour le lancer des dés.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+export type HapticEvent =
+    | "checkerPlaced"
+    | "checkerHit"
+    | "computerDoubles"
+    | "gameWon"
+    | "gameLost";
+
+/** Motifs en millisecondes (vibration, pause, vibration…). */
+export const HAPTIC_PATTERNS: Readonly<Record<HapticEvent, readonly number[]>> = {
+    checkerPlaced: [12],
+    checkerHit: [25, 40, 25],
+    computerDoubles: [40, 60, 40],
+    gameWon: [30, 50, 30, 50, 60],
+    gameLost: [60],
+};
+
+/** navigator.vibrate, s'il existe. */
+export type Vibrate = (pattern: number[]) => boolean;
+
+/**
+ * La fonction qui fait vibrer pour un événement : rien si le navigateur ne
+ * sait pas vibrer ou si le joueur a coupé les vibrations. Une seule vibration
+ * à la fois : chaque appel remplace le précédent (comportement de
+ * navigator.vibrate).
+ */
+export function createHaptics(
+    vibrate: Vibrate | undefined,
+    enabled: () => boolean,
+): (event: HapticEvent) => void {
+    return (event) => {
+        if (vibrate !== undefined && enabled()) {
+            try {
+                vibrate([...HAPTIC_PATTERNS[event]]);
+            } catch {
+                // Navigateur qui refuse (pas encore de geste du joueur) : la
+                // marque visible suffit.
+            }
+        }
+    };
+}

app/src/ui/help-context.ts

@@ -0,0 +1,32 @@
+// La question de l'aide qui correspond au moment de la partie : le bouton
+// « Aide » de l'écran de jeu l'ouvre directement (charte : « fermée par
+// défaut sauf celle qui correspond à l'écran d'où l'on vient »).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Les questions sont les titres des scénarios de docs/scenarios/ (ADR 0008) ;
+// leur adresse en est tirée par slug. Un test (app/tests/ui.test.ts) vérifie
+// que chaque titre ci-dessous est bien celui d'un scénario : changer un
+// titre dans un .feature demande de le changer ici.
+
+import { routeHash, slug } from "./router.js";
+
+/** Le moment de la partie, vu de l'aide. */
+export type HelpMoment = "moving" | "stuck" | "doubled" | "over";
+
+export const HELP_QUESTIONS: Readonly<Record<HelpMoment, string>> = {
+    moving: "Comment jouer un coup ?",
+    stuck: "Je ne peux rien jouer avec mes dés",
+    doubled: "L'ordinateur double : que se passe-t-il si je prends ?",
+    over: "Comment se termine une partie ?",
+};
+
+/** L'adresse de l'aide à ouvrir à ce moment (l'onglet « Jouer » sans
+ * question particulière : null). */
+export function helpHash(moment: HelpMoment | null): string {
+    return routeHash({
+        screen: "help",
+        question: moment === null ? null : slug(HELP_QUESTIONS[moment]),
+    });
+}

app/src/ui/help-text.ts

@@ -14,10 +14,16 @@ export interface HelpFeature {
 }
 
 export interface HelpScenario {
+    /** Le titre, formulé comme la question du joueur. */
     readonly title: string;
+    /** La réponse : le paragraphe sous le titre. */
     readonly description: readonly string[];
-    /** Les étapes, mot-clé compris : « Quand vous prenez ». */
+    /** Les étapes, mot-clé compris : « Quand vous prenez ». Elles ne
+     * s'affichent pas dans l'aide : elles prouvent la réponse. */
     readonly steps: readonly string[];
+    /** La position de l'exemple, donnée par l'étiquette
+     * @position:<Position ID> du scénario (null sans étiquette). */
+    readonly position: string | null;
 }
 
 const STEP = /^(Étant donnée?s?|Etant donnée?s?|Soit|Quand|Lorsque|Alors|Donc|Et|Mais)\s/;
@@ -27,13 +33,20 @@ const FEATURE = /^Fonctionnalité\s*:\s*(.*)$/;
 /**
  * Lit un fichier Gherkin en français (fichiers .feature). Les lignes de texte
  * libre consécutives forment un paragraphe ; les commentaires (#) sont
- * ignorés.
+ * ignorés ; une étiquette @position:<Position ID> donne la position de
+ * l'exemple du scénario qui la suit.
  */
 export function parseFeature(text: string): HelpFeature {
     let title = "";
     const description: string[] = [];
-    const scenarios: { title: string; description: string[]; steps: string[] }[] = [];
+    const scenarios: {
+        title: string;
+        description: string[];
+        steps: string[];
+        position: string | null;
+    }[] = [];
     let paragraph: string[] = [];
+    let tags: string[] = [];
 
     // Le paragraphe en cours rejoint la description de la fonctionnalité ou
     // du dernier scénario.
@@ -50,12 +63,23 @@ export function parseFeature(text: string): HelpFeature {
         const scenario = SCENARIO.exec(line);
         if (line === "" || line.startsWith("#")) {
             endParagraph();
+        } else if (line.startsWith("@")) {
+            endParagraph();
+            tags.push(...line.split(/\s+/));
         } else if (feature) {
             endParagraph();
             title = feature[1] ?? "";
+            tags = [];
         } else if (scenario) {
             endParagraph();
-            scenarios.push({ title: scenario[2] ?? "", description: [], steps: [] });
+            const position = tags.find((tag) => tag.startsWith("@position:"));
+            scenarios.push({
+                title: scenario[2] ?? "",
+                description: [],
+                steps: [],
+                position: position === undefined ? null : position.slice("@position:".length),
+            });
+            tags = [];
         } else if (STEP.test(line) && scenarios.length > 0) {
             endParagraph();
             scenarios.at(-1)?.steps.push(line);
@@ -74,18 +98,42 @@ export function parseGlossaryIndex(readme: string): string[] {
     return [...section.matchAll(/\]\(([a-z0-9-]+\.md)\)/g)].map((match) => match[1] ?? "");
 }
 
-/** Une fiche du glossaire : le terme et sa phrase « En bref ». */
+/** Une fiche du glossaire : le terme, son nom anglais (celui du code), sa
+ * phrase « En bref », et ses renvois « Voir aussi ». */
 export interface GlossaryEntry {
     readonly term: string;
+    readonly english: string;
     readonly brief: string;
+    /** Les fiches citées par « Voir aussi » : le mot, et la fiche sans .md. */
+    readonly seeAlso: readonly { readonly term: string; readonly name: string }[];
 }
 
 /** Lit une fiche du glossaire ; null si elle n'a pas la forme attendue. */
 export function parseGlossaryEntry(text: string): GlossaryEntry | null {
     const term = /^term: (.+)$/m.exec(text)?.[1]?.trim();
+    const english = /^english: (.+)$/m.exec(text)?.[1]?.trim() ?? "";
     const brief = /^\*\*En bref\*\* : (.+)$/m.exec(text)?.[1]?.trim();
     if (term === undefined || brief === undefined) {
         return null;
     }
-    return { term, brief: brief.replaceAll("**", "") };
+    const seeLine = /^Voir aussi : (.+)$/m.exec(text)?.[1] ?? "";
+    const seeAlso = [...seeLine.matchAll(/\[([^\]]+)\]\(([a-z0-9-]+)\.md\)/g)].map((m) => ({
+        term: m[1] ?? "",
+        name: m[2] ?? "",
+    }));
+    return { term, english, brief: brief.replaceAll("**", ""), seeAlso };
+}
+
+/** Un texte sans accents ni majuscules, pour la recherche dans le
+ * glossaire. */
+export function searchable(text: string): string {
+    return text.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase();
+}
+
+/** La fiche correspond-elle à la recherche (le terme, son nom anglais ou sa
+ * phrase « En bref » contiennent chacun des mots cherchés) ? */
+export function matchesSearch(entry: GlossaryEntry, query: string): boolean {
+    const words = searchable(query).split(/\s+/).filter(Boolean);
+    const haystack = searchable(`${entry.term} ${entry.english} ${entry.brief}`);
+    return words.every((word) => haystack.includes(word));
 }

app/src/ui/help.ts

@@ -1,21 +1,41 @@
-// La page d'aide : le scénario « Jouer une partie contre l'ordinateur » et le
-// glossaire, lus à l'exécution dans les copies de docs/ faites par make site
-// (ADR 0008). Rien n'est recopié dans le code.
+// L'aide : les scénarios (onglet « Jouer », une question par scénario), le
+// glossaire (« Les mots du jeu ») et « À propos », lus à l'exécution dans
+// les copies de docs/ faites par make site (ADR 0008). Rien n'est recopié
+// dans le code.
 //
 // Copyright (C) 2026 les auteurs d'Ustagammon.
 // Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Chaque onglet, chaque question et chaque terme a son adresse (ADR 0013,
+// amendement) : on les ouvre par de vrais liens, et l'adresse dit ce qui
+// est ouvert (show). Le titre d'un scénario est la question, sa
+// description la réponse ; ses étapes, la preuve que l'application fait ce
+// que dit la réponse, ne s'affichent pas
+// (docs/identite/charte/accueil-tutoriel-aide.md, « Aide »).
 
 import {
     type GlossaryEntry,
     type HelpFeature,
+    type HelpScenario,
+    matchesSearch,
     parseFeature,
     parseGlossaryEntry,
     parseGlossaryIndex,
 } from "./help-text.js";
+import { HOME_TEXTS } from "./home-texts.js";
+import { type HelpRoute, routeHash, slug } from "./router.js";
 import { TEXTS } from "./texts.js";
 
 /** Les scénarios montrés dans l'aide, dans l'ordre. */
-const FEATURES = ["docs/scenarios/jouer-une-partie.feature"];
+export const FEATURES = [
+    "docs/scenarios/jouer-une-partie.feature",
+    "docs/scenarios/apprendre-les-regles.feature",
+    "docs/scenarios/mes-parties.feature",
+    "docs/scenarios/partager-une-position.feature",
+    "docs/scenarios/regler-l-application.feature",
+    "docs/scenarios/installer-l-application.feature",
+    "docs/scenarios/decouvrir-l-application.feature",
+];
 const GLOSSARY = "docs/glossaire/";
 
 async function fetchText(url: string): Promise<string> {
@@ -26,10 +46,37 @@ async function fetchText(url: string): Promise<string> {
     return response.text();
 }
 
-async function loadGlossary(): Promise<GlossaryEntry[]> {
+/** Une fiche du glossaire et son nom de fichier, sans .md. */
+interface GlossaryCard extends GlossaryEntry {
+    readonly name: string;
+}
+
+async function loadGlossary(): Promise<GlossaryCard[]> {
     const files = parseGlossaryIndex(await fetchText(`${GLOSSARY}README.md`));
     const texts = await Promise.all(files.map((file) => fetchText(GLOSSARY + file)));
-    return texts.map(parseGlossaryEntry).filter((entry) => entry !== null);
+    return texts.flatMap((text, i) => {
+        const entry = parseGlossaryEntry(text);
+        const name = (files[i] ?? "").replace(/\.md$/, "");
+        return entry === null ? [] : [{ ...entry, name }];
+    });
+}
+
+/** Une fiche du glossaire (nom de fichier dans docs/glossaire/), lue dans la
+ * copie du site : la bulle du compte de points en affiche le texte. */
+export async function loadGlossaryEntry(file: string): Promise<GlossaryEntry | null> {
+    return parseGlossaryEntry(await fetchText(GLOSSARY + file));
+}
+
+/** Le commit publié (version.json, écrit par make site), en abrégé. */
+async function publishedVersion(): Promise<string | null> {
+    try {
+        const version = JSON.parse(await fetchText("version.json")) as { commit?: unknown };
+        return typeof version.commit === "string" && version.commit !== ""
+            ? version.commit.slice(0, 12)
+            : null;
+    } catch {
+        return null;
+    }
 }
 
 function element<K extends keyof HTMLElementTagNameMap>(
@@ -45,56 +92,246 @@ function element<K extends keyof HTMLElementTagNameMap>(
     return child;
 }
 
-function renderFeature(parent: HTMLElement, feature: HelpFeature): void {
-    element(parent, "h2", feature.title);
-    for (const paragraph of feature.description) {
-        element(parent, "p", paragraph);
-    }
-    for (const scenario of feature.scenarios) {
-        element(parent, "h3", scenario.title);
+/** Une question de l'onglet « Jouer » : son lien et sa réponse. */
+interface Question {
+    readonly id: string;
+    readonly section: HTMLElement;
+    readonly link: HTMLAnchorElement;
+    readonly answer: HTMLElement;
+}
+
+export interface HelpView {
+    /** Montre l'onglet, la question ou le terme que désigne l'adresse
+     * (l'aide est lue au premier appel). */
+    show(route: HelpRoute): Promise<void>;
+}
+
+/**
+ * L'aide dans container : un onglet par panneau (Jouer, Les mots du jeu, À
+ * propos). Les liens des onglets sont dans tabs, déjà dans la page.
+ */
+export function createHelpView(container: HTMLElement, tabs: HTMLElement): HelpView {
+    const play = document.createElement("div");
+    play.id = "help-play";
+    const glossary = document.createElement("div");
+    glossary.id = "help-glossary";
+    const about = document.createElement("div");
+    about.id = "help-about";
+    const notice = document.createElement("p");
+    notice.className = "help-notice";
+    notice.setAttribute("role", "status");
+    const questions: Question[] = [];
+    const terms = new Map<string, { dt: HTMLElement; card: HTMLElement; entry: GlossaryCard }>();
+    let loading: Promise<boolean> | null = null;
+    // La question ouverte au dernier affichage : refermée, elle reste en vue.
+    let lastOpen: Question | null = null;
+
+    function renderScenario(parent: HTMLElement, scenario: HelpScenario): void {
+        let id = slug(scenario.title);
+        for (let n = 2; questions.some((q) => q.id === id); n++) {
+            id = `${slug(scenario.title)}-${n}`;
+        }
+        const section = element(parent, "section");
+        section.className = "question";
+        section.id = `aide-${id}`;
+        const heading = element(section, "h3");
+        const link = element(heading, "a", scenario.title);
+        link.href = routeHash({ screen: "help", question: id });
+        link.setAttribute("aria-controls", `aide-${id}-reponse`);
+        link.setAttribute("aria-expanded", "false");
+        const answer = element(section, "div");
+        answer.id = `aide-${id}-reponse`;
+        answer.className = "answer";
+        answer.hidden = true;
         for (const paragraph of scenario.description) {
-            element(parent, "p", paragraph);
+            element(answer, "p", paragraph);
         }
-        const steps = element(parent, "ul");
-        steps.className = "steps";
-        for (const step of scenario.steps) {
-            element(steps, "li", step);
+        if (scenario.position !== null) {
+            const board = element(answer, "a", HOME_TEXTS.seeOnBoard);
+            board.className = "see-board";
+            board.href = routeHash({
+                screen: "position",
+                position: scenario.position,
+                match: null,
+            });
         }
+        questions.push({ id, section, link, answer });
     }
-}
 
-function renderGlossary(parent: HTMLElement, entries: readonly GlossaryEntry[]): void {
-    element(parent, "h2", TEXTS.glossaryTitle);
-    const list = element(parent, "dl");
-    list.className = "glossary";
-    for (const entry of entries) {
-        element(list, "dt", entry.term);
-        element(list, "dd", entry.brief);
-    }
-}
-
-/** Remplit container avec l'aide (une seule fois ; les appels suivants ne
- * font rien). */
-export async function showHelp(container: HTMLElement): Promise<void> {
-    if (container.dataset.loaded === "true") {
-        return;
-    }
-    container.replaceChildren();
-    const status = element(container, "p", TEXTS.helpLoading);
-    try {
-        const [features, glossary] = await Promise.all([
-            Promise.all(FEATURES.map(async (url) => parseFeature(await fetchText(url)))),
-            loadGlossary(),
-        ]);
-        status.remove();
-        for (const feature of features) {
-            renderFeature(container, feature);
+    function renderFeature(feature: HelpFeature): void {
+        element(play, "h2", feature.title);
+        for (const paragraph of feature.description) {
+            element(play, "p", paragraph).className = "feature-intro";
+        }
+        for (const scenario of feature.scenarios) {
+            renderScenario(play, scenario);
         }
-        renderGlossary(container, glossary);
-        const about = element(container, "p", TEXTS.about);
-        about.className = "about";
-        container.dataset.loaded = "true";
-    } catch {
-        status.textContent = TEXTS.helpFailed;
     }
+
+    function renderGlossary(entries: readonly GlossaryCard[]): void {
+        element(glossary, "h2", TEXTS.glossaryTitle);
+        const label = element(glossary, "label");
+        label.className = "glossary-search";
+        element(label, "span", HOME_TEXTS.glossarySearch).className = "search-label";
+        const search = element(label, "input");
+        search.id = "glossary-search";
+        search.type = "search";
+        search.autocomplete = "off";
+        search.spellcheck = false;
+        const none = element(glossary, "p", HOME_TEXTS.glossaryNone);
+        none.className = "glossary-none muted";
+        none.hidden = true;
+        const list = element(glossary, "dl");
+        list.className = "glossary";
+        const sorted = [...entries].sort((a, b) => a.term.localeCompare(b.term, "fr"));
+        for (const entry of sorted) {
+            const card = element(list, "div");
+            card.className = "term-card";
+            const dt = element(card, "dt");
+            dt.id = `glossaire-${entry.name}`;
+            const link = element(dt, "a", entry.term);
+            link.href = routeHash({ screen: "glossary", term: entry.name });
+            if (entry.english !== "") {
+                const english = element(dt, "span", entry.english);
+                english.className = "english";
+                english.lang = "en";
+            }
+            const dd = element(card, "dd");
+            element(dd, "p", entry.brief);
+            if (entry.seeAlso.length > 0) {
+                const see = element(dd, "p");
+                see.className = "see-also";
+                see.append(`${HOME_TEXTS.glossarySeeAlso} `);
+                entry.seeAlso.forEach((other, i) => {
+                    if (i > 0) {
+                        see.append(", ");
+                    }
+                    const a = element(see, "a", other.term);
+                    a.href = routeHash({ screen: "glossary", term: other.name });
+                });
+            }
+            terms.set(entry.name, { dt, card, entry });
+        }
+        search.addEventListener("input", () => {
+            let shown = 0;
+            for (const { card, entry } of terms.values()) {
+                const match = matchesSearch(entry, search.value);
+                card.hidden = !match;
+                shown += match ? 1 : 0;
+            }
+            none.hidden = shown > 0;
+        });
+    }
+
+    function renderAbout(version: string | null): void {
+        element(about, "h2", TEXTS.aboutTitle);
+        for (const paragraph of HOME_TEXTS.aboutParagraphs) {
+            element(about, "p", paragraph).className = "about";
+        }
+        const line = element(
+            about,
+            "p",
+            version === null ? HOME_TEXTS.aboutVersionUnknown : HOME_TEXTS.aboutVersion(version),
+        );
+        line.id = "about-version";
+        line.className = "about";
+    }
+
+    function renderTutorialCard(): void {
+        const card = element(container, "a");
+        card.id = "help-tutorial";
+        card.className = "card help-tutorial";
+        card.href = "#/tutoriel/1";
+        const text = element(card, "span");
+        text.className = "help-tutorial-text";
+        element(text, "strong", HOME_TEXTS.helpTutorialTitle);
+        element(text, "span", HOME_TEXTS.helpTutorialText).className = "muted";
+        element(card, "span", HOME_TEXTS.helpTutorialLink).className = "pill";
+    }
+
+    async function load(): Promise<boolean> {
+        container.replaceChildren(notice);
+        notice.textContent = TEXTS.helpLoading;
+        try {
+            const [features, entries, version] = await Promise.all([
+                Promise.all(FEATURES.map(async (url) => parseFeature(await fetchText(url)))),
+                loadGlossary(),
+                publishedVersion(),
+            ]);
+            const intro = element(play, "p", HOME_TEXTS.helpIntro);
+            intro.className = "help-intro muted";
+            for (const feature of features) {
+                renderFeature(feature);
+            }
+            renderGlossary(entries);
+            renderAbout(version);
+            notice.textContent = "";
+            renderTutorialCard();
+            container.append(play, glossary, about);
+            container.dataset.loaded = "true";
+            return true;
+        } catch {
+            notice.textContent = TEXTS.helpFailed;
+            loading = null; // on réessaiera à la prochaine ouverture
+            return false;
+        }
+    }
+
+    return {
+        async show(route) {
+            for (const tab of tabs.querySelectorAll<HTMLAnchorElement>("a[data-screen]")) {
+                if (tab.dataset.screen === route.screen) {
+                    tab.setAttribute("aria-current", "page");
+                } else {
+                    tab.removeAttribute("aria-current");
+                }
+            }
+            loading ??= load();
+            if (!(await loading)) {
+                return;
+            }
+            play.hidden = route.screen !== "help";
+            glossary.hidden = route.screen !== "glossary";
+            about.hidden = route.screen !== "about";
+
+            const question = route.screen === "help" ? route.question : null;
+            for (const q of questions) {
+                const open = q.id === question;
+                q.answer.hidden = !open;
+                q.link.setAttribute("aria-expanded", String(open));
+                // Le lien d'une question ouverte la referme.
+                q.link.href = routeHash({ screen: "help", question: open ? null : q.id });
+                q.section.classList.toggle("open", open);
+            }
+            const term = route.screen === "glossary" ? route.term : null;
+            for (const [name, { dt, card }] of terms) {
+                dt.classList.toggle("current", name === term);
+                card.classList.toggle("current", name === term);
+                if (name === term) {
+                    dt.setAttribute("aria-current", "true");
+                    card.hidden = false;
+                } else {
+                    dt.removeAttribute("aria-current");
+                }
+            }
+            const missing =
+                (question !== null && !questions.some((q) => q.id === question)) ||
+                (term !== null && !terms.has(term));
+            notice.textContent = missing ? TEXTS.helpNotFound : "";
+
+            const opened = questions.find((q) => q.id === question) ?? null;
+            const closed = route.screen === "help" && opened === null ? lastOpen : null;
+            lastOpen = opened;
+            // La barre haute de l'aide reste en vue (app.css) : ce qu'on
+            // amène en haut s'arrête 12 px sous elle (scroll-margin-top).
+            const target = opened?.section ?? (term === null ? undefined : terms.get(term)?.card);
+            if (target !== undefined) {
+                target.scrollIntoView({ block: "start" });
+            } else if (closed !== null) {
+                closed.section.scrollIntoView({ block: "nearest" });
+            } else {
+                window.scrollTo(0, 0);
+            }
+        },
+    };
 }

app/src/ui/home-model.ts

@@ -0,0 +1,64 @@
+// Ce que montre l'accueil, et où s'ouvre l'application : fonctions pures,
+// testées sous Node (docs/identite/charte/accueil-tutoriel-aide.md).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import { installCardShown, isFirstLaunch, type Settings } from "./settings.js";
+
+/** Les deux choix du premier lancement : « Je découvre » mène au
+ * tutoriel, « Je connais les règles » à la partie. */
+export const WELCOME_LINKS = { discover: "#/tutoriel/1", play: "#/" } as const;
+
+/** Les réglages après l'un des deux choix du premier lancement. */
+export function welcomed(): Partial<Settings> {
+    return { welcomed: true };
+}
+
+/** L'adresse où ouvrir l'application lancée sans adresse d'écran (icône de
+ * l'écran d'accueil, adresse du site) : l'accueil. Une adresse donnée est
+ * gardée (null). */
+export function launchHash(hash: string): string | null {
+    return hash === "" || hash === "#" ? "#/accueil" : null;
+}
+
+/** L'accueil, au premier lancement ou ensuite. */
+export interface HomeModel {
+    /** Premier lancement : le choix « Je découvre » / « Je connais les
+     * règles », et rien d'autre. */
+    readonly welcome: boolean;
+    /** La carte de la partie : « Reprendre la partie » si une partie est en
+     * cours, sinon « Nouvelle partie » en action principale. */
+    readonly resume: boolean;
+    /** L'invitation à installer. */
+    readonly installCard: boolean;
+}
+
+/** Ce que montre l'accueil. playing : une partie est en cours (null : pas
+ * encore connu, le moteur se charge). */
+export function homeModel(
+    settings: Settings,
+    playing: boolean | null,
+    installed: boolean,
+): HomeModel {
+    const welcome = isFirstLaunch(settings);
+    return {
+        welcome,
+        resume: playing !== false,
+        installCard: !welcome && installCardShown(settings, installed),
+    };
+}
+
+/** La ligne « Installer l'application » du menu : tant que l'application
+ * n'est pas installée. */
+export function installMenuShown(settings: Settings, installed: boolean): boolean {
+    return !installed && !settings.installed;
+}
+
+/** Les réglages après « Plus tard » sur l'invitation à installer. */
+export function dismissInstall(settings: Settings): Partial<Settings> {
+    return {
+        installDismissals: settings.installDismissals + 1,
+        installDismissedAt: settings.gamesFinished,
+    };
+}

app/src/ui/home-texts.ts

@@ -0,0 +1,125 @@
+// Les textes de l'accueil, du tutoriel, de l'installation et de la mise à
+// jour (ADR 0007, point 5 ; docs/identite/charte/accueil-tutoriel-aide.md).
+// Première version, à valider par Pierre. Le texte des étapes du tutoriel
+// n'est pas ici : il vit dans docs/tutoriel/regles.md.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import type { ResultKind } from "../domain/game/engine.js";
+import type { InstallPlatform } from "./install.js";
+
+function plural(n: number, one: string, many: string): string {
+    return `${n} ${n > 1 ? many : one}`;
+}
+
+export const HOME_TEXTS = {
+    // Premier lancement
+    welcomeTitle: "Bienvenue à la table",
+    welcomeText:
+        "Ustagammon vous apprend le backgammon pas à pas, et vous fait jouer contre l'ordinateur, même sans réseau.",
+    discover: "Je découvre",
+    discoverDetail: "Les règles en huit petites étapes, plateau à l'appui",
+    knowRules: "Je connais les règles",
+    knowRulesDetail: "Une partie tout de suite",
+    tutorialInMenu: "Le tutoriel reste dans le menu, à tout moment.",
+
+    // Accueil
+    homeLink: "Accueil",
+    homeTitle: "À vous de jouer",
+    homeLead: "Reprenez votre partie contre l'ordinateur, ou revoyez les règles.",
+    gameOverline: "Partie en cours",
+    noGameOverline: "Pas de partie en cours",
+    againstComputer: "Contre l'ordinateur",
+    homePips: (player: number, computer: number) =>
+        `Compte de points : vous ${player}, l'ordinateur ${computer}`,
+    homeLoading: "Chargement…",
+    resumeGame: "Reprendre la partie",
+    rulesTitle: "Les règles du jeu",
+    rulesDetail: "Le tutoriel, en huit étapes, plateau à l'appui",
+    rulesStart: "Commencer",
+    rulesContinue: (step: number) => `Reprendre à l'étape ${step}`,
+    rulesAgain: "Revoir",
+    progress: (played: number, won: number) =>
+        `${plural(played, "partie jouée", "parties jouées")} · ${plural(won, "gagnée", "gagnées")}`,
+    footer: "Né à l'Atelier du Huit, à Cugnaux. Logiciel libre, sans publicité ni mise.",
+
+    // Installation
+    installTitle: "Installer Ustagammon",
+    installCardText: "Sur l'écran d'accueil, en plein écran, sans réseau.",
+    install: "Installer",
+    installLater: "Plus tard",
+    installMenu: "Installer l'application",
+    installLead:
+        "Une icône sur votre écran d'accueil, le jeu en plein écran, et tout marche sans réseau.",
+    installSteps: {
+        firefox: [
+            "Touchez le menu du navigateur ⋮, en bas ou en haut de l'écran.",
+            "Choisissez « Installer » ou « Ajouter à l'écran d'accueil ».",
+            "Confirmez. Ensuite, ouvrez Ustagammon depuis son icône.",
+        ],
+        ios: [
+            "Touchez le bouton de partage, le carré d'où sort une flèche, en bas de Safari.",
+            "Choisissez « Sur l'écran d'accueil ».",
+            "Touchez « Ajouter ». Ensuite, ouvrez Ustagammon depuis son icône.",
+        ],
+    } satisfies Record<InstallPlatform, readonly string[]>,
+    installUnderstood: "J'ai compris",
+    installed: "Ustagammon est installé : ouvrez-le depuis son icône.",
+
+    // Mise à jour
+    updateAvailable: "Nouvelle version prête.",
+    updateApply: "Mettre à jour",
+    updateCheck: "Rechercher une mise à jour",
+    updateChecking: "Recherche d'une mise à jour…",
+    updateLatest: "Vous avez la dernière version.",
+    updateUnavailable:
+        "Impossible de chercher une mise à jour : pas de réseau, ou navigateur qui ne le permet pas.",
+
+    // Tutoriel
+    tutorialMenu: "Les règles (tutoriel)",
+    tutorialProgress: "Étapes du tutoriel",
+    tutorialStepLink: (n: number, title: string) => `Étape ${n} : ${title}`,
+    tutorialSkip: "Quitter",
+    tutorialSkipLabel: "Quitter le tutoriel",
+    tutorialOverline: (n: number, total: number, practice: boolean) =>
+        `Les règles · ${n} sur ${total}${practice ? " · à vous" : ""}`,
+    tutorialEndOverline: "Les règles · fin",
+    tutorialEndTitle: "Vous connaissez les règles",
+    back: "Retour",
+    next: "Continuer",
+    replay: "Revoir",
+    replayLabel: "Revoir le coup",
+    take: "Prendre",
+    drop: "Passer",
+    tutorialLoading: "Chargement du tutoriel…",
+    tutorialFailed: "Le tutoriel n'a pas pu se charger.",
+    pathLabel: "Le sens du jeu de vos pions, en pointillés",
+    /** Le résultat d'une partie finie par le coup illustré (étape 7). */
+    illustratedEnd: (kind: ResultKind) =>
+        kind === "single"
+            ? "Partie finie : l'ordinateur avait sorti des pions, c'est une partie simple."
+            : kind === "gammon"
+              ? "Partie finie : l'ordinateur n'a sorti aucun pion, c'est un gammon."
+              : "Partie finie : il reste un pion de l'ordinateur dans votre camp, c'est un backgammon.",
+    computerDoubles: "L'ordinateur double.",
+
+    // Aide
+    helpTutorialTitle: "Nouveau au backgammon ?",
+    helpTutorialText: "Le tutoriel des règles, en huit étapes, plateau à l'appui.",
+    helpTutorialLink: "Apprendre les règles",
+    helpIntro:
+        "Une question en partie ? Elle a sûrement sa réponse ici. Touchez une question pour lire la réponse.",
+    seeOnBoard: "Voir sur le plateau",
+    glossarySearch: "Chercher un mot",
+    glossaryNone: "Aucun mot ne correspond.",
+    glossarySeeAlso: "Voir aussi :",
+    aboutVersion: (commit: string) => `Version publiée : ${commit}.`,
+    aboutVersionUnknown: "Version publiée : inconnue (lancée depuis les sources).",
+    aboutParagraphs: [
+        "Ustagammon est un logiciel libre, sous licence GNU GPL version 3 ou ultérieure : vous pouvez l'utiliser, l'étudier, le modifier et le partager.",
+        "Les textes du tutoriel, de l'aide et du glossaire sont sous licence Creative Commons BY-SA 4.0.",
+        "L'ordinateur joue et juge les coups avec GNU Backgammon (GPLv3), compilé pour le navigateur. Police Alegreya Sans, sous licence SIL Open Font License.",
+        "Né à l'Atelier du Huit, café associatif à Cugnaux. Sans publicité, sans compte, sans mise : tout reste sur votre téléphone.",
+    ],
+} as const;

app/src/ui/home-view.ts

@@ -0,0 +1,242 @@
+// L'accueil (#/accueil) : au premier lancement, le choix « Je découvre » /
+// « Je connais les règles » ; ensuite, la partie en cours, l'invitation à
+// installer, les règles et la progression résumée
+// (docs/identite/charte/accueil-tutoriel-aide.md, « Accueil »).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Les leçons (1g) et la progression détaillée (1h) n'existent pas encore :
+// l'accueil n'affiche que ce qui existe.
+
+import type { SideBoards } from "../domain/game/game.js";
+import { boardModel, OPENING_BOARDS } from "./board-model.js";
+import { NO_MARKS, renderBoard } from "./board-view.js";
+import { boardGeometry, PORTRAIT_ASPECT } from "./geometry.js";
+import { type HomeModel, WELCOME_LINKS } from "./home-model.js";
+import { HOME_TEXTS } from "./home-texts.js";
+import { icon } from "./icons.js";
+import { TUTORIAL_DONE } from "./settings.js";
+import { TEXTS } from "./texts.js";
+
+export interface HomeViewOptions {
+    readonly section: HTMLElement;
+    /** « Nouvelle partie » (bouton : une action, pas un écran). */
+    readonly newGame: () => void;
+    readonly install: () => void;
+    readonly dismissInstall: () => void;
+    /** Un des deux choix du premier lancement a été suivi. */
+    readonly welcomed: () => void;
+}
+
+export interface HomeState {
+    readonly model: HomeModel;
+    /** Le plateau de la partie en cours ou de la dernière partie (null :
+     * jamais joué). */
+    readonly sides: SideBoards | null;
+    /** La dernière étape du tutoriel vue. */
+    readonly tutorialSeen: number;
+    /** Parties jouées et gagnées (null : pas encore lues). */
+    readonly progress: { readonly played: number; readonly won: number } | null;
+    /** Le moteur se charge, ou l'écran est occupé. */
+    readonly busy: boolean;
+}
+
+export interface HomeView {
+    render(state: HomeState): void;
+}
+
+const SVG_NS = "http://www.w3.org/2000/svg";
+
+function element<K extends keyof HTMLElementTagNameMap>(
+    parent: HTMLElement,
+    tag: K,
+    options: { id?: string; className?: string; text?: string } = {},
+): HTMLElementTagNameMap[K] {
+    const child = document.createElement(tag);
+    if (options.id !== undefined) {
+        child.id = options.id;
+    }
+    if (options.className !== undefined) {
+        child.className = options.className;
+    }
+    if (options.text !== undefined) {
+        child.textContent = options.text;
+    }
+    parent.append(child);
+    return child;
+}
+
+function boardSvg(parent: HTMLElement, id: string, className: string): SVGSVGElement {
+    const svg = document.createElementNS(SVG_NS, "svg");
+    svg.id = id;
+    svg.setAttribute("class", `board ${className}`);
+    svg.setAttribute("aria-hidden", "true");
+    parent.append(svg);
+    return svg;
+}
+
+function logo(parent: HTMLElement): void {
+    for (const [variant, file] of [
+        ["logo-light", "logo-horizontal-couleur.svg"],
+        ["logo-dark", "logo-horizontal-sombre.svg"],
+    ] as const) {
+        const img = element(parent, "img", { className: variant });
+        img.src = `icons/${file}`;
+        img.alt = "Ustagammon";
+    }
+}
+
+function drawBoard(svg: SVGSVGElement, sides: SideBoards, width: number): void {
+    renderBoard(svg, boardGeometry("portrait", PORTRAIT_ASPECT, width / 640), boardModel(sides), {
+        ...NO_MARKS,
+        dice: [],
+        cube: { value: 1, owner: null },
+        band: null,
+        controls: null,
+    });
+}
+
+/** Une grande carte-lien du premier lancement : le choix et son détail. */
+function choice(parent: HTMLElement, id: string, href: string, label: string, detail: string) {
+    const link = element(parent, "a", { id, className: "choice" });
+    link.href = href;
+    element(link, "strong", { text: label });
+    element(link, "span", { text: detail });
+    return link;
+}
+
+export function createHomeView(options: HomeViewOptions): HomeView {
+    const { section } = options;
+    section.replaceChildren();
+
+    // Premier lancement.
+    const welcome = element(section, "div", { id: "home-welcome", className: "welcome" });
+    const welcomeLogo = element(welcome, "h1", { className: "welcome-logo" });
+    logo(welcomeLogo);
+    const welcomeBoard = boardSvg(welcome, "welcome-board", "welcome-board");
+    const welcomeText = element(welcome, "div", { className: "welcome-text" });
+    element(welcomeText, "h2", { text: HOME_TEXTS.welcomeTitle });
+    element(welcomeText, "p", { text: HOME_TEXTS.welcomeText });
+    const choices = element(welcome, "div", { className: "welcome-choices" });
+    const discover = choice(
+        choices,
+        "welcome-discover",
+        WELCOME_LINKS.discover,
+        HOME_TEXTS.discover,
+        HOME_TEXTS.discoverDetail,
+    );
+    discover.classList.add("primary");
+    const play = choice(
+        choices,
+        "welcome-play",
+        WELCOME_LINKS.play,
+        HOME_TEXTS.knowRules,
+        HOME_TEXTS.knowRulesDetail,
+    );
+    element(choices, "p", { className: "caption", text: HOME_TEXTS.tutorialInMenu });
+    for (const link of [discover, play]) {
+        link.addEventListener("click", () => options.welcomed());
+    }
+
+    // Ensuite.
+    const main = element(section, "div", { id: "home-main", className: "home-main" });
+    const intro = element(main, "div", { className: "home-intro" });
+    element(intro, "h2", { text: HOME_TEXTS.homeTitle });
+    element(intro, "p", { className: "muted", text: HOME_TEXTS.homeLead });
+
+    const card = element(main, "article", { id: "home-game", className: "card home-game" });
+    const cardTop = element(card, "div", { className: "home-game-top" });
+    const miniBox = element(cardTop, "div", { className: "home-mini" });
+    const mini = boardSvg(miniBox, "home-board", "home-board");
+    const facts = element(cardTop, "div", { className: "home-facts" });
+    const gameOverline = element(facts, "span", { className: "overline" });
+    element(facts, "strong", { text: HOME_TEXTS.againstComputer });
+    const pips = element(facts, "span", { id: "home-pips", className: "home-pips" });
+    const actions = element(card, "div", { className: "home-actions" });
+    const resume = element(actions, "a", {
+        id: "home-resume",
+        className: "button",
+        text: HOME_TEXTS.resumeGame,
+    });
+    resume.href = "#/";
+    const fresh = element(actions, "button", { id: "home-new", text: TEXTS.newGame });
+    fresh.type = "button";
+    fresh.addEventListener("click", () => options.newGame());
+
+    const install = element(main, "aside", { id: "install-card", className: "install-card" });
+    install.setAttribute("aria-label", HOME_TEXTS.installTitle);
+    const symbol = element(install, "img", { className: "install-symbol" });
+    symbol.src = "icons/symbole-couleur.svg";
+    symbol.alt = "";
+    const installText = element(install, "span", { className: "install-text" });
+    element(installText, "strong", { text: HOME_TEXTS.installTitle });
+    element(installText, "span", { className: "muted", text: HOME_TEXTS.installCardText });
+    const installButton = element(install, "button", {
+        id: "install-card-button",
+        className: "secondary",
+        text: HOME_TEXTS.install,
+    });
+    installButton.type = "button";
+    installButton.addEventListener("click", () => options.install());
+    const later = element(install, "button", { id: "install-later", className: "icon-button" });
+    later.type = "button";
+    later.append(icon("close"));
+    later.setAttribute("aria-label", HOME_TEXTS.installLater);
+    later.title = HOME_TEXTS.installLater;
+    later.addEventListener("click", () => options.dismissInstall());
+
+    const rules = element(main, "a", { id: "home-rules", className: "card home-rules" });
+    const rulesText = element(rules, "span", { className: "home-rules-text" });
+    element(rulesText, "strong", { text: HOME_TEXTS.rulesTitle });
+    element(rulesText, "span", { className: "muted", text: HOME_TEXTS.rulesDetail });
+    const rulesAction = element(rules, "span", { className: "pill" });
+
+    const progress = element(main, "p", {
+        id: "home-progress",
+        className: "caption home-progress",
+    });
+    const footer = element(main, "footer", { className: "home-footer" });
+    const footerSymbol = element(footer, "img");
+    footerSymbol.src = "icons/symbole-couleur.svg";
+    footerSymbol.alt = "";
+    element(footer, "span", { text: HOME_TEXTS.footer });
+
+    return {
+        render(state) {
+            const { model } = state;
+            welcome.hidden = !model.welcome;
+            main.hidden = model.welcome;
+            if (model.welcome) {
+                drawBoard(welcomeBoard, OPENING_BOARDS, welcomeBoard.clientWidth || 360);
+                return;
+            }
+            const sides = state.sides ?? OPENING_BOARDS;
+            drawBoard(mini, sides, miniBox.clientWidth || 132);
+            gameOverline.textContent = model.resume
+                ? HOME_TEXTS.gameOverline
+                : HOME_TEXTS.noGameOverline;
+            pips.textContent = HOME_TEXTS.homePips(sides.player.pipCount, sides.computer.pipCount);
+            // Une seule action principale : « Reprendre la partie », ou
+            // « Nouvelle partie » quand il n'y a rien à reprendre.
+            resume.hidden = !model.resume;
+            fresh.textContent = TEXTS.newGame;
+            fresh.classList.toggle("secondary", model.resume);
+            fresh.disabled = state.busy;
+            install.hidden = !model.installCard;
+
+            const seen = state.tutorialSeen;
+            rules.href = seen > 0 && seen < TUTORIAL_DONE ? `#/tutoriel/${seen}` : "#/tutoriel/1";
+            rulesAction.textContent =
+                seen === 0
+                    ? HOME_TEXTS.rulesStart
+                    : seen >= TUTORIAL_DONE
+                      ? HOME_TEXTS.rulesAgain
+                      : HOME_TEXTS.rulesContinue(seen);
+            progress.textContent =
+                state.progress === null || state.progress.played === 0
+                    ? ""
+                    : HOME_TEXTS.progress(state.progress.played, state.progress.won);
+        },
+    };
+}

app/src/ui/icons.ts

@@ -0,0 +1,48 @@
+// Les pictogrammes de l'interface (composant Icons de la charte,
+// docs/identite/charte/interaction.md) : traits de 2 px à bouts ronds, en
+// currentColor, dessinés en SVG. Les tracés viennent des maquettes
+// « Révision UX » (repère 24 × 24). Couleur et épaisseur passent par la
+// classe « icon » (app.css) : aucun style dans le SVG (CSP).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+export const ICON_PATHS = {
+    menu: "M4 7h16M4 12h16M4 17h16",
+    help: "M12 21a9 9 0 1 0 0-18a9 9 0 0 0 0 18zM9.5 9.3a2.6 2.6 0 1 1 3.6 2.4c-.7.3-1.1.9-1.1 1.6v.6M12 17.2v.1",
+    fullscreen: "M4 9V4h5M15 4h5v5M20 15v5h-5M9 20H4v-5",
+    exitFullscreen: "M9 4v5H4M20 9h-5V4M15 20v-5h5M4 15h5v5",
+    undo: "M9 14L4 9l5-5M4 9h10a6 6 0 0 1 0 12h-3",
+    replay: "M20 12a8 8 0 1 1-2.34-5.66M20 4v5h-5",
+    close: "M6 6l12 12M18 6L6 18",
+    chevron: "M9 6l6 6-6 6",
+    copy: "M9 9h11v11H9zM5 15H4V4h11v1",
+    newGame: "M12 5v14M5 12h14",
+    games: "M9 6h11M9 12h11M9 18h11M4 6h.01M4 12h.01M4 18h.01",
+    vibrate: "M9 5h6v14H9zM5 8v8M19 8v8M2 10v4M22 10v4",
+    theme: "M12 21a9 9 0 1 0 0-18zM12 3a9 9 0 0 1 0 18",
+    screenOn: "M7 3h10v18H7zM11 18h2",
+    home: "M4 11l8-7 8 7M6 9.5V20h12V9.5M10 20v-6h4v6",
+    rules: "M4 5h6a2 2 0 0 1 2 2v13a2 2 0 0 0-2-2H4zM20 5h-6a2 2 0 0 0-2 2v13a2 2 0 0 1 2-2h6z",
+    install: "M12 4v11M7 10l5 5 5-5M5 20h14",
+    verdictGood: "M12 21a9 9 0 1 0 0-18a9 9 0 0 0 0 18zM8 12.5l3 3 5-6",
+    verdictDoubtful:
+        "M12 21a9 9 0 1 0 0-18a9 9 0 0 0 0 18zM9.5 9.3a2.6 2.6 0 1 1 3.6 2.4c-.7.3-1.1.9-1.1 1.6v.6M12 17.2v.1",
+    verdictBad: "M12 21a9 9 0 1 0 0-18a9 9 0 0 0 0 18zM9 9l6 6M15 9l-6 6",
+} as const;
+
+export type IconName = keyof typeof ICON_PATHS;
+
+const SVG_NS = "http://www.w3.org/2000/svg";
+
+/** Un pictogramme, décoratif (le nom est porté par son bouton). */
+export function icon(name: IconName): SVGSVGElement {
+    const svg = document.createElementNS(SVG_NS, "svg");
+    svg.setAttribute("class", `icon icon-${name}`);
+    svg.setAttribute("viewBox", "0 0 24 24");
+    svg.setAttribute("aria-hidden", "true");
+    const path = document.createElementNS(SVG_NS, "path");
+    path.setAttribute("d", ICON_PATHS[name]);
+    svg.append(path);
+    return svg;
+}

app/src/ui/install.ts

@@ -0,0 +1,82 @@
+// L'installation de l'application (docs/identite/charte/accueil-tutoriel-
+// aide.md, « Installation ») : l'invite du système quand le navigateur en
+// donne une (Chrome, événement beforeinstallprompt), sinon une marche à
+// suivre en trois étapes (Firefox, iPhone). Plus rien une fois
+// l'application installée.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+/** La marche à suivre à montrer quand le navigateur n'a pas d'invite. */
+export type InstallPlatform = "ios" | "firefox";
+
+/** D'après le navigateur : l'iPhone (et l'iPad) a sa propre marche à
+ * suivre ; les autres suivent celle de Firefox (menu ⋮, « Installer »). */
+export function installPlatform(userAgent: string): InstallPlatform {
+    return /iPhone|iPad|iPod/.test(userAgent) ? "ios" : "firefox";
+}
+
+/** L'événement beforeinstallprompt de Chrome (absent des types du DOM). */
+interface InstallPromptEvent extends Event {
+    readonly prompt: () => Promise<void>;
+    readonly userChoice: Promise<{ outcome: "accepted" | "dismissed" }>;
+}
+
+export interface Installer {
+    /** L'application tourne installée, ou vient de l'être. */
+    readonly installed: boolean;
+    /** Le navigateur a donné son invite d'installation. */
+    readonly canPrompt: boolean;
+    /** Ouvre l'invite du système ; « unavailable » s'il n'y en a pas. */
+    offer(): Promise<"accepted" | "dismissed" | "unavailable">;
+}
+
+/**
+ * Écoute le navigateur : garde l'invite reçue avec beforeinstallprompt (et
+ * empêche le navigateur de l'afficher de lui-même), et note l'installation
+ * (display-mode: standalone, événement appinstalled). onChange est appelé à
+ * chaque changement.
+ */
+export function startInstaller(onChange: (installedNow: boolean) => void): Installer {
+    const standalone = window.matchMedia("(display-mode: standalone)");
+    let installedNow = false;
+    let deferred: InstallPromptEvent | null = null;
+
+    window.addEventListener("beforeinstallprompt", (event) => {
+        event.preventDefault();
+        deferred = event as InstallPromptEvent;
+        onChange(false);
+    });
+    window.addEventListener("appinstalled", () => {
+        installedNow = true;
+        deferred = null;
+        onChange(true);
+    });
+    standalone.addEventListener("change", () => onChange(false));
+
+    return {
+        get installed() {
+            return installedNow || standalone.matches;
+        },
+        get canPrompt() {
+            return deferred !== null;
+        },
+        async offer() {
+            const event = deferred;
+            if (event === null) {
+                return "unavailable";
+            }
+            // Une invite ne sert qu'une fois.
+            deferred = null;
+            try {
+                await event.prompt();
+                const choice = await event.userChoice;
+                return choice.outcome;
+            } catch {
+                return "unavailable";
+            } finally {
+                onChange(false);
+            }
+        },
+    };
+}

app/src/ui/navigation.ts

@@ -0,0 +1,166 @@
+// La navigation entre les écrans : l'adresse de la page est la source de
+// vérité (ADR 0013, amendement du 2026-11-03). On change d'écran par de
+// vrais liens (<a href="#/aide">) ; l'application écoute hashchange et
+// dessine l'écran que désigne l'adresse.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Pour que « Retour », Échap ou la croix d'une feuille reviennent à l'écran
+// d'avant sans empiler d'adresse (le bouton retour du téléphone ne doit pas
+// rouvrir ce qu'on vient de fermer), chaque entrée de l'historique de
+// l'onglet garde, dans history.state, la suite des adresses visitées
+// jusqu'à elle. Elle survit au rechargement de la page.
+
+import { parseRoute, type Route, stepsBack } from "./router.js";
+
+/** Au plus autant d'adresses gardées par entrée de l'historique. */
+const TRAIL_MAX = 50;
+
+export interface Navigation {
+    /** L'écran que désigne l'adresse actuelle. */
+    readonly route: Route;
+    /** Va à une adresse, comme un lien (empile une entrée). */
+    go(hash: string): void;
+    /** Remplace l'adresse actuelle, sans empiler. */
+    replace(hash: string): void;
+    /** Quitte l'écran courant : revient à la dernière adresse de l'onglet
+     * qui ne vérifie pas stay, ou, s'il n'y en a pas (lien ouvert dans un
+     * nouvel onglet), remplace l'adresse par celle de la partie. */
+    leave(stay: (route: Route) => boolean): void;
+}
+
+interface TrailState {
+    readonly ustagammonTrail: readonly string[];
+}
+
+function trailOf(state: unknown): readonly string[] | null {
+    const trail = (state as Partial<TrailState> | null)?.ustagammonTrail;
+    return Array.isArray(trail) ? trail : null;
+}
+
+/** Le fragment actuel, « #/ » s'il est vide. */
+function currentHash(): string {
+    return location.hash === "" || location.hash === "#" ? "#/" : location.hash;
+}
+
+/**
+ * Branche la navigation sur la page : onChange est appelé à chaque
+ * changement d'adresse (pas au démarrage : l'appelant lit route).
+ */
+export function startNavigation(onChange: (route: Route) => void): Navigation {
+    let trail: readonly string[] = [];
+    // Un retour dans l'historique est en cours (history.go est asynchrone) :
+    // une adresse demandée entre-temps attend son arrivée.
+    let leaving: ReturnType<typeof setTimeout> | null = null;
+    let queued: string | null = null;
+
+    const remember = (next: readonly string[]) => {
+        trail = next.slice(-TRAIL_MAX);
+        try {
+            history.replaceState({ ...(history.state ?? {}), ustagammonTrail: trail }, "");
+        } catch {
+            // Historique indisponible (page dans un cadre) : la navigation
+            // marche quand même, « Retour » ramène alors à la partie.
+        }
+    };
+
+    // L'entrée actuelle : déjà connue (rechargement), ou la première.
+    const known = trailOf(history.state);
+    remember(known !== null && known.at(-1) === currentHash() ? known : [currentHash()]);
+
+    window.addEventListener("hashchange", () => {
+        const hash = currentHash();
+        const saved = trailOf(history.state);
+        if (saved !== null && saved.at(-1) === hash) {
+            // Retour ou avance dans l'historique : une entrée déjà connue.
+            trail = saved;
+        } else {
+            // Un lien suivi : une nouvelle entrée.
+            remember([...trail, hash]);
+        }
+        onChange(parseRoute(hash));
+        if (leaving !== null) {
+            clearTimeout(leaving);
+            leaving = null;
+            const next = queued;
+            queued = null;
+            if (next !== null) {
+                go(next);
+            }
+        }
+    });
+
+    function go(hash: string): void {
+        if (leaving !== null) {
+            queued = hash;
+        } else if (hash !== currentHash()) {
+            location.hash = hash;
+        }
+    }
+
+    function replace(hash: string): void {
+        if (hash === currentHash()) {
+            return;
+        }
+        const url = new URL(location.href);
+        url.hash = hash;
+        const next = [...trail.slice(0, -1), hash];
+        try {
+            history.replaceState({ ...(history.state ?? {}), ustagammonTrail: next }, "", url);
+        } catch {
+            location.replace(url);
+            return;
+        }
+        trail = next;
+        // replaceState ne déclenche pas hashchange.
+        onChange(parseRoute(hash));
+    }
+
+    return {
+        get route() {
+            return parseRoute(currentHash());
+        },
+        go,
+        replace,
+        leave(stay) {
+            if (leaving !== null) {
+                return; // déjà en route
+            }
+            const steps = stepsBack(trail, stay);
+            if (steps === null) {
+                replace("#/");
+                return;
+            }
+            // Au cas où le navigateur ne reviendrait pas (historique
+            // indisponible), on n'attend pas plus d'une seconde.
+            leaving = setTimeout(() => {
+                leaving = null;
+                queued = null;
+            }, 1000);
+            history.go(steps);
+        },
+    };
+}
+
+/**
+ * Un lien qui remplace l'adresse au lieu d'en empiler une (les liens d'une
+ * feuille, comme le menu : le retour du téléphone ne rouvre pas la feuille
+ * fermée en suivant le lien). Ouvert dans un nouvel onglet, avec le bouton
+ * du milieu ou une touche, il reste un lien ordinaire.
+ */
+export function replacingLink(link: HTMLAnchorElement, navigation: Navigation): void {
+    link.addEventListener("click", (event) => {
+        if (
+            event.button !== 0 ||
+            event.ctrlKey ||
+            event.metaKey ||
+            event.shiftKey ||
+            event.altKey
+        ) {
+            return;
+        }
+        event.preventDefault();
+        navigation.replace(new URL(link.href).hash);
+    });
+}

app/src/ui/router.ts

@@ -0,0 +1,218 @@
+// Les adresses des écrans (ADR 0013, amendement du 2026-11-03) : chaque
+// écran a la sienne, dans le fragment de l'adresse (après #). Ce module
+// traduit un fragment en écran et un écran en fragment ; fonctions pures,
+// testées sous Node (app/tests/router.test.ts).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+/** Un écran de l'application, tel que le désigne son adresse. */
+export type Route =
+    /** #/ : la partie en cours. */
+    | { readonly screen: "game" }
+    /** #/accueil. */
+    | { readonly screen: "home" }
+    /** #/aide, et une question ouverte : #/aide/<identifiant>. */
+    | { readonly screen: "help"; readonly question: string | null }
+    /** #/glossaire, et un terme : #/glossaire/<fiche sans .md>. */
+    | { readonly screen: "glossary"; readonly term: string | null }
+    /** #/a-propos. */
+    | { readonly screen: "about" }
+    /** #/tutoriel, une étape : #/tutoriel/<n>, et son écran « à vous » :
+     * #/tutoriel/<n>/a-vous. */
+    | { readonly screen: "tutorial"; readonly step: number | null; readonly practice: boolean }
+    /** #/tutoriel/fin : la fin du tutoriel. */
+    | { readonly screen: "tutorialEnd" }
+    /** #/installer : la marche à suivre pour installer l'application. */
+    | { readonly screen: "install" }
+    /** #/parties, et une partie : #/parties/<identifiant>. */
+    | { readonly screen: "games"; readonly game: string | null }
+    /** #/menu. */
+    | { readonly screen: "menu" }
+    /** #/position/<Position ID>/<Match ID> (Match ID facultatif). */
+    | { readonly screen: "position"; readonly position: string; readonly match: string | null }
+    /** Une adresse que l'application ne connaît pas. */
+    | { readonly screen: "unknown"; readonly hash: string };
+
+export type Screen = Route["screen"];
+
+export const GAME_ROUTE: Route = { screen: "game" };
+
+/** Longueur d'un Position ID de gnubg. */
+const POSITION_ID_LENGTH = 14;
+
+/** Un identifiant d'écran (question, terme, partie) : lettres minuscules,
+ * chiffres et tirets. */
+const NAME = /^[a-z0-9][a-z0-9-]*$/;
+
+/** L'écran que désigne un fragment (avec ou sans # au début). */
+export function parseRoute(hash: string): Route {
+    const fragment = hash.startsWith("#") ? hash.slice(1) : hash;
+    if (fragment === "" || fragment === "/") {
+        return GAME_ROUTE;
+    }
+    const unknown: Route = { screen: "unknown", hash: `#${fragment}` };
+    if (!fragment.startsWith("/")) {
+        return unknown;
+    }
+    const [head = "", ...rest] = fragment.slice(1).split("/");
+    // Une barre finale (#/aide/) ne change rien.
+    if (rest.at(-1) === "") {
+        rest.pop();
+    }
+    if (head === "position") {
+        return positionRoute(rest.join("/")) ?? unknown;
+    }
+    if (head === "tutoriel") {
+        return tutorialRoute(rest) ?? unknown;
+    }
+    if (rest.length > 1) {
+        return unknown;
+    }
+    const name = rest[0] ?? null;
+    if (name !== null && !NAME.test(name)) {
+        return unknown;
+    }
+    switch (head) {
+        case "":
+            return name === null ? GAME_ROUTE : unknown;
+        case "accueil":
+            return name === null ? { screen: "home" } : unknown;
+        case "aide":
+            return { screen: "help", question: name };
+        case "glossaire":
+            return { screen: "glossary", term: name };
+        case "a-propos":
+            return name === null ? { screen: "about" } : unknown;
+        case "menu":
+            return name === null ? { screen: "menu" } : unknown;
+        case "parties":
+            return { screen: "games", game: name };
+        case "installer":
+            return name === null ? { screen: "install" } : unknown;
+        default:
+            return unknown;
+    }
+}
+
+/** #/tutoriel, #/tutoriel/<n>, #/tutoriel/<n>/a-vous, #/tutoriel/fin. */
+function tutorialRoute(rest: readonly string[]): Route | null {
+    const [name, part, ...more] = rest;
+    if (name === undefined) {
+        return { screen: "tutorial", step: null, practice: false };
+    }
+    if (more.length > 0) {
+        return null;
+    }
+    if (name === "fin") {
+        return part === undefined ? { screen: "tutorialEnd" } : null;
+    }
+    if (!/^[1-9][0-9]?$/.test(name) || (part !== undefined && part !== "a-vous")) {
+        return null;
+    }
+    return { screen: "tutorial", step: Number(name), practice: part === "a-vous" };
+}
+
+/**
+ * #/position/... : le Position ID (14 caractères), puis, après une barre, le
+ * Match ID. Chaque identifiant est encodé avec encodeURIComponent, mais une
+ * adresse collée telle quelle (le base64 de gnubg contient + et /) est
+ * comprise aussi : le texte est décodé en entier, puis découpé à la
+ * longueur du Position ID. Leur validité est l'affaire du moteur.
+ */
+function positionRoute(text: string): Route | null {
+    let decoded: string;
+    try {
+        decoded = decodeURIComponent(text);
+    } catch {
+        return null;
+    }
+    if (decoded === "") {
+        return null;
+    }
+    if (decoded.length > POSITION_ID_LENGTH && decoded[POSITION_ID_LENGTH] === "/") {
+        const match = decoded.slice(POSITION_ID_LENGTH + 1);
+        return {
+            screen: "position",
+            position: decoded.slice(0, POSITION_ID_LENGTH),
+            match: match === "" ? null : match,
+        };
+    }
+    return { screen: "position", position: decoded, match: null };
+}
+
+/** Le fragment d'un écran, # compris. */
+export function routeHash(route: Route): string {
+    switch (route.screen) {
+        case "game":
+            return "#/";
+        case "home":
+            return "#/accueil";
+        case "help":
+            return route.question === null ? "#/aide" : `#/aide/${route.question}`;
+        case "glossary":
+            return route.term === null ? "#/glossaire" : `#/glossaire/${route.term}`;
+        case "about":
+            return "#/a-propos";
+        case "tutorial":
+            return route.step === null
+                ? "#/tutoriel"
+                : `#/tutoriel/${route.step}${route.practice ? "/a-vous" : ""}`;
+        case "tutorialEnd":
+            return "#/tutoriel/fin";
+        case "install":
+            return "#/installer";
+        case "games":
+            return route.game === null ? "#/parties" : `#/parties/${route.game}`;
+        case "menu":
+            return "#/menu";
+        case "position": {
+            const position = `#/position/${encodeURIComponent(route.position)}`;
+            return route.match === null
+                ? position
+                : `${position}/${encodeURIComponent(route.match)}`;
+        }
+        case "unknown":
+            return route.hash;
+    }
+}
+
+/** Les écrans de l'aide : on passe de l'un à l'autre par ses onglets. */
+export type HelpRoute = Extract<Route, { screen: "help" | "glossary" | "about" }>;
+
+/** L'adresse est-elle celle d'un écran de l'aide ? */
+export function isHelpScreen(route: Route): route is HelpRoute {
+    return route.screen === "help" || route.screen === "glossary" || route.screen === "about";
+}
+
+/** L'identifiant d'une question de l'aide : son titre, en minuscules sans
+ * accents, les mots séparés par des tirets. */
+export function slug(title: string): string {
+    return title
+        .normalize("NFD")
+        .replace(/[̀-ͯ]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+
+/**
+ * Où revenir en quittant un écran (« Retour », Échap, la croix d'une
+ * feuille) : la dernière adresse de l'historique de l'onglet qui n'est pas
+ * de cet écran. trail est la suite des adresses de l'onglet jusqu'à
+ * l'actuelle (comprise). Renvoie le nombre de pas à reculer (négatif), ou
+ * null si aucune adresse ne convient : il faut alors remplacer l'adresse
+ * par celle de la partie, sans rien empiler.
+ */
+export function stepsBack(
+    trail: readonly string[],
+    stay: (route: Route) => boolean,
+): number | null {
+    for (let i = trail.length - 2; i >= 0; i--) {
+        const hash = trail[i];
+        if (hash !== undefined && !stay(parseRoute(hash))) {
+            return i - (trail.length - 1);
+        }
+    }
+    return null;
+}

app/src/ui/settings.ts

@@ -0,0 +1,146 @@
+// Les réglages de l'application (menu) et ce qui en dépend, sans navigateur
+// (testé sous Node). Ils sont enregistrés à part de la partie, en JSON.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Format durable (ADR 0007, amendement du 2026-11-03) : un champ ajouté a
+// toujours une valeur par défaut, et un réglage enregistré par une version
+// précédente se relit sans perte.
+
+export type Theme = "auto" | "light" | "dark";
+
+export interface Settings {
+    /** Vibrations aux moments forts (activées par défaut). */
+    readonly vibrations: boolean;
+    /** Écran maintenu allumé pendant une partie (activé par défaut). */
+    readonly keepScreenOn: boolean;
+    readonly theme: Theme;
+    /** Parties commencées : la consigne est longue pendant les trois
+     * premières, courte ensuite. */
+    readonly gamesStarted: number;
+    /** Parties terminées (l'invitation à installer vient après la
+     * première). */
+    readonly gamesFinished: number;
+    /** Le choix du premier lancement (« Je découvre », « Je connais les
+     * règles ») a été fait : il ne revient plus. */
+    readonly welcomed: boolean;
+    /** La dernière étape du tutoriel déjà vue (0 : aucune ; TUTORIAL_DONE :
+     * la fin). La barre de progression ne mène qu'aux étapes vues. */
+    readonly tutorialSeen: number;
+    /** Combien de fois « Plus tard » a masqué l'invitation à installer, et
+     * le nombre de parties terminées à la dernière fois. */
+    readonly installDismissals: number;
+    readonly installDismissedAt: number;
+    /** L'application a été installée (événement appinstalled). */
+    readonly installed: boolean;
+}
+
+export const DEFAULT_SETTINGS: Settings = {
+    vibrations: true,
+    keepScreenOn: true,
+    theme: "auto",
+    gamesStarted: 0,
+    gamesFinished: 0,
+    welcomed: false,
+    tutorialSeen: 0,
+    installDismissals: 0,
+    installDismissedAt: 0,
+    installed: false,
+};
+
+/** Nombre de parties pendant lesquelles la consigne garde sa forme longue. */
+export const LONG_PROMPT_GAMES = 3;
+
+/** tutorialSeen quand la fin du tutoriel a été vue. */
+export const TUTORIAL_DONE = 99;
+
+/** Parties terminées de plus avant que l'invitation à installer, masquée
+ * par « Plus tard », revienne (une seule fois). */
+export const INSTALL_AGAIN_AFTER = 3;
+
+/** Les réglages lus (JSON), complétés par les valeurs par défaut ; une
+ * valeur illisible garde sa valeur par défaut. */
+export function parseSettings(text: string | null): Settings {
+    let raw: Record<string, unknown> = {};
+    try {
+        const parsed: unknown = JSON.parse(text ?? "{}");
+        if (parsed !== null && typeof parsed === "object") {
+            raw = parsed as Record<string, unknown>;
+        }
+    } catch {
+        // Réglages illisibles : valeurs par défaut.
+    }
+    const bool = (key: "vibrations" | "keepScreenOn" | "welcomed" | "installed") =>
+        typeof raw[key] === "boolean" ? (raw[key] as boolean) : DEFAULT_SETTINGS[key];
+    const count = (
+        key:
+            | "gamesStarted"
+            | "gamesFinished"
+            | "tutorialSeen"
+            | "installDismissals"
+            | "installDismissedAt",
+    ) => {
+        const value = raw[key];
+        return typeof value === "number" && Number.isInteger(value) && value >= 0
+            ? value
+            : DEFAULT_SETTINGS[key];
+    };
+    const theme = raw.theme === "light" || raw.theme === "dark" ? raw.theme : "auto";
+    return {
+        vibrations: bool("vibrations"),
+        keepScreenOn: bool("keepScreenOn"),
+        theme,
+        gamesStarted: count("gamesStarted"),
+        gamesFinished: count("gamesFinished"),
+        welcomed: bool("welcomed"),
+        tutorialSeen: count("tutorialSeen"),
+        installDismissals: count("installDismissals"),
+        installDismissedAt: count("installDismissedAt"),
+        installed: bool("installed"),
+    };
+}
+
+/** Le thème suivant, dans l'ordre du menu : automatique, clair, sombre. */
+export function nextTheme(theme: Theme): Theme {
+    return theme === "auto" ? "light" : theme === "light" ? "dark" : "auto";
+}
+
+/** La consigne doit-elle encore être longue ? (La partie en cours compte.) */
+export function longPrompts(settings: Settings): boolean {
+    return settings.gamesStarted <= LONG_PROMPT_GAMES;
+}
+
+/**
+ * Premier lancement : rien n'a encore été fait dans l'application (le choix
+ * d'accueil, une partie terminée, une étape du tutoriel). La partie
+ * commencée d'office au chargement compte pour une : jusqu'à une partie
+ * commencée, c'est encore le premier lancement.
+ */
+export function isFirstLaunch(settings: Settings): boolean {
+    return (
+        !settings.welcomed &&
+        settings.gamesStarted <= 1 &&
+        settings.gamesFinished === 0 &&
+        settings.tutorialSeen === 0
+    );
+}
+
+/**
+ * L'accueil montre-t-il l'invitation à installer ? Jamais une fois
+ * l'application installée ; à partir de la première partie terminée ;
+ * « Plus tard » la masque, et elle ne revient qu'une fois, après
+ * INSTALL_AGAIN_AFTER parties terminées de plus.
+ */
+export function installCardShown(settings: Settings, installed: boolean): boolean {
+    if (installed || settings.installed || settings.gamesFinished < 1) {
+        return false;
+    }
+    if (settings.installDismissals === 0) {
+        return true;
+    }
+    return (
+        settings.installDismissals === 1 &&
+        settings.gamesFinished >= settings.installDismissedAt + INSTALL_AGAIN_AFTER
+    );
+}

app/src/ui/texts.ts

@@ -22,9 +22,11 @@ function points(n: number): string {
     return n > 1 ? `${n} points` : `${n} point`;
 }
 
-/** Une durée en secondes, avec une décimale : « 0,3 s ». */
-function seconds(ms: number): string {
-    return `${(ms / 1000).toFixed(1).replace(".", ",")} s`;
+/** Une consigne : sa forme longue (les trois premières parties) et sa forme
+ * courte (ensuite, et toujours en paysage, dans la bande du plateau). */
+export interface PromptText {
+    readonly long: string;
+    readonly short: string;
 }
 
 export const TEXTS = {
@@ -36,62 +38,171 @@ export const TEXTS = {
     double: "Doubler",
     take: "Prendre",
     drop: "Passer",
-    confirm: "Valider",
+    confirm: "Jouer ce coup",
     cancel: "Annuler",
     skip: "Continuer",
-    replay: "Revoir",
     replayTitle: "Revoir le dernier coup de l'ordinateur",
+    undoTitle: "Annuler le demi-coup",
     newGame: "Nouvelle partie",
+    reviewGame: "Revoir la partie",
     help: "Aide",
+    menu: "Menu",
+    fullscreen: "Plein écran",
+    exitFullscreen: "Quitter le plein écran",
     back: "Retour à la partie",
+    close: "Fermer",
+    /** Ce que fait un toucher sur les dés (nom accessible de la zone). */
+    diceActions: {
+        roll: "Lancer les dés",
+        confirm: "Jouer ce coup",
+        skip: "Passer votre tour",
+    },
+    moveHint: "Le coup fini, touchez les dés pour le jouer.",
+
+    // Menu
+    helpAndGlossary: "Aide et glossaire",
+    theme: "Thème",
+    themes: { auto: "Automatique", light: "Clair", dark: "Sombre" },
+    vibrations: "Vibrations",
+    keepScreenOn: "Écran allumé pendant la partie",
+    newGameStarted: "Nouvelle partie commencée.",
+    resumeOld: "Reprendre l'ancienne",
+
+    // Bandeaux des joueurs et compte de points
+    you: "Vous",
+    computer: "Ordinateur",
+    yourTurn: "à vous de jouer",
+    computerTurn: "joue",
+    lead: (n: number) => `mène de ${n}`,
+    pipCountButton: (who: string, n: number) => `Compte de points de ${who} : ${n}`,
+    pipCountFile: "compte-de-points.md",
+    seeGlossary: "Voir le glossaire",
 
     // Chargement
     loading: "Chargement du moteur…",
     engineFailed: (message: string) => `Le moteur n'a pas pu se charger : ${message}`,
     actionFailed: (message: string) => `Erreur : ${message}`,
-    confirmNewGame: "Abandonner la partie en cours et en commencer une nouvelle ?",
 
-    // Déroulement
+    // Déroulement (ligne d'information)
     opening: (player: number, computer: number) =>
         `Jet d'ouverture : vous ${player}, l'ordinateur ${computer}. ${
             player > computer ? "Vous commencez." : "L'ordinateur commence."
         }`,
-    yourRoll: "À vous : doublez ou lancez les dés.",
-    yourRollNoDouble: "À vous : lancez les dés.",
-    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…",
-    computerMoved: (dice: readonly number[], move: string, ms: number) =>
-        `L'ordinateur a joué ${roll(dice)} : ${move} (${seconds(ms)}).`,
+    computerMoved: (dice: readonly number[], move: string) =>
+        `L'ordinateur a joué ${roll(dice)} : ${move}.`,
     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)}.`,
     youTook: (value: number) =>
         `Vous prenez : la partie vaut maintenant ${points(value)}, et le videau est chez vous.`,
+    confirmDouble: (value: number) => `Doubler à ${value} ? L'ordinateur pourra prendre ou passer.`,
+
+    // Consignes
+    prompts: {
+        loading: { long: "", short: "Chargement…" },
+        yourRoll: {
+            long: "À vous : touchez les dés pour les lancer, ou le videau pour doubler.",
+            short: "À vous : lancez les dés.",
+        },
+        yourRollNoDouble: {
+            long: "À vous : touchez les dés pour les lancer.",
+            short: "À vous : lancez les dés.",
+        },
+        yourMove: (dice: readonly number[]): PromptText => ({
+            long: `Jouez ${roll(dice)} : touchez un pion, puis sa case d'arrivée.`,
+            short: `Jouez ${roll(dice)}.`,
+        }),
+        pickTarget: {
+            long: "Touchez une case d'arrivée en surbrillance, ou un autre pion.",
+            short: "Choisissez la case.",
+        },
+        confirmOrUndo: {
+            long: "Touchez vos dés pour jouer ce coup, ou « Annuler » pour reprendre un pion.",
+            short: "Touchez les dés pour jouer.",
+        },
+        stuck: {
+            long: "Aucun coup possible : touchez vos dés pour passer votre tour.",
+            short: "Aucun coup : touchez les dés.",
+        },
+        thinking: { long: "L'ordinateur réfléchit", short: "L'ordinateur réfléchit" },
+        computerDoubles: {
+            long: "L'ordinateur vous propose de doubler : prenez ou passez.",
+            short: "L'ordinateur double.",
+        },
+    } satisfies Record<string, PromptText | ((dice: readonly number[]) => PromptText)>,
 
     // Fin de partie
-    youWin: (kind: ResultKind, n: number) => `Vous gagnez ${RESULT_KIND[kind]} : ${points(n)}.`,
-    youLose: (kind: ResultKind, n: number) =>
-        `L'ordinateur gagne ${RESULT_KIND[kind]} : ${points(n)} pour lui.`,
-    computerDropped: (n: number) => `L'ordinateur passe : vous gagnez ${points(n)}.`,
-    youDropped: (n: number) => `Vous passez : l'ordinateur gagne ${points(n)}.`,
-
-    // Sous le plateau
-    pipCounts: (player: number, computer: number) =>
-        `Compte de points : vous ${player}, l'ordinateur ${computer}`,
+    gameOver: "Partie finie",
+    endOverline: "Fin de partie",
+    /** Titre du panneau de fin : qui gagne, et comment. */
+    endTitle: (winner: "player" | "computer", kind: ResultKind, dropped: boolean) => {
+        if (dropped) {
+            return winner === "player" ? "L'ordinateur passe" : "Vous passez";
+        }
+        return winner === "player"
+            ? `Vous gagnez ${RESULT_KIND[kind]}`
+            : `L'ordinateur gagne ${RESULT_KIND[kind]}`;
+    },
+    /** « 8 points pour lui, videau à 4. » */
+    endDetail: (winner: "player" | "computer", n: number, cube: number) =>
+        `${points(n)} pour ${winner === "player" ? "vous" : "lui"}${
+            cube > 1 ? `, videau à ${cube}` : ""
+        }.`,
 
     // Aide
     helpTitle: "Aide",
-    glossaryTitle: "Glossaire",
+    helpTabs: "Rubriques de l'aide",
+    helpTabNames: { help: "Jouer", glossary: "Les mots du jeu", about: "À propos" },
+    glossaryTitle: "Les mots du jeu",
+    aboutTitle: "À propos",
     helpLoading: "Chargement de l'aide…",
     helpFailed: "L'aide n'a pas pu se charger.",
+    helpNotFound: "Cette page de l'aide n'existe pas, ou plus : voici le sommaire.",
     about: "Ustagammon est un logiciel libre (GPLv3). L'ordinateur joue avec GNU Backgammon.",
+
+    // Adresses (ADR 0013)
+    unknownAddress: "Cette adresse ne mène à aucun écran : voici votre partie.",
+
+    // Lien vers une position (ADR 0013)
+    copyPositionLink: "Copier le lien de la position",
+    linkCopied: "Lien de la position copié.",
+    linkNotCopied: (url: string) => `Copie impossible ; le lien : ${url}`,
+    positionTitle: "Position partagée",
+    unreadablePositionTitle: "Lien illisible",
+    unreadablePosition:
+        "Ce lien ne décrit pas une position que GNU Backgammon sait lire. Il a peut-être été coupé en le copiant.",
+    backToGame: "Retour à ma partie",
+    playFromHere: "Jouer à partir d'ici",
+    startedFromPosition: "Nouvelle partie à partir de la position du lien.",
+    /** Ce que montre la vue d'une position, sous le plateau. */
+    positionDetail: (
+        pips: Readonly<Record<"player" | "computer", number>>,
+        cube: { value: number; owner: "player" | "computer" | null },
+        match: { length: number; score: Readonly<Record<"player" | "computer", number>> } | null,
+        winner: "player" | "computer" | null,
+    ) =>
+        [
+            winner === null
+                ? "Vous avez la main : vos pions ivoire, en bas."
+                : `La partie est finie dans cette position : ${
+                      winner === "player" ? "vous gagnez" : "l'ordinateur gagne"
+                  }.`,
+            `Compte de points : vous ${pips.player}, l'ordinateur ${pips.computer}.`,
+            cube.value > 1 || cube.owner !== null
+                ? `Videau à ${cube.value}, ${
+                      cube.owner === null
+                          ? "au centre"
+                          : cube.owner === "player"
+                            ? "chez vous"
+                            : "chez l'ordinateur"
+                  }.`
+                : "",
+            match === null
+                ? ""
+                : `Match en ${points(match.length)}, ${match.score.player} à ${match.score.computer} : vous le jouerez en partie libre.`,
+        ]
+            .filter((part) => part !== "")
+            .join(" "),
 } as const;

app/src/ui/tutorial-nav.ts

@@ -0,0 +1,96 @@
+// Le parcours du tutoriel : l'écran d'avant, l'écran d'après, et la barre
+// de progression (charte : « les segments sont des liens vers les étapes
+// déjà vues, pas vers les suivantes »). Fonctions pures, testées sous Node.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import type { Route } from "./router.js";
+import { TUTORIAL_DONE } from "./settings.js";
+import type { Tutorial } from "./tutorial-text.js";
+
+/** Un écran du tutoriel : une étape (explication ou « à vous »), ou la fin. */
+export type TutorialPlace = { readonly step: number; readonly practice: boolean } | "end";
+
+/** L'écran que désigne une adresse, ramené à un écran qui existe : une
+ * étape hors du tutoriel mène à la première, un « à vous » absent à
+ * l'explication de son étape. */
+export function placeOf(tutorial: Tutorial, route: Route): TutorialPlace {
+    if (route.screen === "tutorialEnd") {
+        return "end";
+    }
+    if (route.screen !== "tutorial" || route.step === null) {
+        return { step: 1, practice: false };
+    }
+    const step = tutorial.steps[route.step - 1];
+    if (step === undefined) {
+        return { step: 1, practice: false };
+    }
+    return { step: step.number, practice: route.practice && step.practice !== null };
+}
+
+/** L'adresse d'un écran du tutoriel. */
+export function placeRoute(place: TutorialPlace): Route {
+    return place === "end"
+        ? { screen: "tutorialEnd" }
+        : { screen: "tutorial", step: place.step, practice: place.practice };
+}
+
+/** L'écran suivant (la fin après la dernière étape). */
+export function nextPlace(tutorial: Tutorial, place: TutorialPlace): TutorialPlace {
+    if (place === "end") {
+        return "end";
+    }
+    const step = tutorial.steps[place.step - 1];
+    if (!place.practice && step?.practice != null) {
+        return { step: place.step, practice: true };
+    }
+    return place.step >= tutorial.steps.length ? "end" : { step: place.step + 1, practice: false };
+}
+
+/** L'écran précédent (null avant la première étape). */
+export function previousPlace(tutorial: Tutorial, place: TutorialPlace): TutorialPlace | null {
+    if (place === "end") {
+        const last = tutorial.steps.at(-1);
+        return last === undefined ? null : { step: last.number, practice: last.practice !== null };
+    }
+    if (place.practice) {
+        return { step: place.step, practice: false };
+    }
+    const before = tutorial.steps[place.step - 2];
+    return before === undefined
+        ? null
+        : { step: before.number, practice: before.practice !== null };
+}
+
+/** Ce que retient la progression quand on arrive sur un écran : la
+ * dernière étape vue (TUTORIAL_DONE à la fin). */
+export function seenAfter(seen: number, place: TutorialPlace): number {
+    return place === "end" ? TUTORIAL_DONE : Math.max(seen, place.step);
+}
+
+/** Un segment de la barre de progression. */
+export interface ProgressSegment {
+    readonly step: number;
+    /** Étape faite ou en cours : le segment est en brique. */
+    readonly done: boolean;
+    /** Étape déjà vue : le segment est un lien vers elle. */
+    readonly link: boolean;
+    readonly current: boolean;
+}
+
+/** La barre de progression, sur l'écran place, quand les étapes jusqu'à
+ * seen ont déjà été vues. */
+export function progress(total: number, place: TutorialPlace, seen: number): ProgressSegment[] {
+    const current = place === "end" ? total + 1 : place.step;
+    const reached = Math.max(seen, current);
+    return Array.from({ length: total }, (_, i) => {
+        const step = i + 1;
+        return {
+            step,
+            done: step <= current,
+            link: step <= reached && step !== current,
+            current: step === current,
+        };
+    });
+}

app/src/ui/tutorial-text.ts

@@ -0,0 +1,204 @@
+// Lecture du texte du tutoriel (docs/tutoriel/regles.md, format décrit dans
+// docs/tutoriel/README.md), copié tel quel dans le site par make site
+// (ADR 0008 : une seule source). Fonction pure, testée sous Node.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+/** Un morceau de texte : simple, en gras, ou lien vers une fiche du
+ * glossaire (nom de fichier sans .md). */
+export interface Inline {
+    readonly text: string;
+    readonly strong?: boolean;
+    readonly term?: string;
+}
+
+export type Paragraph = readonly Inline[];
+
+/** Un écran du tutoriel : explication, ou « à vous ». */
+export interface TutorialScreen {
+    /** Identifiant de position de gnubg, vu du camp au trait. */
+    readonly position: string;
+    readonly onRoll: "player" | "computer";
+    /** Le jet du coup illustré (explication) ou à jouer (« à vous »). */
+    readonly roll: readonly [number, number] | null;
+    /** Explication : le coup illustré, en notation de gnubg. */
+    readonly move: string | null;
+    /** Explication : le sens du jeu dessiné en pointillés. */
+    readonly path: boolean;
+    /** « À vous » : les coups justes, en notation de gnubg. */
+    readonly expected: readonly string[];
+    /** « À vous » de videau : la bonne réponse au double. */
+    readonly answer: "take" | "pass" | null;
+    readonly right: Paragraph;
+    readonly wrong: Paragraph;
+    readonly paragraphs: readonly Paragraph[];
+}
+
+export interface TutorialStep {
+    readonly number: number;
+    readonly title: string;
+    readonly explain: TutorialScreen;
+    readonly practice: TutorialScreen | null;
+}
+
+export interface Tutorial {
+    readonly steps: readonly TutorialStep[];
+    readonly end: { readonly action: string; readonly paragraphs: readonly Paragraph[] };
+}
+
+/** Lit les liens [mot](fiche.md) et le **gras** d'une ligne de texte. */
+export function parseInline(text: string): Paragraph {
+    const parts: Inline[] = [];
+    const pattern = /\[([^\]]+)\]\(([a-z0-9-]+)\.md\)|\*\*([^*]+)\*\*/g;
+    let last = 0;
+    for (const match of text.matchAll(pattern)) {
+        const index = match.index ?? 0;
+        if (index > last) {
+            parts.push({ text: text.slice(last, index) });
+        }
+        if (match[1] !== undefined && match[2] !== undefined) {
+            parts.push({ text: match[1], term: match[2] });
+        } else {
+            parts.push({ text: match[3] ?? "", strong: true });
+        }
+        last = index + match[0].length;
+    }
+    if (last < text.length) {
+        parts.push({ text: text.slice(last) });
+    }
+    return parts;
+}
+
+interface RawScreen {
+    keys: Map<string, string[]>;
+    paragraphs: string[];
+}
+
+function emptyScreen(): RawScreen {
+    return { keys: new Map(), paragraphs: [] };
+}
+
+function rollOf(text: string | undefined, where: string): readonly [number, number] | null {
+    if (text === undefined) {
+        return null;
+    }
+    const match = /^([1-6])-([1-6])$/.exec(text);
+    if (match === null) {
+        throw new Error(`${where} : jet illisible « ${text} »`);
+    }
+    return [Number(match[1]), Number(match[2])];
+}
+
+function screenOf(raw: RawScreen, where: string): TutorialScreen {
+    const one = (key: string) => raw.keys.get(key)?.[0];
+    const position = one("position");
+    if (position === undefined) {
+        throw new Error(`${where} : position absente`);
+    }
+    const trait = one("trait");
+    if (trait !== undefined && trait !== "ordinateur" && trait !== "joueur") {
+        throw new Error(`${where} : trait inconnu « ${trait} »`);
+    }
+    const answer = one("réponse");
+    if (answer !== undefined && answer !== "prendre" && answer !== "passer") {
+        throw new Error(`${where} : réponse inconnue « ${answer} »`);
+    }
+    return {
+        position,
+        onRoll: trait === "ordinateur" ? "computer" : "player",
+        roll: rollOf(one("jet"), where),
+        move: one("coup") ?? null,
+        path: one("chemin") === "oui",
+        expected: raw.keys.get("attendu") ?? [],
+        answer: answer === undefined ? null : answer === "prendre" ? "take" : "pass",
+        right: parseInline(one("juste") ?? ""),
+        wrong: parseInline(one("refus") ?? ""),
+        paragraphs: raw.paragraphs.map(parseInline),
+    };
+}
+
+/** Lit le texte du tutoriel. Erreur si un écran est incomplet ou si les
+ * étapes ne se suivent pas. */
+export function parseTutorial(text: string): Tutorial {
+    const steps: {
+        number: number;
+        title: string;
+        explain: RawScreen;
+        practice: RawScreen | null;
+    }[] = [];
+    let end: RawScreen | null = null;
+    let current: RawScreen | null = null;
+    let paragraph: string[] = [];
+
+    const endParagraph = () => {
+        if (paragraph.length > 0 && current !== null) {
+            current.paragraphs.push(paragraph.join(" "));
+        }
+        paragraph = [];
+    };
+
+    for (const raw of text.split("\n")) {
+        const line = raw.trim();
+        const step = /^## (\d+)\. (.+)$/.exec(line);
+        const key = /^- ([a-zéè]+): (.+)$/.exec(line);
+        if (line === "") {
+            endParagraph();
+        } else if (step !== null) {
+            endParagraph();
+            current = emptyScreen();
+            steps.push({
+                number: Number(step[1]),
+                title: step[2] ?? "",
+                explain: current,
+                practice: null,
+            });
+        } else if (line === "## Fin") {
+            endParagraph();
+            current = emptyScreen();
+            end = current;
+        } else if (line === "### À vous") {
+            endParagraph();
+            const last = steps.at(-1);
+            if (last === undefined) {
+                throw new Error("« À vous » hors d'une étape");
+            }
+            current = emptyScreen();
+            last.practice = current;
+        } else if (current === null) {
+            // Notice avant la première étape : non affichée.
+        } else if (key !== null && paragraph.length === 0 && current.paragraphs.length === 0) {
+            const values = current.keys.get(key[1] ?? "") ?? [];
+            values.push((key[2] ?? "").trim());
+            current.keys.set(key[1] ?? "", values);
+        } else {
+            paragraph.push(line);
+        }
+    }
+    endParagraph();
+
+    steps.forEach((step, i) => {
+        if (step.number !== i + 1) {
+            throw new Error(`étape ${step.number} à la place de l'étape ${i + 1}`);
+        }
+    });
+    if (end === null) {
+        throw new Error("écran de fin absent");
+    }
+    const finish: RawScreen = end;
+    return {
+        steps: steps.map((step) => ({
+            number: step.number,
+            title: step.title,
+            explain: screenOf(step.explain, `étape ${step.number}`),
+            practice:
+                step.practice === null
+                    ? null
+                    : screenOf(step.practice, `étape ${step.number}, à vous`),
+        })),
+        end: {
+            action: finish.keys.get("action")?.[0] ?? "",
+            paragraphs: finish.paragraphs.map(parseInline),
+        },
+    };
+}

app/src/ui/tutorial-view.ts

@@ -0,0 +1,734 @@
+// L'écran du tutoriel (#/tutoriel/<n>, #/tutoriel/<n>/a-vous,
+// #/tutoriel/fin) : la barre de progression, le titre, le plateau, le texte,
+// et les écrans « à vous » où le joueur fait le geste sur le vrai plateau
+// (docs/identite/charte/accueil-tutoriel-aide.md, « Tutoriel des règles »).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Le texte vient de docs/tutoriel/regles.md (copie du site) ; les plateaux,
+// les coups illustrés et le jugement des gestes viennent du domaine, branché
+// sur le moteur (TutorialAccess, assemblé dans main.ts). Aucune règle n'est
+// écrite ici.
+
+import type { MoveSteps } from "../domain/game/game.js";
+import type { HalfMove } from "../domain/game/position.js";
+import type { Roll } from "../domain/game/roll.js";
+import type { Side } from "../domain/game/side.js";
+import type { PracticeVerdict, TutorialBoard } from "../domain/learning/tutorial.js";
+import {
+    boardModel,
+    moveTargets,
+    moveTrace,
+    onlyHalfMove,
+    type Place,
+    placeOf as placeOfChecker,
+} from "./board-model.js";
+import {
+    type BoardDecor,
+    checkerSpot,
+    NO_MARKS,
+    renderBoard,
+    type ShownDie,
+    slideChecker,
+} from "./board-view.js";
+import { boardGeometry, columnLeft, type Geometry, PORTRAIT_ASPECT } from "./geometry.js";
+import { HOME_TEXTS } from "./home-texts.js";
+import { icon } from "./icons.js";
+import { type Route, routeHash } from "./router.js";
+import {
+    nextPlace,
+    placeOf,
+    placeRoute,
+    previousPlace,
+    progress,
+    type TutorialPlace,
+} from "./tutorial-nav.js";
+import {
+    type Paragraph,
+    parseTutorial,
+    type Tutorial,
+    type TutorialScreen,
+} from "./tutorial-text.js";
+
+/** Le coup illustré se joue tout seul après une seconde. */
+const AUTOPLAY_MS = 1000;
+const SLIDE_MS = 160;
+const PAUSE_MS = 120;
+/** Un pion refusé reste un instant à sa place avant de revenir. */
+const REFUSED_MS = 450;
+
+const SOURCE = "docs/tutoriel/regles.md";
+
+/** Un écran « à vous » où l'on joue un coup (MovePractice du domaine). */
+export interface PracticeSession {
+    board(): Promise<{
+        player: TutorialBoard["sides"]["player"];
+        computer: TutorialBoard["sides"]["computer"];
+    }>;
+    nextHalfMoves(): Promise<HalfMove[]>;
+    play(halfMove: HalfMove): Promise<PracticeVerdict>;
+    reset(): void;
+    readonly diceToPlay: readonly { value: number; used: boolean }[];
+}
+
+/** Ce que le tutoriel demande au domaine et au moteur. */
+export interface TutorialAccess {
+    board(position: string, onRoll: Side): Promise<TutorialBoard>;
+    illustrate(
+        position: string,
+        roll: Roll,
+        move: string,
+    ): Promise<{ steps: MoveSteps; after: TutorialBoard }>;
+    practice(position: string, roll: Roll, expected: readonly string[]): Promise<PracticeSession>;
+    shouldTake(position: string): Promise<boolean>;
+}
+
+export interface TutorialViewOptions {
+    readonly section: HTMLElement;
+    readonly access: TutorialAccess;
+    readonly engineReady: Promise<unknown>;
+    /** La dernière étape vue, et son enregistrement à l'arrivée sur un
+     * écran. */
+    readonly seen: () => number;
+    readonly visit: (place: TutorialPlace) => void;
+    /** Un geste juste : la vibration « pion posé ». */
+    readonly placed: () => void;
+    readonly reducedMotion: MediaQueryList;
+    /** L'écran est-il en paysage (plateau à gauche, texte à droite) ? */
+    readonly landscape: () => boolean;
+    /** L'adresse a désigné un écran qui n'existe pas : la remplacer. */
+    readonly replace: (hash: string) => void;
+}
+
+export interface TutorialView {
+    show(route: Route): Promise<void>;
+    /** La taille de l'écran a changé : redessiner le plateau. */
+    relayout(): void;
+    /** L'écran est quitté : arrêter le coup illustré. */
+    hide(): void;
+}
+
+function element<K extends keyof HTMLElementTagNameMap>(
+    parent: HTMLElement,
+    tag: K,
+    options: { id?: string; className?: string; text?: string } = {},
+): HTMLElementTagNameMap[K] {
+    const child = document.createElement(tag);
+    if (options.id !== undefined) {
+        child.id = options.id;
+    }
+    if (options.className !== undefined) {
+        child.className = options.className;
+    }
+    if (options.text !== undefined) {
+        child.textContent = options.text;
+    }
+    parent.append(child);
+    return child;
+}
+
+/** Un paragraphe du tutoriel : texte, gras, liens vers le glossaire. */
+export function fillParagraph(target: HTMLElement, paragraph: Paragraph): void {
+    target.replaceChildren();
+    for (const part of paragraph) {
+        if (part.term !== undefined) {
+            const link = document.createElement("a");
+            link.href = routeHash({ screen: "glossary", term: part.term });
+            link.textContent = part.text;
+            target.append(link);
+        } else if (part.strong === true) {
+            const strong = document.createElement("strong");
+            strong.textContent = part.text;
+            target.append(strong);
+        } else {
+            target.append(part.text);
+        }
+    }
+}
+
+const SVG_NS = "http://www.w3.org/2000/svg";
+
+/** Le sens du jeu des pions du joueur, en pointillés : du haut à droite
+ * (flèche 24) vers la gauche, puis en bas jusqu'à la flèche 1 et la sortie.
+ * Tracé sous les pions et sous les numéros des flèches, qu'il ne cache
+ * jamais. pxPerUnit : pixels à l'écran par unité du dessin (le liseré
+ * ivoire fait 8 px, les points 4 px, quelle que soit la taille). */
+function drawPath(svg: SVGSVGElement, g: Geometry, pxPerUnit: number): void {
+    const center = (column: number) => columnLeft(g, column) + g.pointWidth / 2;
+    const top = g.height * 0.3;
+    const bottom = g.height * 0.7;
+    const right = center(11);
+    const left = center(0) - g.pointWidth * 0.25;
+    const turn = g.pointWidth * 0.6;
+    const end = g.trayLeft + g.tray * 0.25;
+    const d =
+        `M ${right} ${top} L ${left + turn} ${top} Q ${left} ${top} ${left} ${top + turn} ` +
+        `L ${left} ${bottom - turn} Q ${left} ${bottom} ${left + turn} ${bottom} L ${end} ${bottom}`;
+    const group = document.createElementNS(SVG_NS, "g");
+    group.setAttribute("class", "tutorial-path");
+    group.setAttribute("role", "img");
+    group.setAttribute("aria-label", HOME_TEXTS.pathLabel);
+    const px = (n: number) => n / pxPerUnit;
+    const width = px(4);
+    for (const [className, stroke] of [
+        ["path-edge", px(8)],
+        ["path-dots", width],
+    ] as const) {
+        const path = document.createElementNS(SVG_NS, "path");
+        path.setAttribute("class", className);
+        path.setAttribute("d", d);
+        path.setAttribute("stroke-width", String(stroke));
+        if (className === "path-dots") {
+            path.setAttribute("stroke-dasharray", `0.1 ${px(10)}`);
+        }
+        group.append(path);
+    }
+    const head = document.createElementNS(SVG_NS, "path");
+    head.setAttribute("class", "path-head");
+    const size = px(7);
+    head.setAttribute(
+        "d",
+        `M ${end - size} ${bottom - size} L ${end} ${bottom} L ${end - size} ${bottom + size}`,
+    );
+    head.setAttribute("stroke-width", String(px(3)));
+    group.append(head);
+    // Sous les pions, et sous les numéros des flèches, remontés au-dessus
+    // du tracé ; les zones à toucher restent devant tout.
+    const pieces = svg.querySelector(":scope > g.pieces");
+    svg.insertBefore(group, pieces);
+    for (const number of svg.querySelectorAll(":scope > .point-number")) {
+        svg.insertBefore(number, pieces);
+    }
+}
+
+/** Crée l'écran du tutoriel dans section (vide dans index.html). */
+export function createTutorialView(options: TutorialViewOptions): TutorialView {
+    const { section, access } = options;
+    section.replaceChildren();
+    const head = element(section, "header", { className: "tutorial-head" });
+    const bar = element(head, "nav", { id: "tutorial-progress", className: "tutorial-progress" });
+    bar.setAttribute("aria-label", HOME_TEXTS.tutorialProgress);
+    const skip = element(head, "a", { id: "tutorial-skip", className: "tutorial-skip" });
+    skip.href = "#/";
+    skip.textContent = HOME_TEXTS.tutorialSkip;
+    skip.setAttribute("aria-label", HOME_TEXTS.tutorialSkipLabel);
+    const overline = element(section, "p", { id: "tutorial-overline", className: "overline" });
+    const title = element(section, "h2", { id: "tutorial-title", className: "tutorial-title" });
+    const boardBox = element(section, "div", { className: "tutorial-board-box" });
+    const svg = document.createElementNS(SVG_NS, "svg");
+    svg.id = "tutorial-board";
+    svg.setAttribute("class", "board tutorial-board");
+    svg.setAttribute("role", "img");
+    boardBox.append(svg);
+    const replay = element(boardBox, "button", { id: "tutorial-replay", className: "icon-button" });
+    replay.type = "button";
+    replay.append(icon("replay"));
+    replay.setAttribute("aria-label", HOME_TEXTS.replayLabel);
+    replay.title = HOME_TEXTS.replayLabel;
+    // Le texte, la consigne « à vous » et la réponse : en paysage, la seule
+    // partie qui défile si l'écran est trop bas (app.css).
+    const body = element(section, "div", { className: "tutorial-body" });
+    const text = element(body, "div", { id: "tutorial-text", className: "tutorial-text" });
+    const task = element(body, "p", { id: "tutorial-task", className: "tutorial-task" });
+    const feedback = element(body, "p", {
+        id: "tutorial-feedback",
+        className: "tutorial-feedback",
+    });
+    feedback.setAttribute("role", "status");
+    const cube = element(section, "div", { id: "tutorial-cube", className: "tutorial-cube" });
+    const drop = element(cube, "button", {
+        id: "tutorial-drop",
+        className: "secondary",
+        text: HOME_TEXTS.drop,
+    });
+    drop.type = "button";
+    const take = element(cube, "button", {
+        id: "tutorial-take",
+        className: "secondary",
+        text: HOME_TEXTS.take,
+    });
+    take.type = "button";
+    const nav = element(section, "div", { className: "tutorial-nav" });
+    const back = element(nav, "a", {
+        id: "tutorial-back",
+        className: "button secondary",
+        text: HOME_TEXTS.back,
+    });
+    const next = element(nav, "a", {
+        id: "tutorial-next",
+        className: "button",
+        text: HOME_TEXTS.next,
+    });
+
+    let tutorial: Promise<Tutorial> | null = null;
+    // Chaque affichage a son numéro : un affichage dépassé ne touche plus
+    // à l'écran (le joueur est déjà ailleurs).
+    let shown = 0;
+    let autoplay: ReturnType<typeof setTimeout> | null = null;
+    // Un coup illustré se joue, ou un geste est jugé : les touchers
+    // attendent (data-busy, pour les tests dans un navigateur).
+    let busy = false;
+    const setBusy = (value: boolean) => {
+        busy = value;
+        section.toggleAttribute("data-busy", value);
+    };
+
+    // L'écran affiché.
+    let screen: TutorialScreen | null = null;
+    let place: TutorialPlace | null = null;
+    let boards: TutorialBoard | null = null;
+    let illustration: { steps: MoveSteps; after: TutorialBoard } | null = null;
+    let illustrated = false;
+    let practice: PracticeSession | null = null;
+    let targets = new Map<Place, Map<Place, HalfMove>>();
+    let selected: Place | null = null;
+    let solved = false;
+
+    const load = () => {
+        tutorial ??= fetch(SOURCE)
+            .then((response) => {
+                if (!response.ok) {
+                    throw new Error(`${SOURCE} : ${response.status}`);
+                }
+                return response.text();
+            })
+            .then(parseTutorial)
+            .catch((error: unknown) => {
+                tutorial = null;
+                throw error;
+            });
+        return tutorial;
+    };
+
+    /** En paysage, le plateau occupe toute la hauteur, à gauche de la
+     * colonne du texte (app.css), avec la géométrie du jeu en paysage. */
+    function geometry(): Geometry {
+        const box = svg.getBoundingClientRect();
+        if (options.landscape()) {
+            const width = box.width || window.innerWidth;
+            const height = box.height || window.innerHeight;
+            return boardGeometry("landscape", width / height, height / 520);
+        }
+        const width = box.width || Math.min(window.innerWidth, 640);
+        return boardGeometry("portrait", PORTRAIT_ASPECT, width / 640);
+    }
+
+    function shownDice(): ShownDie[] {
+        if (practice !== null) {
+            return practice.diceToPlay.map((die) => ({
+                value: die.value,
+                side: "player",
+                blocked: false,
+                used: die.used,
+            }));
+        }
+        const roll = screen?.move != null ? screen.roll : null;
+        if (roll === null || roll === undefined) {
+            return [];
+        }
+        const [a, b] = roll;
+        return [a, b].map((value) => ({
+            value,
+            side: "player" as const,
+            blocked: false,
+            used: false,
+        }));
+    }
+
+    /** Redessine le plateau dans son état courant. */
+    function draw(sides: TutorialBoard["sides"] | null = null): void {
+        const current = sides ?? (illustrated ? illustration?.after.sides : null) ?? boards?.sides;
+        if (current === undefined || current === null) {
+            return;
+        }
+        const g = geometry();
+        const decor: BoardDecor = {
+            ...NO_MARKS,
+            dice: shownDice(),
+            cube: { value: 1, owner: null },
+            band: null,
+            controls: null,
+            movable: practice !== null && !solved && !busy ? new Set(targets.keys()) : new Set(),
+            selected,
+            targets: new Set(selected === null ? [] : (targets.get(selected)?.keys() ?? [])),
+            trace:
+                illustrated && illustration !== null
+                    ? moveTrace("player", illustration.steps.halfMoves, illustration.steps.hits)
+                    : null,
+        };
+        renderBoard(svg, g, boardModel(current), decor);
+        if (screen?.path === true) {
+            drawPath(svg, g, (svg.getBoundingClientRect().width || g.width) / g.width);
+        }
+    }
+
+    function clearTimer(): void {
+        if (autoplay !== null) {
+            clearTimeout(autoplay);
+            autoplay = null;
+        }
+    }
+
+    /** Le coup illustré, pion par pion (160 ms par pion, 120 ms entre deux),
+     * puis ses traces ; sans mouvement si le système le demande. */
+    async function playIllustration(id: number): Promise<void> {
+        const shownMove = illustration;
+        if (shownMove === null || id !== shown) {
+            return;
+        }
+        setBusy(true);
+        replay.disabled = true;
+        illustrated = false;
+        try {
+            if (!options.reducedMotion.matches) {
+                const { steps } = shownMove;
+                for (const [i, halfMove] of steps.halfMoves.entries()) {
+                    if (id !== shown) {
+                        return;
+                    }
+                    if (i > 0) {
+                        await new Promise((resolve) => setTimeout(resolve, PAUSE_MS));
+                    }
+                    const from = placeOfChecker("player", halfMove.from);
+                    const to = placeOfChecker("player", halfMove.to);
+                    draw(steps.boards[i] ?? null);
+                    const start = checkerSpot(svg, from);
+                    const victim = steps.hits[i] === true ? checkerSpot(svg, to) : null;
+                    draw(steps.boards[i + 1] ?? null);
+                    await Promise.all([
+                        start && slideChecker(svg, to, start, SLIDE_MS),
+                        victim && slideChecker(svg, "bar-computer", victim, SLIDE_MS),
+                    ]);
+                }
+            }
+        } finally {
+            if (id === shown) {
+                setBusy(false);
+                illustrated = true;
+                replay.disabled = false;
+                draw();
+                const result = shownMove.after.result;
+                feedback.textContent =
+                    result === null ? "" : HOME_TEXTS.illustratedEnd(result.kind);
+                feedback.dataset.verdict = result === null ? "" : "info";
+            }
+        }
+    }
+
+    async function refreshTargets(): Promise<void> {
+        targets =
+            practice === null || solved ? new Map() : moveTargets(await practice.nextHalfMoves());
+        if (selected !== null && !targets.has(selected)) {
+            selected = null;
+        }
+    }
+
+    function setVerdict(verdict: "right" | "wrong", words: Paragraph): void {
+        feedback.dataset.verdict = verdict;
+        fillParagraph(feedback, words);
+        if (verdict === "right") {
+            feedback.prepend(icon("verdictGood"));
+        }
+    }
+
+    function markSolved(): void {
+        solved = true;
+        section.toggleAttribute("data-solved", true);
+        next.classList.remove("secondary");
+        take.disabled = true;
+        drop.disabled = true;
+        options.placed();
+    }
+
+    async function playHalfMove(halfMove: HalfMove): Promise<void> {
+        const session = practice;
+        const current = screen;
+        if (session === null || current === null || busy || solved) {
+            return;
+        }
+        const id = shown;
+        setBusy(true);
+        selected = null;
+        try {
+            const verdict = await session.play(halfMove);
+            if (id !== shown) {
+                return;
+            }
+            draw(await session.board());
+            if (verdict === "right") {
+                markSolved();
+                setVerdict("right", current.right);
+            } else if (verdict === "wrong") {
+                // Le pion revient, et une phrase dit pourquoi.
+                await new Promise((resolve) => setTimeout(resolve, REFUSED_MS));
+                if (id !== shown) {
+                    return;
+                }
+                session.reset();
+                setVerdict("wrong", current.wrong);
+            } else {
+                feedback.textContent = "";
+                feedback.dataset.verdict = "";
+            }
+            await refreshTargets();
+        } finally {
+            if (id === shown) {
+                setBusy(false);
+                draw(practice === null ? null : await practice.board());
+            }
+        }
+    }
+
+    svg.addEventListener("click", (event) => {
+        if (practice === null || busy || solved) {
+            return;
+        }
+        const target = event.target as Element | null;
+        const placeName = target
+            ?.closest("[data-place]")
+            ?.getAttribute("data-place") as Place | null;
+        if (placeName == null) {
+            return;
+        }
+        const halfMove = selected === null ? undefined : targets.get(selected)?.get(placeName);
+        if (halfMove !== undefined) {
+            void playHalfMove(halfMove);
+            return;
+        }
+        const only = placeName === selected ? null : onlyHalfMove(targets, placeName);
+        if (only !== null) {
+            void playHalfMove(only);
+            return;
+        }
+        selected = targets.has(placeName) && placeName !== selected ? placeName : null;
+        void practice.board().then((sides) => draw(sides));
+    });
+
+    replay.addEventListener("click", () => {
+        clearTimer();
+        void playIllustration(shown);
+    });
+
+    async function answer(takes: boolean): Promise<void> {
+        const current = screen;
+        if (current === null || solved || busy) {
+            return;
+        }
+        const id = shown;
+        setBusy(true);
+        try {
+            const right = (await access.shouldTake(current.position)) === takes;
+            if (id !== shown) {
+                return;
+            }
+            if (right) {
+                markSolved();
+            }
+            setVerdict(right ? "right" : "wrong", right ? current.right : current.wrong);
+        } finally {
+            setBusy(false);
+        }
+    }
+    take.addEventListener("click", () => void answer(true));
+    drop.addEventListener("click", () => void answer(false));
+
+    function renderProgress(total: number, at: TutorialPlace, steps: Tutorial["steps"]): void {
+        bar.replaceChildren();
+        for (const segment of progress(total, at, options.seen())) {
+            const stepTitle = steps[segment.step - 1]?.title ?? "";
+            const label = HOME_TEXTS.tutorialStepLink(segment.step, stepTitle);
+            const item = segment.link
+                ? document.createElement("a")
+                : document.createElement("span");
+            item.className = `segment${segment.done ? " done" : ""}`;
+            if (item instanceof HTMLAnchorElement) {
+                item.href = routeHash({ screen: "tutorial", step: segment.step, practice: false });
+                item.setAttribute("aria-label", label);
+            } else {
+                item.setAttribute("aria-hidden", "true");
+            }
+            if (segment.current) {
+                item.setAttribute("aria-current", "step");
+            }
+            bar.append(item);
+        }
+        bar.setAttribute(
+            "aria-description",
+            at === "end"
+                ? HOME_TEXTS.tutorialEndOverline
+                : HOME_TEXTS.tutorialOverline(at.step, total, at.practice),
+        );
+    }
+
+    return {
+        async show(route) {
+            const id = ++shown;
+            // Prêt (pour les tests dans un navigateur) une fois ce plateau dessiné.
+            delete section.dataset.ready;
+            clearTimer();
+            setBusy(false);
+            practice = null;
+            illustration = null;
+            illustrated = false;
+            screen = null;
+            boards = null;
+            selected = null;
+            targets = new Map();
+            solved = false;
+            section.toggleAttribute("data-solved", false);
+            feedback.textContent = "";
+            feedback.dataset.verdict = "";
+            task.hidden = true;
+            cube.hidden = true;
+            replay.hidden = true;
+            take.disabled = false;
+            drop.disabled = false;
+            let loaded: Tutorial;
+            try {
+                if (tutorial === null) {
+                    title.textContent = HOME_TEXTS.tutorialLoading;
+                    text.replaceChildren();
+                    svg.replaceChildren();
+                }
+                loaded = await load();
+            } catch {
+                if (id === shown) {
+                    title.textContent = HOME_TEXTS.tutorialFailed;
+                }
+                return;
+            }
+            if (id !== shown) {
+                return;
+            }
+            const at = placeOf(loaded, route);
+            const wanted = routeHash(placeRoute(at));
+            if (routeHash(route) !== wanted) {
+                options.replace(wanted);
+                return;
+            }
+            place = at;
+            options.visit(at);
+            const total = loaded.steps.length;
+            renderProgress(total, at, loaded.steps);
+            const before = previousPlace(loaded, at);
+            back.href = before === null ? "#/accueil" : routeHash(placeRoute(before));
+            if (at === "end") {
+                overline.textContent = HOME_TEXTS.tutorialEndOverline;
+                title.textContent = HOME_TEXTS.tutorialEndTitle;
+                text.replaceChildren();
+                for (const paragraph of loaded.end.paragraphs) {
+                    fillParagraph(element(text, "p"), paragraph);
+                }
+                next.textContent = loaded.end.action;
+                next.href = "#/";
+                next.classList.remove("secondary");
+                screen = loaded.steps[0]?.explain ?? null;
+            } else {
+                const step = loaded.steps[at.step - 1];
+                const current = at.practice ? step?.practice : step?.explain;
+                if (step === undefined || current == null) {
+                    return;
+                }
+                screen = { ...current, path: current.path && !at.practice };
+                overline.textContent = HOME_TEXTS.tutorialOverline(at.step, total, at.practice);
+                title.textContent = step.title;
+                text.replaceChildren();
+                const paragraphs = at.practice ? [] : current.paragraphs;
+                for (const paragraph of paragraphs) {
+                    fillParagraph(element(text, "p"), paragraph);
+                }
+                if (at.practice) {
+                    task.hidden = false;
+                    task.replaceChildren();
+                    for (const [i, paragraph] of current.paragraphs.entries()) {
+                        if (i > 0) {
+                            task.append(" ");
+                        }
+                        const span = document.createElement("span");
+                        fillParagraph(span, paragraph);
+                        task.append(span);
+                    }
+                }
+                const after = nextPlace(loaded, at);
+                next.textContent = HOME_TEXTS.next;
+                next.href = routeHash(placeRoute(after));
+                next.classList.toggle("secondary", at.practice);
+            }
+            const currentScreen = screen;
+            if (currentScreen === null) {
+                return;
+            }
+            // Le plateau : la position, puis le coup illustré ou le geste à
+            // faire, tous lus par le moteur.
+            try {
+                await options.engineReady;
+                const shownBoard = await access.board(currentScreen.position, currentScreen.onRoll);
+                if (id !== shown) {
+                    return;
+                }
+                boards = shownBoard;
+                if (
+                    at !== "end" &&
+                    at.practice &&
+                    currentScreen.roll !== null &&
+                    currentScreen.expected.length > 0
+                ) {
+                    practice = await access.practice(
+                        currentScreen.position,
+                        currentScreen.roll,
+                        currentScreen.expected,
+                    );
+                    if (id !== shown) {
+                        return;
+                    }
+                    await refreshTargets();
+                } else if (at !== "end" && at.practice && currentScreen.answer !== null) {
+                    cube.hidden = false;
+                    feedback.textContent = HOME_TEXTS.computerDoubles;
+                    feedback.dataset.verdict = "info";
+                } else if (
+                    at !== "end" &&
+                    currentScreen.move !== null &&
+                    currentScreen.roll !== null
+                ) {
+                    illustration = await access.illustrate(
+                        currentScreen.position,
+                        currentScreen.roll,
+                        currentScreen.move,
+                    );
+                    if (id !== shown) {
+                        return;
+                    }
+                    replay.hidden = false;
+                    replay.disabled = true;
+                    autoplay = setTimeout(() => void playIllustration(id), AUTOPLAY_MS);
+                }
+                if (id !== shown) {
+                    return;
+                }
+                draw(practice === null ? null : await practice.board());
+                section.dataset.ready = String(id);
+            } catch (error) {
+                if (id === shown) {
+                    feedback.textContent = `${HOME_TEXTS.tutorialFailed} ${error instanceof Error ? error.message : ""}`;
+                }
+            }
+        },
+        relayout() {
+            if (place === null || busy) {
+                return;
+            }
+            if (practice !== null) {
+                void practice.board().then((sides) => draw(sides));
+            } else {
+                draw();
+            }
+        },
+        hide() {
+            shown++;
+            clearTimer();
+            setBusy(false);
+        },
+    };
+}

app/src/ui/updates.ts

@@ -0,0 +1,150 @@
+// La mise à jour de l'application : le service worker (web/sw.js) installe
+// chaque nouvelle version publiée dans son propre cache, puis attend
+// l'accord du joueur. L'application affiche alors, entre deux tours, le
+// bandeau « Nouvelle version prête. » en bas de l'écran ; « Mettre à jour »
+// active la nouvelle version et recharge la page, qui reprend la partie
+// enregistrée.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+export interface Updates {
+    /** Une nouvelle version est installée et attend l'accord du joueur. */
+    readonly available: boolean;
+    /** « Rechercher une mise à jour » : demande au navigateur de relire le
+     * service worker publié. found : une nouvelle version attend (elle a pu
+     * demander de télécharger tout le site) ; latest : rien de nouveau ;
+     * unavailable : pas de service worker (http hors localhost, navigateur
+     * qui le refuse) ou réseau absent. */
+    check(): Promise<"found" | "latest" | "unavailable">;
+    /** Active la nouvelle version : la page se recharge dès qu'elle a pris
+     * la main. */
+    apply(): void;
+}
+
+/** Message au service worker en attente : prendre la main (sw.js). */
+export const SKIP_WAITING = "skip-waiting";
+
+/**
+ * Est-on entre deux tours ? Oui quand la partie attend un lancer de dés
+ * (aucun pion déplacé) ou qu'elle est finie ; non dès que des dés sont à
+ * jouer, qu'un double attend sa réponse, ou au jet d'ouverture. Fonction
+ * pure, testée sous Node.
+ */
+export function betweenTurns(phase: string, pendingHalfMoves: number): boolean {
+    return phase === "over" || (phase === "rolling" && pendingHalfMoves === 0);
+}
+
+/**
+ * Le bandeau « Nouvelle version prête. » est-il montré ? Quand une version
+ * attend, seulement entre deux tours (jamais pendant un coup en cours, ni
+ * quand l'ordinateur joue), et jamais par-dessus le bandeau « Reprendre
+ * l'ancienne », qui occupe la même place. Fonction pure, testée sous Node.
+ */
+export function updateBannerShown(
+    available: boolean,
+    betweenTwoTurns: boolean,
+    otherBanner: boolean,
+): boolean {
+    return available && betweenTwoTurns && !otherBanner;
+}
+
+/**
+ * Enregistre le service worker une fois ready résolue (le moteur chargé :
+ * voir main.ts), et suit ses mises à jour. onAvailable est appelé quand une
+ * nouvelle version attend.
+ */
+export function startUpdates(
+    script: URL,
+    ready: Promise<unknown>,
+    onAvailable: () => void,
+): Updates {
+    const container = "serviceWorker" in navigator ? navigator.serviceWorker : null;
+    let registration: ServiceWorkerRegistration | null = null;
+    let waiting: ServiceWorker | null = null;
+
+    /** Une version installée attend, et une version plus ancienne a la
+     * main : c'est une mise à jour (à la toute première installation,
+     * aucune page n'est encore contrôlée, et rien n'attend). */
+    const notice = (worker: ServiceWorker | null) => {
+        if (worker !== null && worker.state === "installed" && container?.controller) {
+            waiting = worker;
+            onAvailable();
+        }
+    };
+
+    /** Suit une version en cours d'installation ; résolue quand elle est
+     * installée (vrai) ou abandonnée (faux). */
+    const follow = (worker: ServiceWorker): Promise<boolean> =>
+        new Promise((resolve) => {
+            const settle = () => {
+                if (worker.state === "installed" || worker.state === "activated") {
+                    notice(worker);
+                    resolve(true);
+                } else if (worker.state === "redundant") {
+                    resolve(false);
+                }
+            };
+            worker.addEventListener("statechange", settle);
+            settle();
+        });
+
+    if (container !== null) {
+        ready
+            .then(() => container.register(script))
+            .then((reg) => {
+                registration = reg;
+                notice(reg.waiting);
+                if (reg.installing !== null) {
+                    void follow(reg.installing);
+                }
+                reg.addEventListener("updatefound", () => {
+                    if (reg.installing !== null) {
+                        void follow(reg.installing);
+                    }
+                });
+            })
+            .catch(() => {
+                // Refusé (http hors localhost) : l'application marche sans.
+            });
+    }
+
+    return {
+        get available() {
+            return waiting !== null;
+        },
+        async check() {
+            const reg = registration;
+            if (reg === null) {
+                return "unavailable";
+            }
+            try {
+                await reg.update();
+            } catch {
+                return "unavailable";
+            }
+            if (reg.waiting !== null) {
+                notice(reg.waiting);
+                return "found";
+            }
+            if (reg.installing !== null) {
+                return (await follow(reg.installing)) ? "found" : "latest";
+            }
+            return "latest";
+        },
+        apply() {
+            const worker = waiting ?? registration?.waiting ?? null;
+            if (container === null || worker === null) {
+                return;
+            }
+            let reloading = false;
+            container.addEventListener("controllerchange", () => {
+                if (!reloading) {
+                    reloading = true;
+                    location.reload();
+                }
+            });
+            worker.postMessage({ type: SKIP_WAITING });
+        },
+    };
+}

app/tests/branches-sgf.test.ts

@@ -0,0 +1,172 @@
+// Tests du domaine : les branches d'une partie et son export SGF, sur des
+// journaux écrits à la main (sans moteur, sauf un faux pour une position de
+// départ particulière). La relecture des SGF par le vrai GNU Backgammon est
+// faite par tests/test_web.sh (tests/sgf/check.py).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { branches, switchToBranch } from "../src/domain/game/branches.js";
+import type { Board, Engine } from "../src/domain/game/engine.js";
+import {
+    appendEvent,
+    currentLine,
+    EMPTY_JOURNAL,
+    type GameJournal,
+    goBackTo,
+    type NewGameEvent,
+} from "../src/domain/game/events.js";
+import { parseHalfMoves, START_POSITION } from "../src/domain/game/position.js";
+import { exportSgf } from "../src/domain/game/sgf.js";
+
+function add(journal: GameJournal, ...events: NewGameEvent[]): GameJournal {
+    return events.reduce(appendEvent, journal);
+}
+
+const start: NewGameEvent = {
+    type: "GameStarted",
+    position: START_POSITION,
+    cube: { value: 1, owner: null },
+    firstTurn: null,
+};
+const move = (side: "player" | "computer", text: string, position = "P"): NewGameEvent => ({
+    type: "MovePlayed",
+    side,
+    halfMoves: parseHalfMoves(text),
+    position,
+});
+const roll = (side: "player" | "computer" | null, a: number, b: number): NewGameEvent => ({
+    type: "DiceRolled",
+    side,
+    roll: [a, b],
+});
+
+/**
+ * Une partie et ses branches :
+ *   1 début, 2 ouverture 3-1 (joueur), 3 coup 8/5 6/5, 4 dés ordinateur 6-4,
+ *   5 coup 24/18 13/9, 6 dés joueur 2-1 ;
+ * rejouée après 3 : 7 dés ordinateur 5-5 ; puis rejouée après 2 (même
+ * ouverture, autre coup) : 8 coup 24/23 13/10.
+ */
+function branchedGame(): GameJournal {
+    let j = add(
+        EMPTY_JOURNAL,
+        start,
+        roll(null, 3, 1),
+        move("player", "8/5 6/5"),
+        roll("computer", 6, 4),
+        move("computer", "24/18 13/9"),
+        roll("player", 2, 1),
+    );
+    j = add(goBackTo(j, "3"), roll("computer", 5, 5));
+    j = add(goBackTo(j, "2"), move("player", "24/23 13/10"));
+    return j;
+}
+
+test("les branches : feuilles de l'arbre, avec leur point de départ", () => {
+    const j = branchedGame();
+    const all = branches(j);
+    assert.deepEqual(
+        all.map((b) => [b.head, b.forkedFrom, b.forkMoveCount, b.moveCount, b.containsHead]),
+        [
+            ["6", null, 0, 2, false],
+            ["7", "3", 1, 1, false],
+            ["8", "2", 0, 1, true],
+        ],
+    );
+    assert.deepEqual(branches(EMPTY_JOURNAL), []);
+
+    // Passer d'une branche à l'autre ne perd rien.
+    const back = switchToBranch(j, "6");
+    assert.equal(back.events, j.events);
+    assert.deepEqual(
+        currentLine(back).map((e) => e.id),
+        ["1", "2", "3", "4", "5", "6"],
+    );
+    assert.throws(() => switchToBranch(j, "4"), /branche introuvable/);
+});
+
+test("une branche rejouée puis continuée garde son ordre de création", () => {
+    // La ligne d'origine continue après la création d'une branche : elle
+    // reste la première.
+    let j = add(EMPTY_JOURNAL, start, roll(null, 3, 1), move("player", "8/5 6/5"));
+    j = add(goBackTo(j, "2"), move("player", "24/23 13/10"));
+    j = add(goBackTo(j, "3"), roll("computer", 6, 4));
+    assert.deepEqual(
+        branches(j).map((b) => [b.head, b.forkedFrom]),
+        [
+            ["5", null],
+            ["4", "2"],
+        ],
+    );
+});
+
+/** Un faux moteur qui ne sait que décoder un plateau. */
+function boardEngine(board: Board): Engine {
+    return { board: async () => board } as unknown as Engine;
+}
+const noEngine = boardEngine({} as Board);
+const names = { playerName: "Vous", computerName: "Ordi]nateur", date: "2026-11-03" };
+
+test("SGF : les coups, les variantes, la branche courante d'abord", async () => {
+    const sgf = await exportSgf(noEngine, branchedGame(), names);
+    assert.equal(
+        sgf,
+        "(;FF[4]GM[6]CA[UTF-8]AP[Ustagammon]MI[length:0][game:0][ws:0][bs:0]" +
+            "PW[Ordi\\]nateur]PB[Vous]DT[2026-11-03](" +
+            // Branche courante : même ouverture, autre coup.
+            "\n;B[31ablo])(" +
+            // Ligne d'origine : 8/5 6/5 (B : 'x' - (case - 1)).
+            "\n;B[31qtst](" +
+            // Puis 24/18 13/9 de l'ordinateur (W : 'a' + (case - 1)), et
+            // des dés lancés, pas joués.
+            "\n;W[64xrmi]\n;PL[B]DI[21])(" +
+            "\n;PL[W]DI[55])))\n",
+    );
+});
+
+test("SGF : barre, sortie, coup impossible, videau et résultat", async () => {
+    const j = add(
+        EMPTY_JOURNAL,
+        start,
+        roll(null, 1, 6),
+        move("computer", "bar/19 6/off"),
+        { type: "CubeOffered", side: "player" },
+        { type: "CubeTaken", side: "computer" },
+        roll("player", 6, 6),
+        move("player", ""),
+        { type: "CubeOffered", side: "computer" },
+        { type: "CubeDropped", side: "player" },
+        { type: "GameEnded", winner: "computer", kind: "single", points: 2 },
+    );
+    const sgf = await exportSgf(noEngine, j, names);
+    assert.ok(sgf.includes("RE[W+2]"));
+    assert.ok(
+        sgf.endsWith("\n;W[16ysfz]\n;B[double]\n;W[take]\n;B[66]\n;W[double]\n;B[drop])\n"),
+        sgf,
+    );
+});
+
+test("SGF : une position de départ particulière est posée", async () => {
+    // Le joueur a la main : 2 pions sur sa case 1, 1 sur la barre ;
+    // l'ordinateur : 3 pions sur sa case 24. Videau à 4 chez l'ordinateur.
+    const points = (entries: Record<number, number>) =>
+        Array.from({ length: 24 }, (_, i) => entries[i + 1] ?? 0);
+    const engine = boardEngine({
+        onRoll: { points: points({ 1: 2 }), bar: 1, off: 12, pipCount: 27 },
+        opponent: { points: points({ 24: 3 }), bar: 0, off: 12, pipCount: 72 },
+        swappedPosition: "X",
+        result: null,
+    });
+    const j = add(EMPTY_JOURNAL, {
+        type: "GameStarted",
+        position: "ABC",
+        cube: { value: 4, owner: "computer" },
+        firstTurn: "player",
+    });
+    const sgf = await exportSgf(engine, j, names);
+    assert.ok(sgf.endsWith("\n;PL[B]AE[a:y]AW[x][x][x]AB[x][x][y]\n;CV[4]\n;CP[w])\n"), sgf);
+    await assert.rejects(exportSgf(noEngine, EMPTY_JOURNAL, names), /vide/);
+});

app/tests/game.test.ts

@@ -59,6 +59,16 @@ function fakeEngine(overrides: Partial<Engine> = {}): Engine {
             skill: "none",
         }),
         luck: async () => ({ value: 0, rating: "none" }),
+        encodeMatch: async () => "MATCH",
+        decodeMatch: async () => ({
+            matchLength: 0,
+            score: [0, 0],
+            cubeValue: 1,
+            cubeOwner: -1,
+            playerOnRoll: 0,
+            crawford: false,
+            jacoby: true,
+        }),
         ...overrides,
     };
 }

app/tests/home.test.ts

@@ -0,0 +1,133 @@
+// Tests de l'accueil et de l'invitation à installer, sans navigateur :
+// premier lancement, règles d'apparition de la carte d'installation,
+// réglages enregistrés par une version précédente.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { test } from "node:test";
+import { installPlatform } from "../src/ui/install.js";
+import {
+    DEFAULT_SETTINGS,
+    INSTALL_AGAIN_AFTER,
+    installCardShown,
+    isFirstLaunch,
+    parseSettings,
+    type Settings,
+    TUTORIAL_DONE,
+} from "../src/ui/settings.js";
+import { nextPlace, placeOf, previousPlace, progress, seenAfter } from "../src/ui/tutorial-nav.js";
+import { parseTutorial } from "../src/ui/tutorial-text.js";
+
+const root = new URL("../../../", import.meta.url);
+
+test("réglages d'une version précédente : les nouveaux champs prennent leur valeur par défaut", () => {
+    const old = parseSettings('{"vibrations": false, "theme": "dark", "gamesStarted": 4}');
+    assert.equal(old.welcomed, false);
+    assert.equal(old.gamesFinished, 0);
+    assert.equal(old.tutorialSeen, 0);
+    assert.equal(old.installed, false);
+    const saved = parseSettings(
+        '{"welcomed": true, "gamesFinished": 2, "tutorialSeen": 5, "installDismissals": 1, ' +
+            '"installDismissedAt": 2, "installed": true}',
+    );
+    assert.deepEqual(saved, {
+        ...DEFAULT_SETTINGS,
+        welcomed: true,
+        gamesFinished: 2,
+        tutorialSeen: 5,
+        installDismissals: 1,
+        installDismissedAt: 2,
+        installed: true,
+    });
+    assert.equal(parseSettings('{"tutorialSeen": -3, "welcomed": "oui"}').tutorialSeen, 0);
+});
+
+test("premier lancement : tant que rien n'a été fait, une seule fois", () => {
+    assert.ok(isFirstLaunch(DEFAULT_SETTINGS));
+    // La partie commencée d'office au chargement ne compte pas.
+    assert.ok(isFirstLaunch({ ...DEFAULT_SETTINGS, gamesStarted: 1 }));
+    assert.ok(!isFirstLaunch({ ...DEFAULT_SETTINGS, welcomed: true }));
+    assert.ok(!isFirstLaunch({ ...DEFAULT_SETTINGS, gamesStarted: 2 }));
+    assert.ok(!isFirstLaunch({ ...DEFAULT_SETTINGS, gamesFinished: 1 }));
+    assert.ok(!isFirstLaunch({ ...DEFAULT_SETTINGS, tutorialSeen: 1 }));
+});
+
+test("invitation à installer : après la première partie terminée, une seule relance", () => {
+    const at = (changes: Partial<Settings>, installed = false) =>
+        installCardShown({ ...DEFAULT_SETTINGS, ...changes }, installed);
+    assert.ok(!at({}), "jamais avant la première partie terminée");
+    assert.ok(at({ gamesFinished: 1 }));
+    assert.ok(!at({ gamesFinished: 1 }, true), "jamais une fois installée");
+    assert.ok(!at({ gamesFinished: 1, installed: true }));
+    // « Plus tard » : masquée, puis de retour après trois parties de plus.
+    const later = { installDismissals: 1, installDismissedAt: 1 };
+    assert.equal(INSTALL_AGAIN_AFTER, 3);
+    assert.ok(!at({ ...later, gamesFinished: 1 }));
+    assert.ok(!at({ ...later, gamesFinished: 3 }));
+    assert.ok(at({ ...later, gamesFinished: 4 }));
+    // Une seconde fois « Plus tard » : plus jamais sur l'accueil.
+    assert.ok(!at({ installDismissals: 2, installDismissedAt: 4, gamesFinished: 40 }));
+});
+
+test("tutoriel : écran suivant, précédent, adresse ramenée à un écran qui existe", () => {
+    const tutorial = parseTutorial(readFileSync(new URL("docs/tutoriel/regles.md", root), "utf8"));
+    const explain = (step: number) => ({ step, practice: false });
+    const practice = (step: number) => ({ step, practice: true });
+    assert.deepEqual(nextPlace(tutorial, explain(2)), explain(3));
+    assert.deepEqual(nextPlace(tutorial, explain(3)), practice(3));
+    assert.deepEqual(nextPlace(tutorial, practice(3)), explain(4));
+    assert.equal(nextPlace(tutorial, practice(8)), "end");
+    assert.equal(previousPlace(tutorial, explain(1)), null);
+    assert.deepEqual(previousPlace(tutorial, explain(4)), practice(3));
+    assert.deepEqual(previousPlace(tutorial, explain(3)), explain(2));
+    assert.deepEqual(previousPlace(tutorial, "end"), practice(8));
+    assert.deepEqual(
+        placeOf(tutorial, { screen: "tutorial", step: null, practice: false }),
+        explain(1),
+    );
+    assert.deepEqual(
+        placeOf(tutorial, { screen: "tutorial", step: 2, practice: true }),
+        explain(2),
+    );
+    assert.deepEqual(
+        placeOf(tutorial, { screen: "tutorial", step: 42, practice: false }),
+        explain(1),
+    );
+    assert.equal(placeOf(tutorial, { screen: "tutorialEnd" }), "end");
+    assert.equal(seenAfter(5, explain(3)), 5);
+    assert.equal(seenAfter(0, "end"), TUTORIAL_DONE);
+    // La barre : des liens vers les étapes vues seulement, pas l'actuelle.
+    const bar = progress(8, explain(3), 5);
+    assert.deepEqual(
+        bar.filter((s) => s.link).map((s) => s.step),
+        [1, 2, 4, 5],
+    );
+    assert.deepEqual(
+        bar.filter((s) => s.done).map((s) => s.step),
+        [1, 2, 3],
+    );
+    assert.deepEqual(
+        bar.filter((s) => s.current).map((s) => s.step),
+        [3],
+    );
+});
+
+test("la marche à suivre pour installer dépend du navigateur", () => {
+    const iphone =
+        "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 " +
+        "(KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1";
+    const ipad = "Mozilla/5.0 (iPad; CPU OS 16_0 like Mac OS X) AppleWebKit/605.1.15";
+    const firefox = "Mozilla/5.0 (Android 14; Mobile; rv:131.0) Gecko/131.0 Firefox/131.0";
+    const chrome =
+        "Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 (KHTML, like Gecko) " +
+        "Chrome/130.0 Mobile Safari/537.36";
+    assert.equal(installPlatform(iphone), "ios");
+    assert.equal(installPlatform(ipad), "ios");
+    assert.equal(installPlatform(firefox), "firefox");
+    // Sans invite du système, Chrome suit la marche à suivre de Firefox
+    // (menu ⋮, « Installer »), la plus proche de la sienne.
+    assert.equal(installPlatform(chrome), "firefox");
+});

app/tests/layout.test.ts

@@ -0,0 +1,275 @@
+// Tests de la révision UX qui se vérifient sans navigateur : géométrie du
+// plateau selon l'écran, vibrations, réglages, compte de points, plateau
+// gardé pour le chargement, et règles de la charte vérifiables dans le code.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { test } from "node:test";
+import { createSettingsStore } from "../src/storage/settings-store.js";
+import { OPENING_BOARDS, pipLead } from "../src/ui/board-model.js";
+import { BOARD_HEIGHT, boardGeometry, MAX_STACK, stackY } from "../src/ui/geometry.js";
+import { createHaptics, HAPTIC_PATTERNS } from "../src/ui/haptics.js";
+import { ICON_PATHS } from "../src/ui/icons.js";
+import {
+    DEFAULT_SETTINGS,
+    LONG_PROMPT_GAMES,
+    longPrompts,
+    nextTheme,
+    parseSettings,
+} from "../src/ui/settings.js";
+
+const root = new URL("../../../", import.meta.url);
+const read = (path: string) => readFileSync(new URL(path, root), "utf8");
+
+// --------------------------------------------------------------- Géométrie
+
+/** Les écrans en paysage de la recette : largeur et hauteur en pixels,
+ * dont 844 × 320 (Chrome garde sa barre d'adresse) et un rapport plus large
+ * encore. */
+const LANDSCAPES: [number, number][] = [
+    [915, 412],
+    [844, 390],
+    [844, 320],
+    [740, 360],
+    [800, 308],
+];
+
+test("géométrie en portrait : les mesures du plateau d'origine", () => {
+    const g = boardGeometry("portrait", 640 / 520, 396 / 640);
+    assert.equal(g.width, 640);
+    assert.equal(g.pointWidth, 44);
+    assert.equal(g.radius, 20);
+    assert.equal(g.step, 42);
+    assert.equal(g.trayLeft + g.tray + g.frame, 640);
+    // Numéros d'au moins 12 px à l'écran, à 412 px de large.
+    assert.ok(g.numberSize * (396 / 640) >= 12, `numéros de ${g.numberSize} unités`);
+});
+
+test("géométrie en paysage : le plateau remplit l'écran, flèches de 44 px et pions de 22 px au moins", () => {
+    for (const [width, height] of LANDSCAPES) {
+        const px = height / BOARD_HEIGHT;
+        const g = boardGeometry("landscape", width / height, px);
+        const where = `${width}x${height}`;
+        assert.ok(Math.abs(g.width / g.height - width / height) < 0.01, `${where} : proportions`);
+        // Les colonnes, la barre et les flèches occupent toute la largeur.
+        assert.ok(Math.abs(g.trayLeft + g.tray + g.frame - g.width) < 1e-9, `${where} : largeur`);
+        assert.ok(g.pointWidth * px >= 44, `${where} : flèches de ${g.pointWidth * px} px`);
+        assert.ok(2 * g.radius * px >= 22, `${where} : pions de ${2 * g.radius * px} px`);
+        assert.ok(g.numberSize * px >= 12, `${where} : numéros de ${g.numberSize * px} px`);
+        assert.ok(g.bandFont * px >= 13, `${where} : consigne de ${g.bandFont * px} px`);
+        assert.ok(g.chipFont * px >= 13, `${where} : comptes de ${g.chipFont * px} px`);
+        assert.ok(g.target * px >= 44, `${where} : cibles de ${g.target * px} px`);
+        assert.ok(g.cubeFont * px >= 13, `${where} : videau en ${g.cubeFont * px} px`);
+        assert.ok(g.countFont * px >= 13, `${where} : nombres des piles en ${g.countFont * px} px`);
+        assert.ok(g.cube <= g.left - 8, `${where} : videau plus large que sa colonne`);
+        assert.ok(g.left - 4 >= g.target - 4, `${where} : colonne de commandes trop étroite`);
+        // Les numéros tiennent dans le cadre.
+        assert.ok(g.numberSize < g.edge, `${where} : numéros hors du cadre`);
+    }
+});
+
+test("une pile de cinq pions ne déborde pas dans la bande centrale (dés, consigne)", () => {
+    const cases = [
+        boardGeometry("portrait", 640 / 520, 0.62),
+        ...[1.9, 2.16, 2.6].map((aspect) => boardGeometry("landscape", aspect, 0.615)),
+    ];
+    for (const g of cases) {
+        const band = g.height / 2 - g.die / 2;
+        const last = stackY(g, true, MAX_STACK - 1) + g.radius;
+        assert.ok(last <= band, `${g.layout} ${g.width} : pion jusqu'à ${last}, dés dès ${band}`);
+    }
+});
+
+test("en paysage, les pions de la barre s'arrêtent avant les pastilles des comptes", () => {
+    for (const [width, height] of LANDSCAPES) {
+        const g = boardGeometry("landscape", width / height, height / BOARD_HEIGHT);
+        const lastOffset = g.radius + 4 + (g.barStack - 1) * g.step + g.radius;
+        const chipEdge = g.height / 2 - (g.edge + 4 + g.chipHeight);
+        assert.ok(g.barStack >= 1);
+        assert.ok(lastOffset <= chipEdge, `${width}x${height} : ${lastOffset} > ${chipEdge}`);
+    }
+});
+
+// -------------------------------------------------------------- Vibrations
+
+test("vibrations : les motifs de la charte, et rien quand elles sont coupées", () => {
+    const calls: number[][] = [];
+    let on = true;
+    const haptic = createHaptics(
+        (pattern) => {
+            calls.push(pattern);
+            return true;
+        },
+        () => on,
+    );
+    haptic("checkerPlaced");
+    haptic("checkerHit");
+    haptic("computerDoubles");
+    haptic("gameWon");
+    haptic("gameLost");
+    assert.deepEqual(calls, [[12], [25, 40, 25], [40, 60, 40], [30, 50, 30, 50, 60], [60]]);
+    on = false;
+    haptic("checkerHit");
+    assert.equal(calls.length, 5);
+    // Sans navigator.vibrate, ou si le navigateur refuse : aucune erreur.
+    assert.doesNotThrow(() => createHaptics(undefined, () => true)("gameWon"));
+    const refusing = createHaptics(
+        () => {
+            throw new Error("refusé");
+        },
+        () => true,
+    );
+    assert.doesNotThrow(() => refusing("gameWon"));
+    // Aucun motif ne dépasse 60 ms par impulsion (interaction.md).
+    for (const pattern of Object.values(HAPTIC_PATTERNS)) {
+        assert.ok(pattern.every((ms) => ms > 0 && ms <= 60));
+    }
+});
+
+// ---------------------------------------------------------------- Réglages
+
+test("réglages : valeurs par défaut, lecture tolérante, thème en boucle", () => {
+    assert.deepEqual(parseSettings(null), DEFAULT_SETTINGS);
+    assert.equal(DEFAULT_SETTINGS.vibrations, true);
+    assert.equal(DEFAULT_SETTINGS.keepScreenOn, true);
+    assert.deepEqual(parseSettings("pas du JSON"), DEFAULT_SETTINGS);
+    assert.deepEqual(parseSettings('{"vibrations": false, "theme": "dark", "gamesStarted": 4}'), {
+        ...DEFAULT_SETTINGS,
+        vibrations: false,
+        theme: "dark",
+        gamesStarted: 4,
+    });
+    assert.deepEqual(parseSettings('{"vibrations": "non", "theme": "rose", "gamesStarted": -1}'), {
+        ...DEFAULT_SETTINGS,
+    });
+    assert.equal(nextTheme("auto"), "light");
+    assert.equal(nextTheme("light"), "dark");
+    assert.equal(nextTheme("dark"), "auto");
+});
+
+test("consigne longue pendant les trois premières parties, courte ensuite", () => {
+    assert.equal(LONG_PROMPT_GAMES, 3);
+    for (const games of [0, 1, 2, 3]) {
+        assert.equal(longPrompts({ ...DEFAULT_SETTINGS, gamesStarted: games }), true);
+    }
+    assert.equal(longPrompts({ ...DEFAULT_SETTINGS, gamesStarted: 4 }), false);
+});
+
+test("stockage des réglages et du dernier plateau affiché", () => {
+    const data = new Map<string, string>();
+    const store = createSettingsStore({
+        getItem: (key) => data.get(key) ?? null,
+        setItem: (key, value) => void data.set(key, value),
+    });
+    assert.equal(store.loadSettings(), null);
+    store.saveSettings('{"vibrations":false}');
+    assert.equal(store.loadSettings(), '{"vibrations":false}');
+    assert.equal(store.loadBoard(), null);
+    const board = { sides: OPENING_BOARDS, cube: { value: 2, owner: "player" as const } };
+    store.saveBoard(board);
+    assert.deepEqual(store.loadBoard(), board);
+    // Un plateau abîmé est ignoré : la position de départ sera dessinée.
+    data.set("ustagammon.last-board", '{"sides": {"player": {"points": [1]}}}');
+    assert.equal(store.loadBoard(), null);
+    const full = createSettingsStore({
+        getItem: () => {
+            throw new Error("interdit");
+        },
+        setItem: () => {
+            throw new Error("plein");
+        },
+    });
+    assert.doesNotThrow(() => full.saveBoard(board));
+    assert.equal(full.loadBoard(), null);
+    assert.equal(full.loadSettings(), null);
+});
+
+// ------------------------------------------------------- Compte de points
+
+test("compte de points : le plus petit mène, de l'écart", () => {
+    assert.deepEqual(pipLead({ player: 136, computer: 128 }), { leader: "computer", by: 8 });
+    assert.deepEqual(pipLead({ player: 100, computer: 128 }), { leader: "player", by: 28 });
+    assert.deepEqual(pipLead({ player: 167, computer: 167 }), { leader: null, by: 0 });
+    // La position de départ : 15 pions, 167 points chacun.
+    for (const side of [OPENING_BOARDS.player, OPENING_BOARDS.computer]) {
+        assert.equal(
+            side.points.reduce((a, b) => a + b, 0),
+            15,
+        );
+        assert.equal(
+            side.points.reduce((sum, n, i) => sum + n * (i + 1), 0),
+            side.pipCount,
+        );
+    }
+});
+
+// ------------------------------------------------------------------ Charte
+
+/** Les fichiers .ts d'un dossier, récursivement. */
+function sources(dir: string): string[] {
+    const url = new URL(dir, root);
+    return readdirSync(url).flatMap((name) => {
+        const path = `${dir}${name}`;
+        return statSync(new URL(path, root)).isDirectory() ? sources(`${path}/`) : [path];
+    });
+}
+
+test("aucune boîte native du navigateur (confirm, alert, prompt) dans l'application", () => {
+    // Une méthode d'un autre objet ne compte pas : event.prompt() est l'invite
+    // d'installation de Chrome (install.ts), pas une boîte de dialogue.
+    for (const path of sources("app/src/")) {
+        const text = read(path);
+        assert.doesNotMatch(
+            text,
+            /(^|[^.\w])(window\.)?(confirm|alert|prompt)\s*\(/m,
+            `${path} appelle une boîte native`,
+        );
+    }
+    assert.match("window.alert(1)", /(^|[^.\w])(window\.)?(confirm|alert|prompt)\s*\(/m);
+    assert.match("x = confirm('?')", /(^|[^.\w])(window\.)?(confirm|alert|prompt)\s*\(/m);
+});
+
+test("les deux blocs du thème sombre de app.css sont identiques", () => {
+    const css = read("web/app.css");
+    const block = (start: string) => {
+        const from = css.indexOf(start);
+        assert.ok(from >= 0, `bloc ${start} absent`);
+        const body = css.slice(css.indexOf("{", from + start.length - 1) + 1);
+        return body
+            .slice(0, body.indexOf("}"))
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean);
+    };
+    assert.deepEqual(
+        block(':root:not([data-theme="light"]) {'),
+        block(':root[data-theme="dark"] {'),
+    );
+});
+
+test("aucun style en ligne ni attribut style dans la page et le code (CSP)", () => {
+    assert.doesNotMatch(read("web/index.html"), /\sstyle=|<style/);
+    for (const path of sources("app/src/")) {
+        assert.doesNotMatch(read(path), /setAttribute\(\s*"style"|\.style\./, path);
+    }
+});
+
+test("pictogrammes : le jeu de la charte, en tracés SVG", () => {
+    for (const name of [
+        "menu",
+        "help",
+        "fullscreen",
+        "exitFullscreen",
+        "undo",
+        "replay",
+        "close",
+    ]) {
+        assert.ok(name in ICON_PATHS, `pictogramme ${name} absent`);
+    }
+    for (const d of Object.values(ICON_PATHS)) {
+        assert.match(d, /^M[\d.\s,a-zA-Z-]+$/);
+    }
+});

app/tests/position-link.test.ts

@@ -0,0 +1,99 @@
+// Tests des liens de position (app/src/domain/game/position-link.ts, ADR
+// 0013) sur le vrai moteur WebAssembly : Match ID écrit puis relu, videau
+// vu du joueur au trait, identifiants illisibles.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import type { EngineCube } from "../src/domain/game/engine.js";
+import { Game } from "../src/domain/game/game.js";
+import { START_POSITION } from "../src/domain/game/position.js";
+import {
+    linkOf,
+    readPosition,
+    setupOf,
+    UnreadableLinkError,
+} from "../src/domain/game/position-link.js";
+import { fixedDice } from "../src/domain/game/roll.js";
+import { parseRoute, routeHash } from "../src/ui/router.js";
+import { loadNodeEngine } from "./support/node-engine.js";
+
+test("le moteur relit le Match ID qu'il écrit, pour chaque état du videau", async () => {
+    const engine = await loadNodeEngine();
+    const cases: [EngineCube, -1 | 0 | 1][] = [
+        [{ value: 1, owner: "centered" }, -1],
+        [{ value: 2, owner: "onRoll" }, 0],
+        [{ value: 4, owner: "opponent" }, 1],
+    ];
+    for (const [cube, owner] of cases) {
+        const id = await engine.encodeMatch(cube);
+        assert.equal(id.length, 12);
+        const match = await engine.decodeMatch(id);
+        assert.equal(match.matchLength, 0);
+        assert.equal(match.playerOnRoll, 0);
+        assert.equal(match.cubeValue, cube.value);
+        assert.equal(match.cubeOwner, owner);
+    }
+});
+
+test("sans Match ID : partie libre, videau au centre", async () => {
+    const engine = await loadNodeEngine();
+    const shared = await readPosition(engine, { position: START_POSITION, matchId: null });
+    assert.deepEqual(shared.cube, { value: 1, owner: null });
+    assert.equal(shared.match, null);
+    assert.equal(shared.result, null);
+    assert.equal(shared.sides.player.pipCount, 167);
+    assert.equal(shared.sides.computer.pipCount, 167);
+    assert.deepEqual(setupOf(shared), {
+        position: START_POSITION,
+        firstTurn: "player",
+        cube: { value: 1, owner: null },
+    });
+});
+
+test("des identifiants illisibles donnent une erreur claire", async () => {
+    const engine = await loadNodeEngine();
+    for (const link of [
+        { position: "abc", matchId: null },
+        { position: "4HPwATDgc/ABM*", matchId: null },
+        { position: START_POSITION, matchId: "pas un id" },
+        { position: START_POSITION, matchId: "" },
+    ]) {
+        await assert.rejects(readPosition(engine, link), UnreadableLinkError, JSON.stringify(link));
+    }
+});
+
+test("le lien d'une partie rouvre sa position, son videau compris, par l'adresse", async () => {
+    const engine = await loadNodeEngine();
+    // Videau chez l'ordinateur, à 2 : une partie commencée ainsi.
+    const game = Game.start(engine, {
+        dice: fixedDice([3, 1]),
+        setup: {
+            position: "jGfkASjg8wcBMA",
+            firstTurn: "player",
+            cube: { value: 2, owner: "computer" },
+        },
+    });
+    const link = await linkOf(engine, game.state);
+    const route = parseRoute(
+        routeHash({ screen: "position", position: link.position, match: link.matchId }),
+    );
+    assert.ok(route.screen === "position");
+    const shared = await readPosition(engine, { position: route.position, matchId: route.match });
+    assert.deepEqual(shared.sides, await game.displayedBoard());
+    assert.deepEqual(shared.cube, { value: 2, owner: "computer" });
+});
+
+test("le lien pris pendant le tour de l'ordinateur le met au trait, en bas", async () => {
+    const engine = await loadNodeEngine();
+    // Jet d'ouverture 1-6 : l'ordinateur commence.
+    const game = Game.start(engine, { dice: fixedDice([1, 6]) });
+    assert.equal(game.state.turn, "computer");
+    const link = await linkOf(engine, game.state);
+    assert.equal(link.position, game.state.position);
+    const shared = await readPosition(engine, link);
+    const board = await engine.board(game.state.position, { value: 1, owner: "centered" });
+    assert.deepEqual(shared.sides, { player: board.onRoll, computer: board.opponent });
+});

app/tests/router.test.ts

@@ -0,0 +1,145 @@
+// Tests du routeur (app/src/ui/router.ts) : chaque adresse du tableau de
+// l'ADR 0013 (amendement du 2026-11-03) mène au bon écran, et chaque écran
+// redonne son adresse.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+    isHelpScreen,
+    parseRoute,
+    type Route,
+    routeHash,
+    slug,
+    stepsBack,
+} from "../src/ui/router.js";
+
+const START = "4HPwATDgc/ABMA";
+const MATCH = "cAkAAAAAAAAA";
+
+/** Les adresses du tableau de l'ADR, et l'écran de chacune. */
+const TABLE: [string, Route][] = [
+    ["#/", { screen: "game" }],
+    ["#/accueil", { screen: "home" }],
+    ["#/aide", { screen: "help", question: null }],
+    ["#/aide/comment-jouer", { screen: "help", question: "comment-jouer" }],
+    ["#/glossaire", { screen: "glossary", term: null }],
+    ["#/glossaire/videau", { screen: "glossary", term: "videau" }],
+    ["#/a-propos", { screen: "about" }],
+    ["#/tutoriel", { screen: "tutorial", step: null, practice: false }],
+    ["#/tutoriel/3", { screen: "tutorial", step: 3, practice: false }],
+    ["#/tutoriel/3/a-vous", { screen: "tutorial", step: 3, practice: true }],
+    ["#/tutoriel/fin", { screen: "tutorialEnd" }],
+    ["#/installer", { screen: "install" }],
+    ["#/parties", { screen: "games", game: null }],
+    ["#/parties/mh2k3x-a1b2c3", { screen: "games", game: "mh2k3x-a1b2c3" }],
+    ["#/menu", { screen: "menu" }],
+    [
+        "#/position/4HPwATDgc%2FABMA/cAkAAAAAAAAA",
+        { screen: "position", position: START, match: MATCH },
+    ],
+    ["#/position/4HPwATDgc%2FABMA", { screen: "position", position: START, match: null }],
+];
+
+test("chaque adresse du tableau de l'ADR 0013 mène à son écran, et inversement", () => {
+    for (const [hash, route] of TABLE) {
+        assert.deepEqual(parseRoute(hash), route, hash);
+        assert.equal(routeHash(route), hash, hash);
+    }
+});
+
+test("une adresse vide ou « # » est la partie en cours ; une barre finale ne change rien", () => {
+    assert.deepEqual(parseRoute(""), { screen: "game" });
+    assert.deepEqual(parseRoute("#"), { screen: "game" });
+    assert.deepEqual(parseRoute("#/aide/"), { screen: "help", question: null });
+    assert.deepEqual(parseRoute("#/glossaire/blot/"), { screen: "glossary", term: "blot" });
+});
+
+test("une adresse inconnue est reconnue comme telle", () => {
+    for (const hash of [
+        "#/inconnu",
+        "#aide",
+        "#/aide/a/b",
+        "#/aide/Majuscules",
+        "#/menu/plus",
+        "#/tutoriel/0",
+        "#/tutoriel/x",
+        "#/tutoriel/3/b",
+        "#/tutoriel/3/a-vous/x",
+        "#/tutoriel/fin/a-vous",
+        "#/installer/x",
+        "#/a-propos/x",
+        "#/position",
+        "#/position/%E0%A4%A",
+    ]) {
+        assert.equal(parseRoute(hash).screen, "unknown", hash);
+    }
+    assert.equal(routeHash(parseRoute("#/inconnu")), "#/inconnu");
+});
+
+test("un lien de position collé sans encodage (+ et / du base64) est compris", () => {
+    assert.deepEqual(parseRoute(`#/position/${START}/${MATCH}`), {
+        screen: "position",
+        position: START,
+        match: MATCH,
+    });
+    assert.deepEqual(parseRoute("#/position/jGfkASjg8wcBMA/cAkAAAAAAAAA"), {
+        screen: "position",
+        position: "jGfkASjg8wcBMA",
+        match: MATCH,
+    });
+    // + reste un + (pas une espace), encodé ou non.
+    const plus = "AAAA+AAAAAAAAA";
+    assert.equal(
+        routeHash({ screen: "position", position: plus, match: null }),
+        "#/position/AAAA%2BAAAAAAAAA",
+    );
+    assert.deepEqual(parseRoute("#/position/AAAA%2BAAAAAAAAA"), {
+        screen: "position",
+        position: plus,
+        match: null,
+    });
+    assert.deepEqual(parseRoute(`#/position/${plus}`), {
+        screen: "position",
+        position: plus,
+        match: null,
+    });
+});
+
+test("un identifiant de position de mauvaise longueur arrive tel quel au moteur, qui jugera", () => {
+    assert.deepEqual(parseRoute("#/position/abc"), {
+        screen: "position",
+        position: "abc",
+        match: null,
+    });
+});
+
+test("l'identifiant d'une question : le titre sans accents ni ponctuation", () => {
+    assert.equal(slug("Jouer un coup, puis l'annuler"), "jouer-un-coup-puis-l-annuler");
+    assert.equal(slug("  Été : déjà vu ?  "), "ete-deja-vu");
+    assert.equal(
+        slug("Rejouer d'ici sans perdre l'original"),
+        "rejouer-d-ici-sans-perdre-l-original",
+    );
+});
+
+test("les écrans de l'aide : jouer, les mots du jeu, à propos", () => {
+    assert.ok(isHelpScreen(parseRoute("#/aide/x")));
+    assert.ok(isHelpScreen(parseRoute("#/glossaire")));
+    assert.ok(isHelpScreen(parseRoute("#/a-propos")));
+    assert.ok(!isHelpScreen(parseRoute("#/menu")));
+});
+
+test("quitter un écran revient à la dernière adresse qui n'en est pas", () => {
+    const help = (route: Route) => isHelpScreen(route);
+    // Partie, aide, une question : « Retour » remonte de deux pas.
+    assert.equal(stepsBack(["#/", "#/aide", "#/aide/q"], help), -2);
+    // Le menu ouvert depuis l'aide : on revient à l'aide.
+    const menu = (route: Route) => route.screen === "menu";
+    assert.equal(stepsBack(["#/", "#/aide", "#/menu"], menu), -1);
+    // Ouvert directement dans un nouvel onglet : rien avant, on remplace.
+    assert.equal(stepsBack(["#/aide/q"], help), null);
+    assert.equal(stepsBack(["#/aide", "#/glossaire/blot"], help), null);
+});

app/tests/steps/accueil.steps.ts

@@ -0,0 +1,181 @@
+// Étapes des scénarios docs/scenarios/decouvrir-l-application.feature et
+// installer-l-application.feature (ADR 0008) : l'accueil et l'invitation à
+// installer passent par les modules de l'interface qui les décident
+// (home-model.ts, settings.ts, install.ts), la partie par le domaine et le
+// vrai moteur, le tutoriel par son texte source.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { BeforeAll, Given, Then, When } from "@cucumber/cucumber";
+import type { Engine } from "../../src/domain/game/engine.js";
+import { Game } from "../../src/domain/game/game.js";
+import {
+    dismissInstall,
+    homeModel,
+    installMenuShown,
+    launchHash,
+    WELCOME_LINKS,
+    welcomed,
+} from "../../src/ui/home-model.js";
+import { HOME_TEXTS } from "../../src/ui/home-texts.js";
+import { installPlatform } from "../../src/ui/install.js";
+import { parseRoute } from "../../src/ui/router.js";
+import { parseSettings, type Settings } from "../../src/ui/settings.js";
+import { placeOf } from "../../src/ui/tutorial-nav.js";
+import { parseTutorial } from "../../src/ui/tutorial-text.js";
+import { loadNodeEngine } from "../support/node-engine.js";
+import { seededDice, step } from "../support/play.js";
+
+const root = new URL("../../../../", import.meta.url);
+
+let engine: Engine;
+let settings: Settings;
+let game: Game | null = null;
+let installed = false;
+let route = "";
+let installSteps: readonly string[] = [];
+
+BeforeAll(async () => {
+    engine = await loadNodeEngine();
+});
+
+/** Ce que montre l'accueil, la partie étant celle du scénario. */
+function home() {
+    const playing = game === null ? false : game.state.phase !== "over";
+    return homeModel(settings, playing, installed);
+}
+
+// ------------------------------------------------------- Premier lancement
+
+Given("vous ouvrez Ustagammon pour la toute première fois", () => {
+    settings = parseSettings(null);
+    game = null;
+    installed = false;
+});
+
+Then("l'accueil vous propose de découvrir les règles ou de jouer tout de suite", () => {
+    assert.equal(launchHash(""), "#/accueil");
+    assert.equal(parseRoute(launchHash("") ?? "").screen, "home");
+    assert.ok(home().welcome);
+    assert.equal(parseRoute(WELCOME_LINKS.play).screen, "game");
+});
+
+When("vous choisissez de découvrir les règles", () => {
+    settings = { ...settings, ...welcomed() };
+    route = WELCOME_LINKS.discover;
+});
+
+Then("le tutoriel s'ouvre à sa première étape", () => {
+    const tutorial = parseTutorial(readFileSync(new URL("docs/tutoriel/regles.md", root), "utf8"));
+    assert.deepEqual(placeOf(tutorial, parseRoute(route)), { step: 1, practice: false });
+});
+
+Then("ce choix ne vous est plus proposé", () => {
+    assert.ok(!home().welcome);
+});
+
+Given("vous avez choisi de jouer tout de suite", () => {
+    settings = { ...parseSettings(null), ...welcomed() };
+    installed = false;
+});
+
+Given("une partie est en cours", () => {
+    game = Game.start(engine, { dice: seededDice(11), ply: 0 });
+    settings = { ...settings, gamesStarted: settings.gamesStarted + 1 };
+});
+
+When("vous rouvrez Ustagammon", () => {
+    route = launchHash("") ?? "";
+});
+
+Then("l'accueil vous propose de reprendre votre partie", () => {
+    assert.equal(parseRoute(route).screen, "home");
+    assert.ok(home().resume);
+});
+
+When("la partie se termine", async () => {
+    assert.ok(game !== null);
+    for (let i = 0; game.state.phase !== "over"; i++) {
+        assert.ok(i < 2000, "la partie ne finit pas");
+        await step(game, engine);
+    }
+});
+
+Then("l'accueil vous propose une nouvelle partie", () => {
+    assert.equal(parseRoute(route).screen, "home");
+    assert.ok(!home().resume);
+});
+
+// ------------------------------------------------------------- Installation
+
+Given("votre navigateur ne propose pas lui-même l'installation", () => {
+    installSteps = [];
+});
+
+When("vous demandez à installer l'application avec Firefox", () => {
+    const firefox = "Mozilla/5.0 (Android 14; Mobile; rv:131.0) Gecko/131.0 Firefox/131.0";
+    installSteps = HOME_TEXTS.installSteps[installPlatform(firefox)];
+});
+
+When("vous demandez à installer l'application sur iPhone", () => {
+    const iphone =
+        "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 " +
+        "(KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1";
+    installSteps = HOME_TEXTS.installSteps[installPlatform(iphone)];
+});
+
+Then("la marche à suivre compte trois étapes, en commençant par le menu du navigateur", () => {
+    assert.equal(installSteps.length, 3);
+    assert.match(installSteps[0] ?? "", /menu du navigateur/);
+});
+
+Then("la marche à suivre compte trois étapes, en commençant par le bouton de partage", () => {
+    assert.equal(installSteps.length, 3);
+    assert.match(installSteps[0] ?? "", /bouton de partage/);
+});
+
+Then("l'accueil ne vous propose pas d'installer l'application", () => {
+    assert.ok(!home().installCard);
+});
+
+Then("l'accueil vous propose d'installer l'application", () => {
+    assert.ok(home().installCard);
+});
+
+When("vous terminez une partie", () => {
+    settings = { ...settings, gamesFinished: settings.gamesFinished + 1 };
+});
+
+When("vous terminez {int} parties de plus", (n: number) => {
+    settings = { ...settings, gamesFinished: settings.gamesFinished + n };
+});
+
+When("vous choisissez « Plus tard »", () => {
+    settings = { ...settings, ...dismissInstall(settings) };
+});
+
+Then("le menu vous le propose toujours", () => {
+    assert.ok(installMenuShown(settings, installed));
+});
+
+Given("vous avez terminé une partie", () => {
+    settings = { ...parseSettings(null), welcomed: true, gamesFinished: 1 };
+    installed = false;
+    assert.ok(home().installCard);
+});
+
+When("vous installez l'application", () => {
+    // L'événement appinstalled du navigateur, retenu dans les réglages.
+    installed = true;
+    settings = { ...settings, installed: true };
+});
+
+Then("le menu non plus", () => {
+    assert.ok(!installMenuShown(settings, installed));
+    // Même dans un onglet ouvert plus tard, hors de l'application installée.
+    assert.ok(!installMenuShown(settings, false));
+    assert.ok(!homeModel(settings, true, false).installCard);
+});

app/tests/steps/apprendre-les-regles.steps.ts

@@ -0,0 +1,132 @@
+// Étapes du scénario docs/scenarios/apprendre-les-regles.feature (ADR 0008) :
+// le texte du tutoriel est lu dans sa source (docs/tutoriel/regles.md), et
+// chaque geste est jugé par le domaine branché sur le vrai moteur, comme
+// dans l'application.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { BeforeAll, Given, Then, When } from "@cucumber/cucumber";
+import type { Engine } from "../../src/domain/game/engine.js";
+import {
+    MovePractice,
+    type PracticeVerdict,
+    shouldTake,
+    tutorialBoard,
+} from "../../src/domain/learning/tutorial.js";
+import { progress, seenAfter, type TutorialPlace } from "../../src/ui/tutorial-nav.js";
+import { parseTutorial, type Tutorial, type TutorialScreen } from "../../src/ui/tutorial-text.js";
+import { loadNodeEngine } from "../support/node-engine.js";
+
+const root = new URL("../../../../", import.meta.url);
+
+let engine: Engine;
+let tutorial: Tutorial;
+let seen = 0;
+let place: TutorialPlace = { step: 1, practice: false };
+let screen: TutorialScreen;
+let practice: MovePractice | null = null;
+let verdict: PracticeVerdict = "continue";
+let answeredRight = false;
+
+BeforeAll(async () => {
+    engine = await loadNodeEngine();
+    tutorial = parseTutorial(readFileSync(new URL("docs/tutoriel/regles.md", root), "utf8"));
+});
+
+Given("vous commencez le tutoriel", () => {
+    seen = 0;
+    place = { step: 1, practice: false };
+    seen = seenAfter(seen, place);
+});
+
+Then("il compte huit étapes, dont quatre où c'est à vous de jouer", () => {
+    assert.equal(tutorial.steps.length, 8);
+    assert.equal(tutorial.steps.filter((s) => s.practice !== null).length, 4);
+});
+
+Then("chaque position du tutoriel se lit sur le plateau", async () => {
+    for (const step of tutorial.steps) {
+        for (const current of [step.explain, step.practice]) {
+            if (current !== null) {
+                const board = await tutorialBoard(engine, current.position, current.onRoll);
+                assert.equal(board.sides.player.points.length, 24);
+            }
+        }
+    }
+});
+
+When("vous arrivez à l'étape {int}", (n: number) => {
+    for (let step = 1; step <= n; step++) {
+        place = { step, practice: false };
+        seen = seenAfter(seen, place);
+    }
+});
+
+Then("la barre de progression vous ramène aux étapes 1 et 2, mais pas aux suivantes", () => {
+    const links = progress(tutorial.steps.length, place, seen)
+        .filter((segment) => segment.link)
+        .map((segment) => segment.step);
+    assert.deepEqual(links, [1, 2]);
+});
+
+Given("vous êtes à l'écran « à vous » de l'étape {int}", async (n: number) => {
+    const found = tutorial.steps[n - 1]?.practice;
+    assert.ok(found != null, `l'étape ${n} n'a pas d'écran « à vous »`);
+    screen = found;
+    practice =
+        screen.roll === null || screen.expected.length === 0
+            ? null
+            : await MovePractice.start(engine, screen.position, screen.roll, screen.expected);
+    verdict = "continue";
+    answeredRight = false;
+});
+
+When(
+    "vous déplacez un pion de la flèche {int} à la flèche {int}",
+    async (from: number, to: number) => {
+        assert.ok(practice !== null);
+        verdict = await practice.play({ from, to });
+        if (verdict === "wrong") {
+            practice.reset();
+        }
+    },
+);
+
+Then("le pion revient, et une phrase vous dit pourquoi", () => {
+    assert.equal(verdict, "wrong");
+    assert.deepEqual(practice?.pendingHalfMoves, []);
+    assert.ok(screen.wrong.map((part) => part.text).join("").length > 20);
+});
+
+When("vous réunissez deux pions sur la flèche 5", async () => {
+    assert.ok(practice !== null);
+    verdict = await practice.play({ from: 8, to: 5 });
+    assert.equal(verdict, "continue");
+    verdict = await practice.play({ from: 6, to: 5 });
+});
+
+Then("le tutoriel salue votre coup", () => {
+    assert.equal(verdict, "right");
+    assert.ok(screen.right.length > 0);
+});
+
+When("vous répondez « Passer »", async () => {
+    answeredRight = (await shouldTake(engine, screen.position)) === false;
+});
+
+When("vous répondez « Prendre »", async () => {
+    answeredRight = (await shouldTake(engine, screen.position)) === true;
+});
+
+Then("le maître dit qu'il aurait pris", () => {
+    assert.ok(!answeredRight);
+    assert.match(screen.wrong.map((part) => part.text).join(""), /Le maître prendrait/);
+});
+
+Then("le tutoriel salue votre réponse", () => {
+    assert.ok(answeredRight);
+    assert.match(screen.right.map((part) => part.text).join(""), /Le maître prend aussi/);
+});

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

@@ -19,6 +19,7 @@ import {
 } from "../../src/domain/game/position.js";
 import { fixedDice } from "../../src/domain/game/roll.js";
 import type { GameState } from "../../src/domain/game/state.js";
+import { boardModel, pipLead } from "../../src/ui/board-model.js";
 import { loadNodeEngine } from "../support/node-engine.js";
 
 // Le chargement du moteur prend une à deux secondes sur le PC de 2011.
@@ -283,7 +284,7 @@ Then("c'est toujours à vous", () => {
     assert.equal(lastEvent().type, "DiceRolled");
 });
 
-When("vous continuez", async () => {
+When("vous laissez passer votre tour", async () => {
     await game.skipTurn();
     const event = lastEvent();
     assert.ok(event.type === "MovePlayed" && event.side === "player");
@@ -344,6 +345,27 @@ Then("vous pouvez revoir son coup", async () => {
     assert.deepEqual(await game.lastMoveSteps(), computerMove);
 });
 
+// ------------------------------------------------------- Compte de points
+
+// Les bandeaux lisent le compte de points du plateau donné par le moteur ;
+// qui mène se calcule dans l'interface (board-model.ts).
+
+async function pips() {
+    return boardModel(await game.displayedBoard()).pipCount;
+}
+
+Then("chaque camp a un compte de points de {int}", async (n: number) => {
+    assert.deepEqual(await pips(), { player: n, computer: n });
+});
+
+Then("personne ne mène la course", async () => {
+    assert.equal(pipLead(await pips()).leader, null);
+});
+
+Then("vous menez la course de {int}", async (n: number) => {
+    assert.deepEqual(pipLead(await pips()), { leader: "player", by: n });
+});
+
 // ------------------------------------------------------------------ Videau
 
 // La confirmation elle-même est une question de l'interface (une fenêtre

app/tests/steps/mes-parties.steps.ts

@@ -0,0 +1,203 @@
+// Étapes du scénario docs/scenarios/mes-parties.feature (ADR 0008) : elles
+// pilotent le domaine, branché sur le vrai moteur WebAssembly, et le
+// stockage des parties sur un localStorage simulé en mémoire. Fermer puis
+// rouvrir l'application revient à rouvrir ce stockage et à reprendre la
+// partie en cours, comme main.ts au démarrage.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { Before, Given, Then, When } from "@cucumber/cucumber";
+import type { Engine } from "../../src/domain/game/engine.js";
+import type { GameJournal, MovePlayed } from "../../src/domain/game/events.js";
+import { Game } from "../../src/domain/game/game.js";
+import { exportSgf } from "../../src/domain/game/sgf.js";
+import type { GameLibrary } from "../../src/storage/game-library.js";
+import type { KeyValueStorage } from "../../src/storage/key-value-backend.js";
+import { memoryStorage, openGameLibrary } from "../../src/storage/open-library.js";
+import { loadNodeEngine } from "../support/node-engine.js";
+import { playMoves, seededDice } from "../support/play.js";
+
+let engine: Engine;
+let storage: KeyValueStorage;
+let library: GameLibrary;
+let game: Game;
+let shownId: string;
+/** Les parties jouées, dans l'ordre : identifiant et journal laissé. */
+let played: { id: string; journal: GameJournal }[];
+/** La partie d'origine, avant « Rejouer d'ici ». */
+let original: { head: string; ids: string[] };
+/** Le coup du joueur d'où l'on rejoue. */
+let replayed: MovePlayed;
+let sgf: string;
+let nextSeed = 1;
+
+Before(async () => {
+    engine = await loadNodeEngine();
+    storage = memoryStorage();
+    library = (await openGameLibrary({ localStorage: storage })).library;
+    played = [];
+});
+
+/** Commence une partie, comme l'application : un nouvel identifiant. */
+function startGame(): void {
+    game = Game.start(engine, { dice: seededDice(nextSeed), ply: 0 });
+    shownId = `partie-${nextSeed++}`;
+}
+
+/** Joue des coups, en enregistrant après chacun comme l'application. */
+async function play(moves: number): Promise<void> {
+    for (let i = 0; i < moves; i++) {
+        await playMoves(game, engine, 1);
+        await library.save(shownId, game.journal, { level: "0ply" });
+    }
+}
+
+async function reopen(): Promise<void> {
+    library = (await openGameLibrary({ localStorage: storage })).library;
+    const saved = await library.current();
+    assert.ok(saved !== null, "aucune partie en cours");
+    game = Game.resume(engine, saved.journal, { ply: 0 });
+    shownId = saved.summary.id;
+}
+
+/** « Rejouer d'ici » : revient juste avant le deuxième coup du joueur (ses
+ * dés déjà lancés). Renvoie ce coup. */
+function goBackToSecondMove(): MovePlayed {
+    original = { head: game.journal.head as string, ids: game.events.map((e) => e.id) };
+    const second = game.events.filter(
+        (e): e is MovePlayed => e.type === "MovePlayed" && e.side === "player",
+    )[1];
+    assert.ok(second?.parent != null, "moins de deux coups du joueur");
+    game.goBackTo(second.parent);
+    return second;
+}
+
+/** Joue, avec les mêmes dés, un coup légal qui mène ailleurs que first. */
+async function playAnotherMove(first: MovePlayed): Promise<void> {
+    const state = game.state;
+    assert.ok(state.roll !== null);
+    const moves = await engine.legalMoves(state.position, state.roll);
+    // Move.position est vue de celui qui joue, MovePlayed.position de son
+    // adversaire : on compare les demi-coups.
+    const same = (m: (typeof moves)[number]) =>
+        m.halfMoves.length === first.halfMoves.length &&
+        m.halfMoves.every((h, i) => h.from === first.halfMoves[i]?.from);
+    const move = moves.find((m) => !same(m));
+    assert.ok(move !== undefined, "un seul coup possible");
+    for (const halfMove of move.halfMoves) {
+        assert.ok(await game.playHalfMove(halfMove));
+    }
+    await game.confirmMove();
+    await library.save(shownId, game.journal, { level: "0ply" });
+    const last = game.events.at(-1);
+    assert.ok(last?.type === "MovePlayed" && last.position !== first.position);
+}
+
+// ------------------------------------------- Reprendre une partie parmi plusieurs
+
+Given("vous avez joué deux parties, l'une après l'autre", async () => {
+    for (const moves of [5, 3]) {
+        startGame();
+        await play(moves);
+        played.push({ id: shownId, journal: game.journal });
+    }
+});
+
+When("vous fermez l'application puis la rouvrez", reopen);
+
+Then("la dernière partie jouée est à l'écran", () => {
+    const last = played.at(-1);
+    assert.equal(shownId, last?.id);
+    assert.deepEqual(game.journal, last?.journal);
+});
+
+Then("« Mes parties » montre vos deux parties, la dernière jouée en premier", async () => {
+    const ids = (await library.list()).map((s) => s.id);
+    assert.deepEqual(ids, played.map((p) => p.id).reverse());
+});
+
+When("vous reprenez la première partie", async () => {
+    await library.setCurrent(played[0]?.id as string);
+    await reopen();
+});
+
+Then("elle est à l'écran, telle que vous l'aviez laissée", () => {
+    assert.equal(shownId, played[0]?.id);
+    assert.deepEqual(game.journal, played[0]?.journal);
+});
+
+// ------------------------------------------- Rejouer d'ici sans perdre l'original
+
+Given("vous avez joué plusieurs coups", async () => {
+    startGame();
+    await play(8);
+});
+
+When("vous rejouez d'ici à partir de votre deuxième coup", () => {
+    // Le retour seul : le coup suivant ouvrira la branche.
+    replayed = goBackToSecondMove();
+});
+
+When("vous choisissez un autre coup", async () => {
+    await playAnotherMove(replayed);
+});
+
+Then("la partie a deux branches", () => {
+    assert.equal(game.branches.length, 2);
+});
+
+Then("la partie d'origine est intacte", () => {
+    const origin = game.branches.find((b) => b.forkedFrom === null);
+    assert.equal(origin?.head, original.head);
+    const copy = Game.resume(engine, game.journal);
+    copy.switchBranch(original.head);
+    assert.deepEqual(
+        copy.events.map((e) => e.id),
+        original.ids,
+    );
+});
+
+Then("vous êtes sur la nouvelle branche", () => {
+    const current = game.branches.find((b) => b.containsHead);
+    assert.ok(current !== undefined && current.forkedFrom !== null);
+    assert.equal(current.head, game.journal.head);
+});
+
+Then("vous pouvez revenir à la partie d'origine, au coup près", () => {
+    const branch = game.branches.find((b) => b.forkedFrom === null);
+    assert.ok(branch !== undefined);
+    game.switchBranch(branch.head);
+    assert.deepEqual(
+        game.events.map((e) => e.id),
+        original.ids,
+    );
+});
+
+// ------------------------------------------------------------ Exporter une partie
+
+Given("vous avez rejoué d'ici une autre suite", async () => {
+    await playAnotherMove(goBackToSecondMove());
+    await play(2);
+});
+
+When("vous exportez la partie", async () => {
+    sgf = await exportSgf(engine, game.journal, {
+        playerName: "Vous",
+        computerName: "Ustagammon",
+    });
+});
+
+Then("vous obtenez un fichier SGF de GNU Backgammon", () => {
+    assert.ok(sgf.startsWith("(;FF[4]GM[6]"), sgf.slice(0, 40));
+    assert.ok(sgf.trimEnd().endsWith(")"));
+});
+
+Then("il contient vos coups, et l'autre branche en variante", () => {
+    // Un nœud par coup joué, toutes branches comprises (B ou W, puis les
+    // dés), et deux variantes à l'embranchement.
+    const moves = game.journal.events.filter((e) => e.type === "MovePlayed").length;
+    assert.equal(sgf.match(/;[BW]\[\d\d/g)?.length, moves);
+    assert.equal(sgf.match(/\(\n;/g)?.length, 2);
+});

app/tests/steps/partager-une-position.steps.ts

@@ -0,0 +1,171 @@
+// Étapes du scénario docs/scenarios/partager-une-position.feature (ADR 0008,
+// ADR 0013) : le lien passe par le routeur de l'interface (adresse écrite
+// puis relue), la position par le domaine et le vrai moteur WebAssembly, et
+// les parties par le même enregistrement que l'application.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { Before, BeforeAll, Given, Then, When } from "@cucumber/cucumber";
+import type { Engine } from "../../src/domain/game/engine.js";
+import type { GameJournal } from "../../src/domain/game/events.js";
+import { Game } from "../../src/domain/game/game.js";
+import {
+    linkOf,
+    readPosition,
+    type SharedPosition,
+    setupOf,
+    UnreadableLinkError,
+} from "../../src/domain/game/position-link.js";
+import { createGameLibrary, type GameLibrary } from "../../src/storage/game-library.js";
+import { createGameSession, type GameSession } from "../../src/storage/game-session.js";
+import { createKeyValueBackend } from "../../src/storage/key-value-backend.js";
+import { memoryStorage } from "../../src/storage/open-library.js";
+import { parseRoute, routeHash } from "../../src/ui/router.js";
+import { loadNodeEngine } from "../support/node-engine.js";
+import { playMoves, seededDice, step } from "../support/play.js";
+
+let engine: Engine;
+let library: GameLibrary;
+let session: GameSession;
+let game: Game;
+let gameId: string | null;
+let journalBefore: GameJournal;
+let address: string;
+let shared: SharedPosition | null;
+let failure: unknown;
+
+/** Une position de milieu de partie (gnubg), vue du joueur au trait. */
+const MIDDLE_GAME = "jGfkASjg8wcBMA";
+
+BeforeAll(async () => {
+    engine = await loadNodeEngine();
+});
+
+Before(() => {
+    library = createGameLibrary(createKeyValueBackend(memoryStorage()));
+    session = createGameSession(
+        library,
+        {
+            start: (setup) =>
+                Game.start(engine, { dice: seededDice(7), ply: 0, ...(setup ? { setup } : {}) }),
+            resume: (journal) => Game.resume(engine, journal, { ply: 0 }),
+        },
+        "0ply",
+    );
+    shared = null;
+    failure = null;
+});
+
+/** Ouvre une adresse comme l'application : le routeur la lit, le moteur
+ * lit la position. */
+async function open(hash: string): Promise<void> {
+    const route = parseRoute(hash);
+    assert.equal(route.screen, "position", `adresse non reconnue : ${hash}`);
+    if (route.screen !== "position") {
+        return;
+    }
+    try {
+        shared = await readPosition(engine, { position: route.position, matchId: route.match });
+    } catch (error) {
+        failure = error;
+    }
+}
+
+Given("votre partie en cours compte quelques coups", async () => {
+    game = session.newGame();
+    // Des coups jusqu'à ce que ce soit à vous de lancer les dés.
+    await playMoves(game, engine, 4);
+    const yourRoll = () => game.state.turn === "player" && game.state.phase === "rolling";
+    while (!yourRoll() && game.state.phase !== "over") {
+        await step(game, engine);
+    }
+    assert.ok(yourRoll(), "partie finie trop tôt");
+    session.save(game.journal);
+    gameId = session.shownId;
+    journalBefore = game.journal;
+});
+
+When("vous copiez le lien de la position", async () => {
+    const link = await linkOf(engine, game.state);
+    address = routeHash({ screen: "position", position: link.position, match: link.matchId });
+});
+
+Then("le lien contient l'identifiant de la position et celui du match", () => {
+    const route = parseRoute(address);
+    assert.ok(route.screen === "position");
+    assert.equal(route.position, game.state.position);
+    assert.equal(route.match?.length, 12);
+    assert.match(address, /^#\/position\/[A-Za-z0-9%]{14,}\/[A-Za-z0-9%]{12,}$/);
+});
+
+When("vous ouvrez ce lien", async () => {
+    await open(address);
+});
+
+Then("vous voyez exactement la même position, avec le même videau", async () => {
+    assert.ok(shared !== null, `lien illisible : ${failure}`);
+    assert.deepEqual(shared.sides, await game.displayedBoard());
+    assert.deepEqual(shared.cube, game.state.cube);
+    assert.equal(shared.match, null);
+});
+
+When("vous ouvrez un lien vers une position où le videau est à 2, chez l'ordinateur", async () => {
+    const matchId = await engine.encodeMatch({ value: 2, owner: "opponent" });
+    address = routeHash({ screen: "position", position: MIDDLE_GAME, match: matchId });
+    await open(address);
+});
+
+Then("vous voyez cette position, avec la main", async () => {
+    assert.ok(shared !== null, `lien illisible : ${failure}`);
+    const board = await engine.board(MIDDLE_GAME, { value: 2, owner: "opponent" });
+    assert.deepEqual(shared.sides, { player: board.onRoll, computer: board.opponent });
+    assert.equal(shared.result, null);
+});
+
+Then("votre partie n'a pas changé", () => {
+    assert.equal(session.shownId, gameId);
+    assert.deepEqual(game.journal, journalBefore);
+});
+
+When("vous choisissez « Jouer à partir d'ici »", () => {
+    assert.ok(shared !== null);
+    game = session.newGame(setupOf(shared));
+    session.save(game.journal);
+});
+
+Then("une nouvelle partie commence à cette position, à vous de lancer les dés", () => {
+    assert.notEqual(session.shownId, gameId);
+    assert.equal(game.state.position, MIDDLE_GAME);
+    assert.equal(game.state.turn, "player");
+    assert.equal(game.state.phase, "rolling");
+});
+
+Then("le videau est à 2, chez l'ordinateur", () => {
+    assert.deepEqual(game.state.cube, { value: 2, owner: "computer" });
+});
+
+Then("votre partie précédente est toujours enregistrée", async () => {
+    assert.ok(gameId !== null);
+    const saved = await library.load(gameId);
+    assert.deepEqual(saved?.journal, journalBefore);
+});
+
+When("vous ouvrez un lien dont l'identifiant de position est abîmé", async () => {
+    // Coupé d'un caractère, puis un caractère hors du base64.
+    shared = null;
+    failure = null;
+    await open("#/position/4HPwATDgc%2FAB%2A/cAkAAAAAAAAA");
+});
+
+When("vous ouvrez un lien dont l'identifiant de match est abîmé", async () => {
+    shared = null;
+    failure = null;
+    await open("#/position/4HPwATDgc%2FABMA/cAk*");
+});
+
+Then("le lien est déclaré illisible", () => {
+    assert.equal(shared, null);
+    assert.ok(failure instanceof UnreadableLinkError, `erreur inattendue : ${failure}`);
+});

app/tests/steps/regler-l-application.steps.ts

@@ -0,0 +1,210 @@
+// Étapes du scénario docs/scenarios/regler-l-application.feature (ADR 0008) :
+// la partie reprise passe par le domaine et le vrai moteur, et par le même
+// enregistrement que l'application ; les réglages et les vibrations par les
+// modules de l'interface qui les portent (settings.ts, haptics.ts).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { BeforeAll, Given, setDefaultTimeout, Then, When } from "@cucumber/cucumber";
+import type { Engine } from "../../src/domain/game/engine.js";
+import type { GameJournal } from "../../src/domain/game/events.js";
+import { Game } from "../../src/domain/game/game.js";
+import { parseHalfMoves, START_POSITION } from "../../src/domain/game/position.js";
+import { fixedDice } from "../../src/domain/game/roll.js";
+import { createGameLibrary, type GameLibrary } from "../../src/storage/game-library.js";
+import { createGameSession, type GameSession } from "../../src/storage/game-session.js";
+import { createKeyValueBackend } from "../../src/storage/key-value-backend.js";
+import { memoryStorage } from "../../src/storage/open-library.js";
+import { BANNER_MS } from "../../src/ui/app.js";
+import { createHaptics } from "../../src/ui/haptics.js";
+import { nextTheme, parseSettings, type Settings } from "../../src/ui/settings.js";
+import { betweenTurns, updateBannerShown } from "../../src/ui/updates.js";
+import { loadNodeEngine } from "../support/node-engine.js";
+
+setDefaultTimeout(30_000);
+
+let engine: Engine;
+let game: Game;
+let oldJournal: GameJournal;
+let oldBoard: unknown;
+let settings: Settings;
+let vibrations: number[][] = [];
+
+BeforeAll(async () => {
+    engine = await loadNodeEngine();
+});
+
+// -------------------------------------------------- Nouvelle partie annulable
+
+// Comme dans l'application : chaque partie est enregistrée par la session
+// (ici sur un stockage en mémoire), et l'ancienne est relue dans le
+// stockage par son identifiant.
+let library: GameLibrary;
+let session: GameSession;
+let oldId: string | null;
+
+Given("une partie est en cours depuis quelques coups", async () => {
+    library = createGameLibrary(createKeyValueBackend(memoryStorage()));
+    let dice = fixedDice([3, 1, 6, 4, 5, 2]);
+    session = createGameSession(
+        library,
+        {
+            start: () => Game.start(engine, { dice }),
+            resume: (journal) => Game.resume(engine, journal, { dice }),
+        },
+        "2ply",
+    );
+    game = session.newGame();
+    dice = () => 1 + Math.floor(Math.random() * 6);
+    for (const halfMove of parseHalfMoves("8/5 6/5")) {
+        assert.ok(await game.playHalfMove(halfMove));
+    }
+    await game.confirmMove();
+    await game.playComputerTurn();
+    session.save(game.journal);
+    oldId = session.shownId;
+    assert.equal(game.state.turn, "player");
+});
+
+When("vous commencez une nouvelle partie depuis le menu", async () => {
+    oldJournal = game.journal;
+    oldBoard = await game.displayedBoard();
+    game = session.newGame();
+    session.save(game.journal);
+});
+
+Then("une nouvelle partie commence aussitôt", () => {
+    assert.equal(game.state.position, START_POSITION);
+    assert.ok(game.events.every((e) => e.type === "GameStarted" || e.type === "DiceRolled"));
+});
+
+Then("l'ancienne partie peut être reprise pendant {int} secondes", (seconds: number) => {
+    assert.equal(BANNER_MS, seconds * 1000);
+});
+
+When("vous reprenez l'ancienne partie", async () => {
+    const old = await session.resumePrevious();
+    assert.ok(old !== null);
+    game = old;
+    session.save(game.journal);
+});
+
+Then("vous retrouvez exactement la partie quittée", async () => {
+    assert.equal(session.shownId, oldId);
+    assert.deepEqual((await library.current())?.journal, oldJournal);
+    // La nouvelle partie, abandonnée, est supprimée.
+    assert.deepEqual(
+        (await library.list()).map((s) => s.id),
+        [oldId],
+    );
+    assert.deepEqual(game.journal, oldJournal);
+    assert.deepEqual(await game.displayedBoard(), oldBoard);
+    assert.equal(game.state.turn, "player");
+    assert.equal(game.state.phase, "rolling");
+});
+
+// --------------------------------------------------------------- Réglages
+
+Given("vous ouvrez l'application pour la première fois", () => {
+    settings = parseSettings(null);
+    vibrations = [];
+});
+
+const haptic = createHaptics(
+    (pattern) => {
+        vibrations.push(pattern);
+        return true;
+    },
+    () => settings.vibrations,
+);
+
+When("un pion est frappé", () => {
+    vibrations = [];
+    haptic("checkerHit");
+});
+
+Then("le téléphone vibre deux fois, brièvement", () => {
+    assert.deepEqual(vibrations, [[25, 40, 25]]);
+});
+
+When("vous coupez les vibrations dans le menu", () => {
+    settings = { ...settings, vibrations: false };
+});
+
+Then("le téléphone ne vibre pas", () => {
+    assert.deepEqual(vibrations, []);
+});
+
+Then("l'écran reste allumé pendant une partie", () => {
+    assert.equal(settings.keepScreenOn, true);
+});
+
+When("vous coupez « Écran allumé pendant la partie » dans le menu", () => {
+    settings = parseSettings(JSON.stringify({ ...settings, keepScreenOn: false }));
+});
+
+Then("l'écran peut se mettre en veille comme d'habitude", () => {
+    assert.equal(settings.keepScreenOn, false);
+});
+
+Then("le thème suit celui du téléphone", () => {
+    assert.equal(settings.theme, "auto");
+});
+
+When("vous changez de thème dans le menu", () => {
+    // Rien : l'étape suivante fait le tour des thèmes.
+});
+
+Then("il passe à clair, puis à sombre, puis revient à automatique", () => {
+    const seen = [settings.theme];
+    for (let i = 0; i < 3; i++) {
+        seen.push(nextTheme(seen.at(-1) ?? "auto"));
+    }
+    assert.deepEqual(seen, ["auto", "light", "dark", "auto"]);
+});
+
+// ------------------------------------------------------------ Mise à jour
+
+// Le bandeau dépend de deux choses : une version attend (le service worker
+// l'a installée), et la partie est entre deux tours. La partie est celle du
+// domaine, sur le vrai moteur.
+let updateAvailable = false;
+
+Given("une nouvelle version d'Ustagammon est disponible", () => {
+    updateAvailable = true;
+});
+
+const shownNow = (otherBanner = false) =>
+    updateBannerShown(
+        updateAvailable,
+        betweenTurns(game.state.phase, game.pendingHalfMoves.length),
+        otherBanner,
+    );
+
+Given("vous avez des dés à jouer", () => {
+    // Jet d'ouverture 3-1 : vous commencez.
+    game = Game.start(engine, { dice: fixedDice([3, 1, 6, 4, 5, 2]), ply: 0 });
+    assert.equal(game.state.turn, "player");
+    assert.equal(game.state.phase, "moving");
+});
+
+When("vous déplacez un pion de votre coup", async () => {
+    assert.ok(await game.playHalfMove({ from: 8, to: 5 }));
+});
+
+Then("l'application ne vous propose pas encore de mettre à jour", () => {
+    assert.ok(!shownNow());
+});
+
+When("vous avez joué votre coup", async () => {
+    assert.ok(await game.playHalfMove({ from: 6, to: 5 }));
+    await game.confirmMove();
+});
+
+Then("l'application vous propose de mettre à jour", () => {
+    assert.ok(shownNow());
+    // Jamais par-dessus le bandeau « Reprendre l'ancienne ».
+    assert.ok(!shownNow(true));
+});

app/tests/storage.test.ts

@@ -0,0 +1,267 @@
+// Tests du stockage des parties (src/storage/), sans navigateur : la
+// bibliothèque de parties sur un stockage clé-valeur en mémoire (le repli
+// de localStorage), la migration de la partie des versions précédentes et
+// le choix du stockage. IndexedDB, absent de Node, est essayé dans un vrai
+// navigateur (tests/browser/play.mjs).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { branches } from "../src/domain/game/branches.js";
+import type { Engine } from "../src/domain/game/engine.js";
+import {
+    appendEvent,
+    EMPTY_JOURNAL,
+    type GameJournal,
+    goBackTo,
+} from "../src/domain/game/events.js";
+import { Game } from "../src/domain/game/game.js";
+import { START_POSITION } from "../src/domain/game/position.js";
+import { fixedDice } from "../src/domain/game/roll.js";
+import { createGameLibrary, isJournal, newGameId } from "../src/storage/game-library.js";
+import { createGameSession } from "../src/storage/game-session.js";
+import {
+    createKeyValueBackend,
+    type KeyValueStorage,
+    migrateLegacyGame,
+} from "../src/storage/key-value-backend.js";
+import { memoryStorage, openGameLibrary } from "../src/storage/open-library.js";
+
+/** Une partie commencée, et éventuellement quelques événements de plus. */
+function journal(extraRolls = 0): GameJournal {
+    let j = appendEvent(EMPTY_JOURNAL, {
+        type: "GameStarted",
+        position: START_POSITION,
+        cube: { value: 1, owner: null },
+        firstTurn: null,
+    });
+    for (let i = 0; i < extraRolls; i++) {
+        j = appendEvent(j, { type: "DiceRolled", side: null, roll: [3, 3] });
+    }
+    return j;
+}
+
+/** Une horloge qui avance d'une seconde à chaque lecture. */
+function clock(start = 1_000_000): () => number {
+    let t = start;
+    return () => {
+        t += 1000;
+        return t;
+    };
+}
+
+function library(storage: KeyValueStorage = memoryStorage()) {
+    return createGameLibrary(createKeyValueBackend(storage), { now: clock() });
+}
+
+test("plusieurs parties : liste, chargement, dernière jouée d'abord", async () => {
+    const games = library();
+    assert.deepEqual(await games.list(), []);
+    assert.equal(await games.current(), null);
+
+    const a = await games.save("a", journal(), { level: "2ply" });
+    await games.save("b", journal(1), { level: "beginner" });
+    assert.deepEqual(
+        (await games.list()).map((s) => s.id),
+        ["b", "a"],
+    );
+    assert.equal(a.status, "playing");
+    assert.equal(a.result, null);
+    assert.equal(a.moveCount, 0);
+    assert.equal(a.branchCount, 1);
+
+    // Rejouer « a » la remet en tête ; sa date de début ne change pas.
+    const again = await games.save("a", journal(2), { level: "2ply" });
+    assert.equal(again.startedAt, a.startedAt);
+    assert.ok(again.updatedAt > a.updatedAt);
+    assert.deepEqual(
+        (await games.list()).map((s) => s.id),
+        ["a", "b"],
+    );
+    assert.deepEqual((await games.load("a"))?.journal, journal(2));
+    assert.equal((await games.load("b"))?.summary.level, "beginner");
+    assert.equal(await games.load("inconnue"), null);
+});
+
+test("partie en cours : la dernière enregistrée, ou celle qu'on reprend", async () => {
+    const games = library();
+    await games.save("ancienne", journal(), { level: "2ply" });
+    await games.save("nouvelle", journal(1), { level: "2ply" });
+    assert.equal((await games.current())?.summary.id, "nouvelle");
+
+    // « Reprendre l'ancienne » : elle redevient la partie en cours, sans
+    // être modifiée ; la nouvelle peut être supprimée.
+    const before = await games.load("ancienne");
+    await games.setCurrent("ancienne");
+    await games.remove("nouvelle");
+    assert.deepEqual(await games.current(), before);
+    assert.deepEqual(
+        (await games.list()).map((s) => s.id),
+        ["ancienne"],
+    );
+    await assert.rejects(games.setCurrent("nouvelle"), /introuvable/);
+
+    // La partie en cours supprimée : la dernière jouée la remplace.
+    await games.save("autre", journal(), { level: "2ply" });
+    await games.setCurrent("ancienne");
+    await games.remove("ancienne");
+    assert.equal((await games.current())?.summary.id, "autre");
+});
+
+test("les opérations sont faites dans l'ordre des appels", async () => {
+    const games = library();
+    // Lancées sans attendre, comme l'enregistrement après chaque action.
+    void games.save("a", journal(), { level: "2ply" });
+    void games.save("a", journal(3), { level: "2ply" });
+    void games.remove("a");
+    void games.save("b", journal(), { level: "2ply" });
+    assert.deepEqual(
+        (await games.list()).map((s) => s.id),
+        ["b"],
+    );
+});
+
+test("les branches et le résultat sont résumés", async () => {
+    const games = library();
+    let j = journal(2);
+    j = goBackTo(j, "2");
+    j = appendEvent(j, { type: "DiceRolled", side: null, roll: [5, 2] });
+    j = appendEvent(j, {
+        type: "MovePlayed",
+        side: "player",
+        halfMoves: [],
+        position: START_POSITION,
+    });
+    j = appendEvent(j, { type: "GameEnded", winner: "player", kind: "gammon", points: 2 });
+    const summary = await games.save("x", j, { level: "2ply" });
+    assert.equal(summary.branchCount, 2);
+    assert.equal(summary.moveCount, 1);
+    assert.equal(summary.status, "over");
+    assert.deepEqual(summary.result, { winner: "player", kind: "gammon", points: 2 });
+});
+
+test("un journal illisible n'est pas chargé ; un stockage plein ne casse rien", async () => {
+    const storage = memoryStorage();
+    const games = library(storage);
+    await games.save("a", journal(), { level: "2ply" });
+    storage.setItem("ustagammon.game.a", "{pas du JSON");
+    assert.equal(await games.load("a"), null);
+    assert.equal(isJournal({ events: [], head: 3 }), false);
+    assert.equal(isJournal(null), false);
+
+    const full = library({
+        getItem: () => null,
+        setItem: () => {
+            throw new Error("plein");
+        },
+        removeItem: () => {},
+    });
+    await assert.rejects(full.save("a", journal(), { level: "2ply" }), /plein/);
+    // La bibliothèque reste utilisable après un échec.
+    assert.deepEqual(await full.list(), []);
+});
+
+test("la partie des versions précédentes est migrée, une seule fois", async () => {
+    const storage = memoryStorage();
+    const old = journal(1);
+    storage.setItem("ustagammon.current-game", JSON.stringify(old));
+    const games = library(storage);
+    const id = await migrateLegacyGame(storage, games, 42);
+    assert.ok(id !== null);
+    assert.equal(storage.getItem("ustagammon.current-game"), null);
+    const current = await games.current();
+    assert.equal(current?.summary.id, id);
+    assert.deepEqual(current?.journal, old);
+    assert.equal(await migrateLegacyGame(storage, games), null);
+    assert.equal((await games.list()).length, 1);
+
+    // Un ancien enregistrement illisible est seulement effacé.
+    storage.setItem("ustagammon.current-game", "{pas du JSON");
+    assert.equal(await migrateLegacyGame(storage, games), null);
+    assert.equal(storage.getItem("ustagammon.current-game"), null);
+    assert.equal((await games.list()).length, 1);
+});
+
+test("sans IndexedDB : localStorage, ou à défaut la mémoire", async () => {
+    const storage = memoryStorage();
+    storage.setItem("ustagammon.current-game", JSON.stringify(journal()));
+    const opened = await openGameLibrary({ localStorage: storage });
+    assert.equal(opened.kind, "localStorage");
+    assert.equal((await opened.library.list()).length, 1);
+
+    const refused: KeyValueStorage = {
+        getItem: () => {
+            throw new Error("interdit");
+        },
+        setItem: () => {
+            throw new Error("interdit");
+        },
+        removeItem: () => {
+            throw new Error("interdit");
+        },
+    };
+    const memory = await openGameLibrary({ localStorage: refused });
+    assert.equal(memory.kind, "memory");
+    await memory.library.save("a", journal(), { level: "2ply" });
+    assert.equal((await memory.library.current())?.summary.id, "a");
+
+    // IndexedDB qui échoue à l'ouverture : repli.
+    const broken = {
+        open: () => {
+            throw new Error("indisponible");
+        },
+    } as unknown as IDBFactory;
+    assert.equal((await openGameLibrary({ indexedDB: broken })).kind, "memory");
+});
+
+test("les identifiants de partie sont distincts", () => {
+    const ids = new Set(Array.from({ length: 100 }, () => newGameId(1)));
+    assert.ok(ids.size > 95);
+    assert.match(newGameId(), /^[0-9a-z]+-[0-9a-z]{6}$/);
+});
+
+test("session : « Reprendre l'ancienne » par l'identifiant, et reprise d'une branche", async () => {
+    const games = library();
+    // Game.start et Game.resume n'interrogent pas le moteur.
+    const engine = {} as Engine;
+    const session = createGameSession(
+        games,
+        {
+            start: () => Game.start(engine, { dice: fixedDice([5, 2]) }),
+            resume: (j) => Game.resume(engine, j),
+        },
+        "2ply",
+    );
+    assert.equal(await session.restore(), null);
+    assert.equal(await session.resumePrevious(), null);
+
+    const first = session.newGame();
+    const firstId = session.shownId as string;
+    session.save(first.journal);
+    const second = session.newGame();
+    session.save(second.journal);
+    assert.notEqual(session.shownId, firstId);
+
+    // L'ancienne revient, relue dans le stockage ; la nouvelle disparaît.
+    const back = await session.resumePrevious();
+    assert.deepEqual(back?.journal, first.journal);
+    assert.equal(session.shownId, firstId);
+    assert.deepEqual(
+        (await games.list()).map((s) => s.id),
+        [firstId],
+    );
+    assert.equal(await session.resumePrevious(), null);
+
+    // Une branche reprise devient la ligne courante enregistrée.
+    let j = goBackTo(first.journal, "1");
+    j = appendEvent(j, { type: "DiceRolled", side: null, roll: [6, 1] });
+    await games.save(firstId, j, { level: "2ply" });
+    const original = branches(j).find((b) => b.forkedFrom === null);
+    assert.ok(original !== undefined);
+    const opened = await session.open(firstId, original.head);
+    assert.equal(opened.journal.head, original.head);
+    assert.equal((await games.current())?.journal.head, original.head);
+    await assert.rejects(session.open("inconnue"), /introuvable/);
+});

app/tests/support/play.ts

@@ -0,0 +1,86 @@
+// Jouer une partie du domaine sans interface, pour les tests, les
+// scénarios et les parties d'exemple : les deux camps, avec des dés
+// reproductibles.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import type { Engine } from "../../src/domain/game/engine.js";
+import type { Game } from "../../src/domain/game/game.js";
+import type { DiceSource } from "../../src/domain/game/roll.js";
+
+/** Des dés pseudo-aléatoires reproductibles (générateur congruentiel). */
+export function seededDice(seed: number): DiceSource {
+    let state = seed;
+    return () => {
+        state = (state * 1103515245 + 12345) % 2147483648;
+        return 1 + (Math.floor(state / 65536) % 6);
+    };
+}
+
+/**
+ * Une action de la partie, quel que soit le camp qui a la main. Le joueur
+ * joue le choice-ième coup légal (le dernier s'il y en a moins), prend les
+ * doubles si take, et double quand il le peut si double.
+ */
+export async function step(
+    game: Game,
+    engine: Engine,
+    strategy: { choice?: number; take?: boolean; double?: boolean } = {},
+): Promise<void> {
+    const state = game.state;
+    if (state.turn === "computer" && state.phase === "doubled") {
+        if (strategy.take ?? true) {
+            game.take();
+        } else {
+            game.drop();
+        }
+    } else if (state.turn === "computer") {
+        await game.playComputerTurn();
+    } else if (state.phase === "rolling") {
+        if (strategy.double === true && (await game.canDouble())) {
+            await game.double();
+        } else {
+            await game.roll();
+        }
+    } else if (state.phase === "moving" && state.roll !== null) {
+        const moves = await engine.legalMoves(state.position, state.roll);
+        const move = moves[Math.min(strategy.choice ?? 0, moves.length - 1)];
+        if (move === undefined) {
+            await game.skipTurn();
+            return;
+        }
+        for (const halfMove of move.halfMoves) {
+            if (!(await game.playHalfMove(halfMove))) {
+                throw new Error("coup légal refusé");
+            }
+        }
+        await game.confirmMove();
+    } else {
+        throw new Error(`phase inattendue : ${state.phase}`);
+    }
+}
+
+/** Joue jusqu'à count coups (des deux camps), ou jusqu'à la fin. */
+export async function playMoves(
+    game: Game,
+    engine: Engine,
+    count: number,
+    choice = 0,
+): Promise<void> {
+    let played = 0;
+    while (played < count && game.state.phase !== "over") {
+        const before = game.events.length;
+        await step(game, engine, { choice });
+        played += game.events.slice(before).filter((event) => event.type === "MovePlayed").length;
+    }
+}
+
+export async function playToTheEnd(game: Game, engine: Engine, choice = 0): Promise<void> {
+    for (let i = 0; game.state.phase !== "over"; i++) {
+        if (i > 2000) {
+            throw new Error("la partie ne finit pas");
+        }
+        await step(game, engine, { choice });
+    }
+}

app/tests/tools/sgf-samples.ts

@@ -0,0 +1,139 @@
+// Parties d'exemple exportées en SGF, pour les faire relire par le GNU
+// Backgammon de référence (tests/test_sgf_reference.sh).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Usage : node build/web/tests/tools/sgf-samples.js <dossier>
+//
+// Joue sur le vrai moteur WebAssembly, avec des dés reproductibles, des
+// parties variées : complètes, avec branches, avec videau, depuis une
+// position particulière. Pour chaque branche de chaque partie, écrit
+// <nom>.sgf (la partie exportée, cette branche en premier : c'est celle que
+// gnubg lit) et <nom>.json : les positions successives du journal sur cette
+// branche, celles que gnubg doit retrouver (tests/sgf/check.py).
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { Game } from "../../src/domain/game/game.js";
+import { exportSgf } from "../../src/domain/game/sgf.js";
+import { loadNodeEngine } from "../support/node-engine.js";
+import { playMoves, playToTheEnd, seededDice, step } from "../support/play.js";
+
+/** Le dernier événement « coup joué » de la ligne courante. */
+function lastMoveId(game: Game, skip = 0): string {
+    const moves = game.events.filter((event) => event.type === "MovePlayed");
+    const move = moves.at(-1 - skip);
+    if (move === undefined) {
+        throw new Error("aucun coup joué");
+    }
+    return move.id;
+}
+
+async function main(): Promise<void> {
+    const out = process.argv[2];
+    if (out === undefined) {
+        throw new Error("usage : sgf-samples.js <dossier>");
+    }
+    mkdirSync(out, { recursive: true });
+    const engine = await loadNodeEngine();
+    const games: [string, Game][] = [];
+
+    // Une partie complète, puis une autre où le joueur joue autrement.
+    for (const [seed, choice] of [
+        [3, 0],
+        [11, 2],
+    ] as const) {
+        const game = Game.start(engine, { dice: seededDice(seed), ply: 0 });
+        await playToTheEnd(game, engine, choice);
+        games.push([`complete-${seed}`, game]);
+    }
+
+    // Des branches : rejouée d'un coup de l'ordinateur (nouveaux dés), d'un
+    // jet du joueur (même jet, autre coup), et une branche d'une branche.
+    {
+        const game = Game.start(engine, { dice: seededDice(5), ply: 0 });
+        await playMoves(game, engine, 14);
+        const original = game.events.at(-1)?.id as string;
+        game.goBackTo(lastMoveId(game, 6));
+        await playMoves(game, engine, 8);
+        const rolled = game.events.findLast((e) => e.type === "DiceRolled" && e.side === "player");
+        if (rolled === undefined) {
+            throw new Error("aucun jet du joueur");
+        }
+        game.goBackTo(rolled.id);
+        await playMoves(game, engine, 5, 1);
+        game.switchBranch(original);
+        await playToTheEnd(game, engine);
+        games.push(["branches", game]);
+    }
+
+    // Le joueur double d'entrée ; l'ordinateur prend ou passe selon le moteur.
+    {
+        const game = Game.start(engine, { dice: seededDice(9), ply: 0 });
+        for (let i = 0; i < 400 && game.state.phase !== "over"; i++) {
+            await step(game, engine, { double: true });
+        }
+        games.push(["player-doubles", game]);
+    }
+
+    // Depuis une position particulière : l'ordinateur, au trait, double
+    // (position de référence « cube-double-take ») ; le joueur prend dans
+    // une branche, passe dans une autre.
+    {
+        const game = Game.start(engine, {
+            dice: seededDice(13),
+            ply: 0,
+            setup: { position: "6O5uAAC4uzsAAA", firstTurn: "computer" },
+        });
+        await step(game, engine);
+        const offered = game.events.at(-1)?.id as string;
+        await playMoves(game, engine, 6);
+        game.goBackTo(offered);
+        await step(game, engine, { take: false });
+        games.push(["setup-cube", game]);
+    }
+
+    // Depuis une position particulière, videau déjà doublé chez le joueur,
+    // qui a la main ; partie laissée en cours, dés lancés et pas joués.
+    {
+        const game = Game.start(engine, {
+            dice: seededDice(17),
+            ply: 0,
+            setup: {
+                position: "t+0OAADg/wcAQA",
+                firstTurn: "player",
+                cube: { value: 2, owner: "player" },
+            },
+        });
+        await playMoves(game, engine, 4);
+        await game.roll();
+        games.push(["setup-unfinished", game]);
+    }
+
+    let files = 0;
+    for (const [name, game] of games) {
+        const original = game.journal;
+        for (const [i, branch] of game.branches.entries()) {
+            game.switchBranch(branch.head);
+            const sgf = await exportSgf(engine, game.journal, {
+                playerName: "Vous",
+                computerName: "Ordinateur",
+                date: "2026-11-03",
+            });
+            // Après chaque coup, la position vue de celui qui a alors la main,
+            // et le résultat.
+            const expected = {
+                after: game.events.flatMap((e) => (e.type === "MovePlayed" ? [e.position] : [])),
+                result: game.state.result,
+            };
+            writeFileSync(join(out, `${name}-${i}.sgf`), sgf);
+            writeFileSync(join(out, `${name}-${i}.json`), `${JSON.stringify(expected)}\n`);
+            files++;
+        }
+        game.goBackTo(original.head as string);
+    }
+    console.log(`${files} parties exportées dans ${out}`);
+}
+
+await main();

app/tests/tutorial.test.ts

@@ -0,0 +1,212 @@
+// Tests du tutoriel des règles : le texte (docs/tutoriel/regles.md) se lit,
+// chaque position est valide pour le vrai moteur, chaque coup illustré et
+// chaque coup attendu est légal, chaque écran « à vous » accepte ses coups
+// justes et refuse les autres, et la réponse au double est celle du moteur.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { existsSync, readFileSync } from "node:fs";
+import { test } from "node:test";
+import type { Move } from "../src/domain/game/engine.js";
+import {
+    canStillLeadTo,
+    illustratedMove,
+    MovePractice,
+    shouldTake,
+    tutorialBoard,
+} from "../src/domain/learning/tutorial.js";
+import { parseInline, parseTutorial, type TutorialScreen } from "../src/ui/tutorial-text.js";
+import { loadNodeEngine } from "./support/node-engine.js";
+
+const root = new URL("../../../", import.meta.url);
+const tutorial = parseTutorial(readFileSync(new URL("docs/tutoriel/regles.md", root), "utf8"));
+
+test("le texte du tutoriel a huit étapes, une fin, et ses écrans « à vous »", () => {
+    assert.equal(tutorial.steps.length, 8);
+    assert.deepEqual(
+        tutorial.steps.filter((s) => s.practice !== null).map((s) => s.number),
+        [3, 4, 6, 8],
+    );
+    assert.ok(tutorial.end.action !== "");
+    assert.ok(tutorial.end.paragraphs.length > 0);
+    for (const step of tutorial.steps) {
+        assert.ok(step.explain.paragraphs.length > 0, `étape ${step.number} sans texte`);
+        const practice = step.practice;
+        if (practice !== null) {
+            assert.ok(practice.paragraphs.length > 0, `étape ${step.number} : consigne absente`);
+            assert.ok(
+                practice.right.length > 0 && practice.wrong.length > 0,
+                `étape ${step.number} : phrases juste et refus absentes`,
+            );
+            assert.ok(
+                practice.expected.length > 0 || practice.answer !== null,
+                `étape ${step.number} : ni coup attendu, ni réponse au double`,
+            );
+        }
+    }
+});
+
+test("chaque mot du glossaire cité par le tutoriel a sa fiche", () => {
+    const screens = tutorial.steps.flatMap((s) => [s.explain, ...(s.practice ? [s.practice] : [])]);
+    const inlines = [
+        ...screens.flatMap((s) => [...s.paragraphs.flat(), ...s.right, ...s.wrong]),
+        ...tutorial.end.paragraphs.flat(),
+    ];
+    const terms = inlines.flatMap((i) => (i.term === undefined ? [] : [i.term]));
+    assert.ok(terms.length >= 10, `seulement ${terms.length} liens vers le glossaire`);
+    for (const term of terms) {
+        assert.ok(
+            existsSync(new URL(`docs/glossaire/${term}.md`, root)),
+            `fiche ${term}.md absente`,
+        );
+    }
+});
+
+test("les liens et le gras du texte sont lus", () => {
+    assert.deepEqual(parseInline("Un [blot](blot.md) **seul**, voilà."), [
+        { text: "Un " },
+        { text: "blot", term: "blot" },
+        { text: " " },
+        { text: "seul", strong: true },
+        { text: ", voilà." },
+    ]);
+});
+
+test("un texte mal formé est refusé", () => {
+    assert.throws(() =>
+        parseTutorial("## 2. Sans la première\n\n- position: x\n\nTexte.\n\n## Fin\n"),
+    );
+    assert.throws(() => parseTutorial("## 1. Sans position\n\nTexte.\n\n## Fin\n"));
+    assert.throws(() => parseTutorial("## 1. Jet faux\n\n- position: x\n- jet: 7-1\n\n## Fin\n"));
+    assert.throws(() => parseTutorial("## 1. Sans fin\n\n- position: x\n\nTexte.\n"));
+});
+
+/** Tous les écrans, avec leur nom pour les messages. */
+function screens(): [string, TutorialScreen][] {
+    return tutorial.steps.flatMap((s) => [
+        [`étape ${s.number}`, s.explain] as [string, TutorialScreen],
+        ...(s.practice === null
+            ? []
+            : [[`étape ${s.number}, à vous`, s.practice] as [string, TutorialScreen]]),
+    ]);
+}
+
+test("chaque position du tutoriel est valide pour le moteur", async () => {
+    const engine = await loadNodeEngine();
+    for (const [name, screen] of screens()) {
+        const board = await tutorialBoard(engine, screen.position, screen.onRoll);
+        const count = (side: "player" | "computer") => {
+            const s = board.sides[side];
+            return s.points.reduce((a, b) => a + b, 0) + s.bar + s.off;
+        };
+        assert.equal(count("player"), 15, `${name} : pions ivoire`);
+        assert.equal(count("computer"), 15, `${name} : pions noyer`);
+    }
+});
+
+test("chaque coup illustré est légal, et la partie de l'étape 7 finit par un gammon", async () => {
+    const engine = await loadNodeEngine();
+    for (const [name, screen] of screens()) {
+        if (screen.move === null) {
+            continue;
+        }
+        assert.ok(screen.roll !== null, `${name} : coup sans jet`);
+        const { steps, after } = await illustratedMove(
+            engine,
+            screen.position,
+            screen.roll,
+            screen.move,
+        );
+        assert.equal(steps.boards.length, steps.halfMoves.length + 1, name);
+        if (name === "étape 7") {
+            assert.deepEqual(after.result, { winner: "player", kind: "gammon" });
+        } else {
+            assert.equal(after.result, null, name);
+        }
+        if (name === "étape 4") {
+            assert.ok(steps.hits.some(Boolean), "étape 4 : le coup illustré ne frappe pas");
+        }
+    }
+});
+
+test("chaque écran « à vous » accepte ses coups attendus et refuse les autres", async () => {
+    const engine = await loadNodeEngine();
+    for (const [name, screen] of screens()) {
+        if (screen.expected.length === 0) {
+            continue;
+        }
+        assert.ok(screen.roll !== null, `${name} : pas de jet`);
+        const legal = await engine.legalMoves(screen.position, screen.roll);
+        for (const move of legal) {
+            const practice = await MovePractice.start(
+                engine,
+                screen.position,
+                screen.roll,
+                screen.expected,
+            );
+            let verdict = "continue";
+            for (const halfMove of move.halfMoves) {
+                verdict = await practice.play(halfMove);
+                if (verdict !== "continue") {
+                    break;
+                }
+            }
+            const right = screen.expected.includes(move.notation);
+            assert.equal(verdict, right ? "right" : "wrong", `${name} : ${move.notation}`);
+        }
+        // Un coup attendu au moins, et un coup refusé au moins.
+        assert.ok(
+            legal.some((m) => !screen.expected.includes(m.notation)),
+            `${name} : rien à refuser`,
+        );
+    }
+});
+
+test("le joueur peut revenir en arrière après un coup refusé", async () => {
+    const engine = await loadNodeEngine();
+    const practice = await MovePractice.start(engine, "4HPwATDgc/ABMA", [3, 1], ["8/5 6/5"]);
+    assert.equal(await practice.play({ from: 24, to: 21 }), "wrong");
+    practice.reset();
+    assert.deepEqual(practice.pendingHalfMoves, []);
+    assert.equal(await practice.play({ from: 8, to: 5 }), "continue");
+    assert.equal(await practice.play({ from: 6, to: 5 }), "right");
+});
+
+test("la réponse au double de l'étape 8 est celle du moteur", async () => {
+    const engine = await loadNodeEngine();
+    for (const [name, screen] of screens()) {
+        if (screen.answer === null) {
+            continue;
+        }
+        assert.equal(screen.onRoll, "computer", `${name} : l'ordinateur doit avoir la main`);
+        assert.equal(await shouldTake(engine, screen.position), screen.answer === "take", name);
+    }
+});
+
+test("des demi-coups peuvent encore mener à un coup attendu, ou plus", () => {
+    const move = (notation: string, halfMoves: [number, number][]): Move => ({
+        notation,
+        halfMoves: halfMoves.map(([from, to]) => ({ from, to })),
+        position: notation,
+    });
+    const expected = [
+        move("8/5 6/5", [
+            [8, 5],
+            [6, 5],
+        ]),
+    ];
+    assert.ok(canStillLeadTo([], expected));
+    assert.ok(canStillLeadTo([{ from: 6, to: 5 }], expected));
+    assert.ok(!canStillLeadTo([{ from: 8, to: 7 }], expected));
+    assert.ok(
+        !canStillLeadTo(
+            [
+                { from: 8, to: 5 },
+                { from: 8, to: 5 },
+            ],
+            expected,
+        ),
+    );
+});

app/tests/ui.test.ts

@@ -1,6 +1,6 @@
 // Tests de ce qui, dans l'interface et le stockage, se vérifie sans
 // navigateur : le plateau à dessiner, les mises en évidence, la lecture de
-// l'aide, l'enregistrement de la partie.
+// l'aide. Le stockage des parties a ses tests (storage.test.ts).
 //
 // Copyright (C) 2026 les auteurs d'Ustagammon.
 // Licence : GPLv3 ou ultérieure (voir LICENSE).
@@ -9,9 +9,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { test } from "node:test";
 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 { parseHalfMoves } from "../src/domain/game/position.js";
 import {
     boardModel,
     moveTargets,
@@ -21,7 +19,15 @@ import {
     pointColor,
     pointSlot,
 } from "../src/ui/board-model.js";
-import { parseFeature, parseGlossaryEntry, parseGlossaryIndex } from "../src/ui/help-text.js";
+import { FEATURES } from "../src/ui/help.js";
+import { HELP_QUESTIONS, helpHash } from "../src/ui/help-context.js";
+import {
+    matchesSearch,
+    parseFeature,
+    parseGlossaryEntry,
+    parseGlossaryIndex,
+} from "../src/ui/help-text.js";
+import { slug } from "../src/ui/router.js";
 import { TEXTS } from "../src/ui/texts.js";
 
 // Compilé dans build/web/tests/ : la racine du dépôt est trois dossiers plus haut.
@@ -145,21 +151,77 @@ test("l'aide lit le scénario tel qu'il est écrit dans docs/scenarios/", () =>
     const feature = parseFeature(read("docs/scenarios/jouer-une-partie.feature"));
     assert.equal(feature.title, "Jouer une partie contre l'ordinateur");
     assert.match(feature.description[0] ?? "", /^Vous jouez une partie complète/);
-    assert.equal(feature.scenarios[0]?.title, "Commencer une partie");
+    assert.equal(feature.scenarios[0]?.title, "Comment commence une partie ?");
+    assert.equal(feature.scenarios[0]?.position, "4HPwATDgc/ABMA");
     assert.deepEqual(feature.scenarios[0]?.steps, [
         "Quand vous commencez une nouvelle partie",
         "Alors les pions sont en position de départ",
         "Et le premier jet de dés désigne qui commence",
     ]);
-    const refused = feature.scenarios.find((s) => s.title === "Un coup interdit est refusé");
-    assert.match(refused?.description[0] ?? "", /^La case 12 est tenue/);
+    const refused = feature.scenarios.find(
+        (s) => s.title === "Pourquoi je ne peux pas poser mon pion sur cette flèche ?",
+    );
+    assert.match(
+        refused?.description[0] ?? "",
+        /^Une flèche où l'ordinateur a au moins deux pions/,
+    );
     assert.equal(refused?.steps[0], "Étant donné que c'est à vous de jouer avec le jet 3-1");
+    assert.equal(feature.scenarios[2]?.position, null);
     // Chaque scénario a des étapes : aucune n'a été prise pour du texte libre.
     for (const scenario of feature.scenarios) {
         assert.ok(scenario.steps.length >= 2, scenario.title);
     }
 });
 
+test("aide : chaque scénario affiché est une question avec sa réponse", () => {
+    const listed = read("docs/scenarios/README.md");
+    const ids = new Set<string>();
+    for (const url of FEATURES) {
+        assert.ok(
+            listed.includes(`](${url.replace("docs/scenarios/", "")})`),
+            `${url} hors de l'index`,
+        );
+        const feature = parseFeature(read(url));
+        assert.ok(feature.description.length > 0, `${url} : pas d'introduction`);
+        for (const scenario of feature.scenarios) {
+            // La réponse se lit seule : pas de vocabulaire technique.
+            assert.ok(scenario.description.length > 0, `${scenario.title} : pas de réponse`);
+            for (const word of ["scénario", "événement", "moteur", "Étant donné"]) {
+                assert.ok(
+                    !scenario.description.join(" ").includes(word),
+                    `${scenario.title} : « ${word} » dans la réponse`,
+                );
+            }
+            const id = slug(scenario.title);
+            assert.ok(id !== "" && !ids.has(id), `${scenario.title} : identifiant ${id} en double`);
+            ids.add(id);
+        }
+    }
+});
+
+test("aide contextuelle : chaque question ouverte depuis la partie existe dans les scénarios", () => {
+    const titles = FEATURES.flatMap((url) => parseFeature(read(url)).scenarios.map((s) => s.title));
+    for (const title of Object.values(HELP_QUESTIONS)) {
+        assert.ok(titles.includes(title), `« ${title} » n'est plus le titre d'un scénario`);
+    }
+    assert.equal(helpHash("stuck"), "#/aide/je-ne-peux-rien-jouer-avec-mes-des");
+    assert.equal(helpHash(null), "#/aide");
+});
+
+test("glossaire : nom anglais, renvois, recherche sans accents", () => {
+    const entry = parseGlossaryEntry(read("docs/glossaire/camp.md"));
+    assert.ok(entry !== null);
+    assert.equal(entry.english, "Home board");
+    assert.deepEqual(
+        entry.seeAlso.map((s) => s.name),
+        ["sortie", "barre", "point"],
+    );
+    assert.ok(matchesSearch(entry, "camp"));
+    assert.ok(matchesSearch(entry, "HOME"));
+    assert.ok(matchesSearch(entry, "fleches sortir"));
+    assert.ok(!matchesSearch(entry, "videau"));
+});
+
 test("l'aide lit chaque fiche de l'index du glossaire", () => {
     const files = parseGlossaryIndex(read("docs/glossaire/README.md"));
     assert.ok(files.includes("videau.md"));
@@ -169,51 +231,24 @@ test("l'aide lit chaque fiche de l'index du glossaire", () => {
         assert.ok(entry !== null, file);
         assert.ok(entry.brief.length > 10, file);
     }
-    assert.deepEqual(parseGlossaryEntry(read("docs/glossaire/videau.md")), {
-        term: "Videau",
-        brief: "le dé à doubler, marqué 2, 4, 8, 16, 32 et 64 : il indique la valeur actuelle de la partie.",
-    });
+    const videau = parseGlossaryEntry(read("docs/glossaire/videau.md"));
+    assert.equal(videau?.term, "Videau");
+    assert.equal(videau?.english, "Cube");
+    assert.equal(
+        videau?.brief,
+        "le dé à doubler, marqué 2, 4, 8, 16, 32 et 64 : il indique la valeur actuelle de la partie.",
+    );
     assert.equal(parseGlossaryEntry("pas une fiche"), null);
 });
 
-test("la partie enregistrée se relit ; un enregistrement illisible est ignoré", () => {
-    const data = new Map<string, string>();
-    const storage = {
-        getItem: (key: string) => data.get(key) ?? null,
-        setItem: (key: string, value: string) => void data.set(key, value),
-    };
-    const store = createGameStore(storage);
-    assert.equal(store.load(), null);
-    const journal = appendEvent(EMPTY_JOURNAL, {
-        type: "GameStarted",
-        position: START_POSITION,
-        cube: { value: 1, owner: null },
-        firstTurn: null,
-    });
-    store.save(journal);
-    assert.deepEqual(store.load(), journal);
-    for (const key of data.keys()) {
-        data.set(key, "{pas du JSON");
-    }
-    assert.equal(store.load(), null);
-    // Un stockage plein ou interdit ne casse pas la partie.
-    const full = createGameStore({
-        getItem: () => null,
-        setItem: () => {
-            throw new Error("plein");
-        },
-    });
-    assert.doesNotThrow(() => full.save(journal));
-});
-
 test("les textes de fin de partie emploient les mots du glossaire", () => {
-    assert.equal(TEXTS.youWin("gammon", 2), "Vous gagnez un gammon : 2 points.");
+    assert.equal(TEXTS.endTitle("computer", "gammon", false), "L'ordinateur gagne un gammon");
+    assert.equal(TEXTS.endDetail("computer", 8, 4), "8 points pour lui, videau à 4.");
+    assert.equal(TEXTS.endTitle("player", "single", false), "Vous gagnez la partie simple");
+    assert.equal(TEXTS.endDetail("player", 1, 1), "1 point pour vous.");
+    assert.equal(TEXTS.endTitle("player", "single", true), "L'ordinateur passe");
     assert.equal(
-        TEXTS.youLose("single", 1),
-        "L'ordinateur gagne la partie simple : 1 point pour lui.",
-    );
-    assert.equal(
-        TEXTS.computerMoved([6, 4], "24/18 13/9", 312),
-        "L'ordinateur a joué 6-4 : 24/18 13/9 (0,3 s).",
+        TEXTS.computerMoved([6, 4], "24/18 13/9"),
+        "L'ordinateur a joué 6-4 : 24/18 13/9.",
     );
 });

docs/adr/0007-architecture-et-conventions-de-code.md

@@ -94,3 +94,15 @@ les justifie pas.
   dépendances seront fixés avec le socle, à la fin de l'étape 0.
 - Les sous-agents reçoivent ces règles dans leurs consignes ; `CLAUDE.md` y
   renvoie.
+
+## Amendements
+
+### 2026-11-03 — Le stockage des parties est un format durable
+
+Avec les parties enregistrées (étape 1b), le schéma IndexedDB (base
+« ustagammon », version 1 : magasins `games`, `journals`, `settings`) et les
+clés `localStorage` de l'application (`ustagammon.settings`,
+`ustagammon.last-board`, et le repli des parties) rejoignent le journal
+d'événements parmi les formats durables : toute modification passe par une
+montée de version avec migration testée, jamais par une réécriture qui
+perdrait les parties des joueurs.

docs/adr/0013-position-dans-l-adresse.md

@@ -47,3 +47,54 @@ moteur sait les lire et les écrire (`engine.h`).
 - Les liens restent valables tant que GNU Backgammon garde ces formats, stables
   depuis des années.
 - Les liens contiennent la position, rien d'autre : pas de donnée personnelle.
+
+## Amendements
+
+### 2026-11-03 — Une adresse pour chaque écran, des liens plutôt que des états
+
+Demandé par Pierre : « il faudra vraiment que chaque page (l'aide, etc.) ait
+une URL. Utilise des liens accessibles, pas des états. » Aucun lien de
+position n'a encore circulé : le format ci-dessus est remplacé par un schéma
+unique pour tous les écrans, avant sa première mise en œuvre.
+
+- Chaque écran a son adresse, dans le fragment (pour les mêmes raisons
+  qu'au-dessus : hors ligne, service worker, aucune configuration serveur) :
+
+  | Écran | Adresse |
+  | --- | --- |
+  | Partie en cours | `#/` |
+  | Accueil | `#/accueil` |
+  | Aide (onglet Jouer) | `#/aide`, une question : `#/aide/<identifiant>` |
+  | Les mots du jeu | `#/glossaire`, un terme : `#/glossaire/<fichier sans .md>` |
+  | À propos | `#/a-propos` |
+  | Tutoriel | `#/tutoriel`, une étape : `#/tutoriel/<n>` |
+  | Mes parties | `#/parties`, une partie : `#/parties/<id>` |
+  | Réglages / menu | `#/menu` |
+  | Une position | `#/position/<Position ID>/<Match ID>` (Match ID facultatif) |
+
+  Les identifiants de gnubg sont encodés avec `encodeURIComponent`. Les
+  écrans à venir (analyse, leçons, progression) suivront le même schéma.
+- On change d'écran par de vrais liens (`<a href="#/aide">`), pas par des
+  boutons qui modifient un état caché : le lien se partage, s'ouvre dans un
+  nouvel onglet, se lit aux lecteurs d'écran comme un lien, et le bouton
+  « retour » du téléphone ramène à l'écran précédent. Les actions de jeu
+  (lancer, jouer, doubler) restent des boutons : elles ne sont pas des écrans.
+- Les feuilles (menu, explication) et panneaux qui sont des écrans à part
+  entière ont aussi leur adresse ; une confirmation ou un bandeau éphémère
+  n'en a pas.
+- Une adresse inconnue mène à la partie en cours avec un message clair.
+- L'adresse de l'écran courant est la source de vérité de la navigation :
+  l'application l'écoute (`hashchange`) et dessine l'écran correspondant.
+
+### 2026-11-09 — Adresses du tutoriel et de l'installation
+
+Ajoutées avec l'accueil et le tutoriel (étape 0e.5), dans le même schéma :
+
+| Écran | Adresse |
+| --- | --- |
+| Écran « à vous » d'une étape du tutoriel | `#/tutoriel/<n>/a-vous` |
+| Fin du tutoriel | `#/tutoriel/fin` |
+| Marche à suivre pour installer l'application | `#/installer` |
+
+Lancée sans adresse, l'application ouvre l'accueil (`#/accueil`) ; `#/` reste
+la partie en cours, pour que les liens existants ne changent pas.

docs/etape-1.md

@@ -18,9 +18,9 @@ Repris du cadrage (modules, écrans clés, IA générative en V1) et des ADR 001
 | Sous-étape | Contenu | Dépend de |
 | --- | --- | --- |
 | 1a. Moteur pour l'analyse (fait) | Niveaux de jeu (plis et bruit de GNU Backgammon : débutant à expert), classement des coups d'un jet avec équités, analyse d'un coup joué et d'une décision de videau, chance d'un jet ; exposés par `engine.h`, `engine-cli` et le Worker, avec positions de référence comparées à gnubg de bureau | — |
-| 1b. Parties enregistrées | Stockage IndexedDB derrière l'interface de stockage existante : plusieurs parties, reprise automatique, branches (« Rejouer d'ici » crée une branche, l'originale reste intacte et rechargeable), export SGF avec variantes | — |
+| 1b. Parties enregistrées (fait) | Stockage IndexedDB derrière l'interface de stockage existante : plusieurs parties, reprise automatique, branches (« Rejouer d'ici » crée une branche, l'originale reste intacte et rechargeable), export SGF avec variantes | — |
 | 1c. Match et réglages | Partie libre ou match en N points, règle Crawford, règle Jacoby, choix du niveau de l'ordinateur, conseil du maître activable ou non ; écran de nouvelle partie | 1a, 1b |
-| 1d. Conseil du maître | Après chaque coup du joueur, jamais avant (ADR 0011) : appréciation du moteur (bon coup, imprécision, erreur, gaffe) avec mot, icône et couleur, phrase du maître fondée sur les chiffres du moteur, coup recommandé montré sur demande ; aussi pour les décisions de videau ; calcul en arrière-plan sans retarder le jeu | 1a |
+| 1d. Conseil du maître | Après chaque coup du joueur, jamais avant (ADR 0011) : appréciation du moteur (bon coup, imprécision, erreur, grosse erreur) avec mot, icône et couleur, phrase du maître fondée sur les chiffres du moteur, coup recommandé montré sur demande ; aussi pour les décisions de videau ; calcul en arrière-plan sans retarder le jeu | 1a |
 | 1e. Fin de partie et analyse | Bilan (ADR 0011) : résultat, coups par appréciation, taux d'erreur comparé à la chance, « le coup à revoir » ; écran d'analyse : graphe d'équité (toucher un point ouvre la position), liste des erreurs filtrable, visualiseur pas à pas coup joué contre meilleur coup, « Rejouer d'ici » | 1a, 1b, 1d |
 | 1f. Prompts à copier | Gabarits versionnés et testés (`docs/prompts/` ou équivalent, source unique), bouton « Demander à une IA » sur le plateau, le conseil du maître, l'analyse et la fin de partie ; le moteur décide, l'IA explique | 1d, 1e |
 | 1g. Accueil, tutoriel et leçons | Accueil (reprendre, nouvelle partie, prochaine leçon, progression résumée), tutoriel des règles interactif et illustré (0e.5), cinq premières leçons numérotées (ADR 0011) avec positions et « à vous de jouer », progression locale ; contenus CC BY-SA 4.0 en brouillon, à relire par un joueur fort | 0e.5, 1a |

docs/feuille-de-route.md

@@ -23,9 +23,6 @@ Demandes de Pierre du 2026-11-03, traitées avant d'ouvrir l'étape 1.
 
 | Sous-étape | Contenu | État | Plan |
 | --- | --- | --- | --- |
-| 0e.3 | Révision UX arbitrée (session « identité », sur délégation de Pierre) : portrait stable, bandeaux de compte de points, menu en feuille et nouvelle partie annulable, vibrations, écran allumé, paysage « plateau = écran » dès la rotation (ADR 0012 amendé) | ⏳ | `plans/2026-11-03-revision-ux.md` |
-| 0e.4 | Position dans l'adresse : chaque position du plateau a un lien direct (ADR 0013) | ⏳ | `plans/2026-11-03-position-dans-l-adresse.md` |
-| 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 | ⏳ | `plans/2026-11-03-accueil-tutoriel-aide.md` |
 
 ## Étapes suivantes
 

docs/glossaire/README.md

@@ -40,6 +40,7 @@ exportée. `make test` vérifie le lien dans les deux sens : chaque fiche avec
 | [Barre](barre.md) | Bar |
 | [Blot](blot.md) | Blot |
 | [Branche](branche.md) | Branch |
+| [Camp](camp.md) | Home board |
 | [Chance](chance.md) | Luck |
 | [Compte de points](compte-de-points.md) | Pip count |
 | [Coup](coup.md) | Move |
@@ -52,10 +53,12 @@ exportée. `make test` vérifie le lien dans les deux sens : chaque fiche avec
 | [Identifiant de match](identifiant-de-match.md) | Match ID |
 | [Identifiant de position](identifiant-de-position.md) | Position ID |
 | [Jet](jet.md) | Roll |
+| [Lien de position](lien-de-position.md) | Position link |
 | [Match](match.md) | Match |
 | [Moteur](moteur.md) | Engine |
 | [Niveau de jeu](niveau-de-jeu.md) | Level |
 | [Partie](partie.md) | Game |
+| [Partie enregistrée](partie-enregistree.md) | Saved game |
 | [Passer](passer.md) | Drop |
 | [Pion](pion.md) | Checker |
 | [Plateau](plateau.md) | Board |
@@ -64,5 +67,6 @@ exportée. `make test` vérifie le lien dans les deux sens : chaque fiche avec
 | [Prendre](prendre.md) | Take |
 | [Règle de Crawford](regle-de-crawford.md) | Crawford rule |
 | [Règle de Jacoby](regle-de-jacoby.md) | Jacoby rule |
+| [SGF](sgf.md) | SGF |
 | [Sortie](sortie.md) | Bear-off |
 | [Videau](videau.md) | Cube |

docs/glossaire/branche.md

@@ -1,9 +1,14 @@
 ---
 term: Branche
 english: Branch
+code: Branch
 ---
 # Branche
 
 **En bref** : suite de coups rejouée à partir d'un moment d'une partie (« Rejouer d'ici ») ; la partie d'origine reste intacte.
 
-Voir aussi : [Événement de partie](evenement-de-partie.md)
+Une partie garde toutes ses branches : vous pouvez revenir à l'une ou à
+l'autre depuis « Mes parties », et l'export SGF les contient toutes, en
+variantes.
+
+Voir aussi : [Événement de partie](evenement-de-partie.md), [Partie enregistrée](partie-enregistree.md)

docs/glossaire/camp.md

@@ -0,0 +1,12 @@
+---
+term: Camp
+english: Home board
+---
+# Camp
+
+**En bref** : les six dernières flèches d'un joueur, avant sa sortie : il y rassemble ses pions pour les sortir, et un pion adverse frappé doit y rentrer.
+
+Votre camp est en bas à droite (vos flèches 1 à 6) ; celui de l'ordinateur,
+en haut à droite (vos flèches 19 à 24), où rentrent vos pions frappés.
+
+Voir aussi : [Sortie](sortie.md), [Barre](barre.md), [Point](point.md)

docs/glossaire/identifiant-de-match.md

@@ -1,9 +1,10 @@
 ---
 term: Identifiant de match
 english: Match ID
+code: MatchId
 ---
 # Identifiant de match
 
 **En bref** : code de 12 caractères qui décrit le reste de l'état du jeu : score, videau, joueur au trait, dés ; c'est le format de GNU Backgammon.
 
-Voir aussi : [Identifiant de position](identifiant-de-position.md)
+Voir aussi : [Identifiant de position](identifiant-de-position.md), [Lien de position](lien-de-position.md)

docs/glossaire/identifiant-de-position.md

@@ -7,4 +7,4 @@ code: PositionId
 
 **En bref** : code de 14 caractères, par exemple 4HPwATDgc/ABMA, qui décrit la place de tous les pions ; c'est le format de GNU Backgammon.
 
-Voir aussi : [Identifiant de match](identifiant-de-match.md)
+Voir aussi : [Identifiant de match](identifiant-de-match.md), [Lien de position](lien-de-position.md)

docs/glossaire/lien-de-position.md

@@ -0,0 +1,15 @@
+---
+term: Lien de position
+english: Position link
+code: PositionLink
+---
+# Lien de position
+
+**En bref** : une adresse qui ouvre directement une position du plateau, à partager, à garder ou à coller dans une question ; elle contient l'identifiant de position et l'identifiant de match.
+
+Le lien montre la position du point de vue du joueur qui a la main : c'est
+vous, en bas. « Jouer à partir d'ici » commence une nouvelle partie depuis
+cette position, sans toucher à votre partie en cours. Le lien ne contient que
+la position : aucune donnée personnelle.
+
+Voir aussi : [Identifiant de position](identifiant-de-position.md), [Identifiant de match](identifiant-de-match.md)

docs/glossaire/partie-enregistree.md

@@ -0,0 +1,14 @@
+---
+term: Partie enregistrée
+english: Saved game
+code: SavedGameSummary
+---
+# Partie enregistrée
+
+**En bref** : une partie gardée sur votre téléphone, finie ou en cours, avec toutes ses branches ; vous la retrouvez dans « Mes parties ».
+
+Chaque partie est enregistrée après chacune de vos actions : fermer
+l'application ne perd rien. Rien ne quitte le téléphone, sauf si vous
+exportez une partie.
+
+Voir aussi : [Partie](partie.md), [Branche](branche.md), [SGF](sgf.md)

docs/glossaire/sgf.md

@@ -0,0 +1,13 @@
+---
+term: SGF
+english: SGF
+---
+# SGF
+
+**En bref** : format de fichier des parties de GNU Backgammon ; une partie exportée en SGF s'ouvre dans GNU Backgammon pour l'analyser.
+
+SGF (Smart Game Format) est un format commun à plusieurs jeux. Les branches
+d'une partie y deviennent des variantes ; GNU Backgammon ouvre la branche
+courante.
+
+Voir aussi : [Partie enregistrée](partie-enregistree.md), [Moteur](moteur.md)

docs/identite/charte/README.md

@@ -14,6 +14,7 @@ Décisions : ADR 0010. Fichiers du logo et des icônes : `../logo/`.
 | Fichier | Contenu |
 | --- | --- |
 | `guide-de-marque.md` | Règles d'usage : ton, couleurs, typographie, formes, mouvement, icônes, composants |
+| `ecrans-etape-1.md` | Écrans de l'étape 1, lot par lot : nouvelle partie et match (1c), conseil du maître (1d), bilan et analyse (1e), IA (1f), leçons (1g), progression (1h), gestes (1i) |
 | `accueil-tutoriel-aide.md` | Accueil, installation sans intrusion, tutoriel des règles (forme et première version du texte), aide en questions |
 | `recette-ux.md` | Critères de recette design de l'écran de jeu, à cocher sur les captures et sur le téléphone |
 | `interaction.md` | Comportement : réponse immédiate, annuler plutôt que confirmer, mouvement, vibrations, clavier, mises en page de l'écran de jeu (portrait, paysage, ordinateur), pictogrammes |

docs/identite/charte/accueil-tutoriel-aide.md

@@ -67,7 +67,8 @@ interrompre.
   deux ou trois phrases. Une étape sur deux finit par un écran **« à vous »**
   où le joueur fait le geste sur le vrai plateau, contrôlé par le moteur.
 - En haut : une barre de progression en huit segments (`accent` pour les
-  étapes faites) et « Passer » à droite. En bas : « Retour » et
+  étapes faites) et « Quitter » à droite (pas « Passer » : ce mot appartient au
+  videau, et le tutoriel enseigne les mots exacts du jeu). En bas : « Retour » et
   « Continuer ».
 - Les positions sont données par leurs identifiants gnubg (ADR 0013) ; le
   plateau est le composant de l'app, non jouable sauf sur les écrans
@@ -113,9 +114,10 @@ interrompre.
    flèche 6, un 1 un pion de la flèche 1. Touchez le pion, puis la sortie à
    droite. » *À vous* : sortir deux pions avec 6-3.
 7. **Gammon et backgammon.** « Une partie gagnée vaut 1 point. Si
-   l'adversaire n'a sorti aucun pion quand vous finissez, c'est un gammon :
-   2 points. S'il lui reste en plus un pion sur la barre ou dans votre camp,
-   c'est un backgammon : 3 points. »
+   l'adversaire n'a sorti aucun pion, c'est un gammon : 2 points ; s'il lui
+   reste en plus un pion sur la barre ou dans votre camp, c'est un
+   backgammon : 3 points. En partie libre, gammon et backgammon ne comptent
+   que si le videau a été doublé : c'est la règle de Jacoby. »
 8. **Le videau.** « Le cube aux faces 2, 4, 8, 16, 32 et 64 sert à miser.
    Avant de lancer vos dés, vous pouvez proposer de doubler la valeur de la
    partie. L'ordinateur prend, et la partie continue en valant le double, ou il
@@ -151,3 +153,24 @@ fichiers servent d'aide et de tests.
   alphabétique, avec un champ de recherche en tête.
 - **Ton** : celui du maître de café, patient et concret. Pas de « Étant
   donné que », pas de vocabulaire technique (moteur, scénario, événement).
+
+## Liens (ADR 0013, amendement : une adresse par écran)
+
+Chaque élément qui mène ailleurs est un vrai lien (`<a href>`), qu'on peut
+ouvrir, partager et retrouver avec le bouton « retour » du téléphone.
+
+| Élément | Adresse |
+| --- | --- |
+| « Je découvre », « Toutes les leçons » | `#/tutoriel/1` |
+| Étape *n* du tutoriel (« Continuer », « Retour », segments de la barre de progression) | `#/tutoriel/<n>` |
+| « Je connais les règles », « Reprendre la partie » | l'écran de jeu |
+| Un terme du jeu dans un texte (blot, barre, camp…) | `#/glossaire/<terme>` |
+| Une position illustrée, « Voir sur le plateau » | `#/position/<Position ID>/<Match ID>` |
+| Aide, onglet « Jouer » | `#/aide` ; une question ouverte : `#/aide/<scénario>` |
+| Menu | `#/menu` |
+
+- Les segments de la barre de progression du tutoriel sont des liens vers les
+  étapes déjà vues, pas vers les suivantes.
+- Le bouton « retour » du téléphone ferme d'abord la feuille ou la question
+  ouverte, puis revient à l'écran précédent ; il ne quitte jamais une partie
+  sans retour possible.

docs/identite/charte/ecrans-etape-1.md

@@ -0,0 +1,253 @@
+# Écrans de l'étape 1
+
+Règles de design des écrans de l'étape 1 (`docs/etape-1.md`), lot par lot.
+Maquettes : canevas https://claude.ai/artifact/CQw6vbDpi6XQqVWQa4sANe, rangées
+« Étape 1 ». Comportement général : `interaction.md` ; liens : ADR 0013.
+
+## 1c. Nouvelle partie et match
+
+### Écran « Nouvelle partie » (`#/nouvelle-partie`)
+
+Ouvert depuis le menu, l'accueil et la fin de partie. Une seule page, sans
+étapes, de haut en bas :
+
+1. **Type de partie** : un sélecteur à deux segments, « Partie libre » et
+   « Match » (fond `surface-sunken`, segment choisi en `surface` avec
+   `shadow-raised`).
+   - **Match** : « Le premier à [3] [5] [7] [11] points », quatre boutons
+     carrés de 44 px, le choisi en brique. Dessous, une phrase sur la règle de
+     Crawford, avec le lien vers sa fiche du glossaire.
+   - **Partie libre** : une phrase sur la règle de Jacoby, avec le lien vers
+     sa fiche. Pas d'interrupteur pour Crawford ni Jacoby : ce sont les règles
+     usuelles, et le joueur débutant n'a pas à les choisir.
+2. **Niveau de l'ordinateur** : six barres de hauteur croissante, à toucher
+   (Débutant, Amateur, Intermédiaire, Avancé, Expert, Champion) ; les barres
+   jusqu'au niveau choisi sont en brique, le niveau choisi porte l'anneau de
+   focus. Dessous, le nom en `heading` et une phrase qui le décrit en mots de
+   joueur, jamais en plis ni en bruit :
+   - Débutant : « Joue simplement et laisse passer des occasions. Idéal pour
+     vos premières parties. »
+   - Amateur : « Un joueur qui connaît les règles et commet encore des
+     erreurs. »
+   - Intermédiaire : « Un habitué de la table : solide, sans être
+     implacable. »
+   - Avancé : « Un bon joueur de club. Peu d'erreurs de pions, un videau
+     sérieux. »
+   - Expert : « Très peu d'erreurs. Chaque point se gagne. »
+   - Champion : « GNU Backgammon à son meilleur niveau sur ce téléphone. »
+3. **Pendant la partie** : interrupteur « Conseil du maître », sous-titre
+   « Une ligne après chacun de vos coups ».
+4. **Barre d'action collée en bas** : un seul bouton principal, qui dit ce
+   qu'il lance (« Commencer la partie » ou « Commencer le match en 5
+   points »), et la mention « Vos choix sont gardés pour la prochaine fois. ».
+
+Par défaut : partie libre, Intermédiaire, conseil activé. Fermer (croix en
+haut à gauche, ou retour du téléphone) ne change rien à la partie en cours.
+Commencer une nouvelle partie alors qu'une partie est en cours suit la règle
+« annuler plutôt que confirmer » (bandeau « Reprendre l'ancienne »).
+
+### Score de match sur l'écran de jeu
+
+- **Portrait** : une ligne `overline` centrée sous la barre haute, « Match en
+  5 points », complétée par « · partie Crawford » pendant la partie Crawford ;
+  dans chaque bandeau, une pastille carrée (contour `border-strong`, chiffre
+  gras) avec le score de ce joueur, juste avant son compte de points.
+- **Paysage** : dans la colonne de commandes, sous le menu, une case qui
+  empile le score de l'ordinateur, « sur 5 », puis le vôtre (même ordre que
+  les bandeaux : l'ordinateur en haut, vous en bas).
+- Le score se lit aussi au lecteur d'écran : « Match en 5 points :
+  l'ordinateur 4, vous 2 ».
+- Pendant la partie Crawford, le videau n'est pas affiché : il n'existe pas
+  pour cette partie.
+
+## 1d. Conseil du maître
+
+### La ligne du maître
+
+Maquette « Portrait révisé : conseil du maître après le coup ». Une ligne de
+44 px, réservée sous le bandeau du joueur (elle ne pousse rien) :
+
+- icône d'appréciation, puis le **mot en couleur** suivi d'un point
+  (« Bon coup. »), puis la **phrase du maître en italique**, sur une ligne,
+  tronquée par des points de suspension si elle est trop longue, et un
+  chevron ;
+- elle apparaît **après** la validation du coup du joueur (ou sa décision de
+  videau), dès que l'analyse est prête, en fondu de `duration-fast` ; elle
+  s'efface à l'action suivante du joueur (lancer les dés, toucher un pion) ;
+- **pendant que le joueur réfléchit, rien n'apparaît** ; si l'analyse arrive
+  trop tard (le joueur a déjà relancé), la ligne n'apparaît pas, et le coup
+  reste commenté dans le bilan ;
+- conseil désactivé : la ligne reste réservée et vide (la mise en page ne
+  bouge pas).
+
+### Les mots
+
+| Seuil gnubg (écart d'équité) | Mot | Couleur | Icône |
+| --- | --- | --- | --- |
+| meilleur coup, ou moins de 0,03 | Bon coup | `verdict-good` | coche |
+| 0,03 à 0,06 (doubtful) | Imprécision | `verdict-doubtful` | point d'interrogation |
+| 0,06 à 0,12 (bad) | Erreur | `verdict-bad` | croix |
+| plus de 0,12 (very bad) | Grosse erreur | `verdict-bad` | croix |
+
+Pour le videau : « Bon choix » et « Bonne décision » remplacent « Bon coup ».
+« Grosse erreur » est la recommandation de design ; `docs/etape-1.md` écrit
+« gaffe », et le choix final revient à Pierre (ton).
+
+### La feuille d'explication
+
+Maquette « Feuille d'explication du maître ». Toucher la ligne ouvre une
+feuille qui monte du bas (`duration-moderate`), au-dessus du plateau voilé :
+
+1. le mot d'appréciation et le contexte (« Erreur · votre 3-1 d'ouverture ») ;
+2. le titre : le coup du maître, à la première personne (« J'aurais joué
+   8/5 6/5 ») ; pour un bon coup : « C'est aussi le coup que j'aurais joué » ;
+3. la phrase du maître, en italique ;
+4. un sélecteur à deux segments, « Votre coup » et « Le coup du maître », au-
+   dessus d'un plateau qui montre la position d'avant le coup ; le coup choisi
+   se joue pion par pion (`duration-fast`), avec un tracé du départ à
+   l'arrivée : `text` pour votre coup, `verdict-good` pour celui du maître ;
+5. « Voir les chiffres du moteur » (repliée par défaut) : le classement des
+   coups avec leur écart d'équité et le niveau d'évaluation ; votre coup est en
+   gras ;
+6. « Demander à une IA » (1f) et « Fermer ».
+
+Le lien vers la fiche d'un concept du glossaire n'apparaît que si le moteur
+permet de le déterminer, sinon rien.
+
+### Les phrases du maître
+
+- **Le maître parle à la première personne et vouvoie** : « J'aurais joué… »,
+  jamais « Vous auriez dû… », jamais « Il fallait… ».
+- **Il ne cite que des faits** : le coup recommandé, le rang de votre coup,
+  les pions frappés, les points faits ou laissés (lisibles dans le coup
+  lui-même), l'écart d'équité sur demande. Aucune explication stratégique
+  inventée (« la case la plus précieuse », « trop risqué ») : celles-là
+  viendront des leçons, relues par un joueur fort.
+- **Trois parties au plus** : ce que vous avez fait, ce que le maître préfère,
+  un fait qui les distingue. Moins de 140 caractères pour la ligne ; la
+  feuille peut aller jusqu'à deux phrases.
+- **Ton** : encourageant et sobre. Pas de point d'exclamation, pas d'émoji, pas
+  de superlatif. Les bons coups ont plusieurs formules qui tournent
+  (« C'est le coup du maître. », « Exactement ce que j'aurais joué. »,
+  « Bien vu. »), pour ne pas lasser.
+- **Exemples** (gabarits à remplir avec les données du moteur) :
+  - Bon coup : « Bien vu. 8/5 6/5 fait votre point 5. »
+  - Imprécision : « J'aurais joué {meilleur}. Votre coup était le
+    {rang}e choix, tout près. »
+  - Erreur : « J'aurais joué {meilleur}. Votre {joué} était le {rang}e
+    choix. »
+  - Videau, prise juste : « Bonne décision : prendre était le bon choix. »
+  - Videau, double manqué : « Ici, j'aurais doublé. »
+
+## 1e. Bilan et analyse
+
+### Bilan (`#/parties/<id>/bilan`)
+
+Maquette « Bilan de fin de partie ». Il remplace le panneau de fin de partie
+quand l'analyse est prête ; avant, le panneau actuel s'affiche et le bilan le
+remplace en place, sans saut.
+
+1. `overline` « Fin de partie », titre `display` (« Vous gagnez », « L'ordinateur
+   gagne un gammon »), puis une phrase : le résultat en points et une
+   lecture simple du jeu et des dés (« Votre jeu a fait la différence, avec
+   des dés un peu contre vous. »), construite à partir du taux d'erreur et de
+   la chance donnés par le moteur, jamais inventée.
+2. Trois cases côte à côte : le nombre de bons coups, d'imprécisions et
+   d'erreurs (grosses erreurs comprises), chiffre en 28 px, mot et icône en
+   couleur d'appréciation.
+3. Deux jauges sur une ligne chacune :
+   - « Votre jeu » : le taux d'erreur traduit en niveau (correspondance avec
+     les classements de gnubg documentée, mêmes noms que les niveaux de
+     l'ordinateur), jauge en `verdict-good` ;
+   - « Les dés » : la chance, jauge centrée (à droite si elle vous a aidé, à
+     gauche sinon), en `border-strong`, avec trois mots possibles : « pour
+     vous », « équilibrés », « contre vous » (« un peu » ou « nettement »
+     selon l'écart).
+   Lien « Comment lire ces mesures » vers les fiches du glossaire.
+4. « Le coup à revoir » : la plus grosse erreur, mini-plateau, mot
+   d'appréciation, coup joué et coup du maître ; « Revoir ce coup » (ouvre
+   l'analyse sur ce coup) et « Demander à une IA ». Sans erreur ni
+   imprécision : la carte dit « Aucun coup à revoir : vous avez joué comme le
+   maître. »
+5. Barre d'actions : « Voir l'analyse » et « Nouvelle partie » (principale).
+
+### Analyse (`#/parties/<id>/analyse/<coup>`)
+
+Maquette interactive « Analyse ». Une page qui défile, de haut en bas :
+
+1. **Courbe de vos chances de gagner**, coup après coup, en pourcentage (pas
+   en équité : un débutant lit « 41 % », pas « −0,18 »). Tracé `text` de 2 px,
+   aire `accent-soft`, ligne pointillée à 50 %. Les coups commentés sont des
+   points de couleur d'appréciation, les autres de petits points `text`.
+   **On parcourt la courbe du doigt** : chaque coup possède une bande verticale
+   sur toute la hauteur du graphique, qui sert de cible tactile ; le coup
+   choisi porte un trait vertical brique et un point cerclé.
+2. **Visualiseur** : « ‹ Coup 7 sur 24 · 6-1 › », le plateau de la position
+   d'avant le coup, la phrase du maître, le sélecteur « Votre coup » / « Le
+   coup du maître » de la feuille 1d, puis « Rejouer d'ici » (crée une
+   branche, ADR 0011 et 1b) et « Demander à une IA ».
+3. **Les coups à revoir** : filtres en pastilles de 44 px (« Tout »,
+   « Erreurs », « Imprécisions », avec leurs nombres), puis une ligne par
+   coup : numéro, dés, coup joué, mot d'appréciation. Toucher une ligne place
+   le visualiseur et la courbe sur ce coup.
+
+Sur ordinateur, `←` et `→` passent d'un coup à l'autre.
+
+## 1f. Demander à une IA
+
+Le bouton est secondaire partout, jamais l'action principale, avec l'icône
+de copie : dans la feuille du maître (1d), dans la carte « Le coup à
+revoir » du bilan, dans le visualiseur de l'analyse, et dans une fiche du
+glossaire. Après la copie, le bandeau « Prompt copié » (`verdict-good`, 2 s),
+puis le texte du prompt reste lisible dans une zone `surface-sunken`
+repliable, pour qui veut le relire avant de le coller (composant `AskAI`).
+
+## 1g. Leçons (`#/lecons`, `#/lecons/<n>/<écran>`)
+
+Maquette « Leçons ». En tête, un rappel discret « Les règles du jeu ·
+revoir » (le tutoriel de 0e.5). Puis les cinq leçons numérotées, dans
+l'ordre, chacune avec une pastille ronde à son numéro :
+
+- terminée : pastille `verdict-good`, « Terminée » ;
+- en cours : carte bordée de brique, pastille brique, « 2 exercices sur 4 »,
+  barre de progression, bouton « Continuer » (seule action principale de
+  l'écran) ;
+- à commencer : pastille au contour `border-strong`.
+
+Toutes les leçons restent ouvertes : l'ordre est conseillé, jamais imposé.
+Les écrans d'une leçon suivent la forme du tutoriel (barre de progression,
+« Passer », « Retour », « Continuer », écrans « à vous » contrôlés par le
+moteur).
+
+## 1h. Progression (`#/progression`)
+
+Maquette « Progression ».
+
+- Une phrase de synthèse, factuelle (« Sur vos 8 dernières parties, vous
+  faites moins d'erreurs : votre taux d'erreur est passé de 14 à 7. »). Si la
+  tendance monte, la phrase reste encourageante et sans reproche (« Votre
+  taux d'erreur remonte un peu ces derniers jours. Les leçons sont là
+  pour reprendre un point. »).
+- La courbe du taux d'erreur par partie terminée, avec le rappel « plus bas,
+  c'est mieux » dans son titre, le dernier point en `verdict-good`, et un lien
+  vers la fiche « taux d'erreur ».
+- La liste des parties (résultat, date, niveau de l'ordinateur, taux d'erreur
+  en chiffre gras aligné à droite), chacune ouvrant son bilan.
+- Moins de trois parties analysées : pas de courbe, une phrase « Votre
+  courbe apparaîtra après trois parties. ».
+
+## 1i. Gestes sur le plateau
+
+- **Glisser-déposer** : le pion suit le doigt, agrandi à 115 % et décalé de
+  12 px vers le haut pour rester visible sous le doigt ; à son départ, un pion
+  fantôme en pointillés ; les cases d'arrivée permises gardent leur voile et
+  leur anneau (révision UX). Lâché sur une case permise : il s'y pose
+  (`duration-fast`, vibration « pion posé ») ; lâché ailleurs : il revient à
+  sa place en `duration-fast`, sans vibration ni message.
+- **Double toucher** : joue le coup évident quand il existe (un seul coup légal
+  complet commence par ce pion, ou le moteur n'en propose qu'un) ; sinon, il
+  vaut un simple toucher, sans message d'erreur.
+- **Toucher simple** : inchangé (pion puis case, ou avance directe s'il n'a
+  qu'une case d'arrivée).
+- Les trois gestes coexistent ; aucun n'est expliqué par une fenêtre : le
+  tutoriel et l'aide en parlent.

docs/plans/2026-11-03-accueil-tutoriel-aide.md

@@ -1,59 +0,0 @@
-# Accueil, installation, tutoriel des règles, aide (0e.5)
-
-- **Date** : 2026-11-03
-- **Étape** : 0e.5 (feuille de route), qui couvre aussi le tutoriel de 1g
-- **Statut** : prévu (après la fusion de 0e.4)
-- **Exécutant** : sous-agent general-purpose, dans un worktree
-
-## Objectif
-
-Traiter les points 2 et 3 du message de Pierre du 2026-11-03 et sa demande d'installation en un toucher :
-- une page d'accueil ;
-- l'installation proposée par l'app ;
-- un tutoriel des règles très didactique, illustré par le plateau ;
-- une aide plus humaine.
-
-## Références
-
-- Règles : `docs/identite/charte/accueil-tutoriel-aide.md`. Le texte du tutoriel y figure en première version, à faire valider par Pierre.
-- Maquettes : https://claude.ai/artifact/CQw6vbDpi6XQqVWQa4sANe, rangée « Étape 0e.5 » et artboard « Accueil ».
-- ADR 0008 (source unique), ADR 0013 (positions par identifiants gnubg).
-
-## Consignes
-
-1. **Accueil**, selon la charte :
-   - au premier lancement, et une seule fois, le choix entre « Je découvre » et « Je connais les règles » ;
-   - ensuite : la partie en cours, la carte d'installation, la prochaine leçon et la progression résumée. La leçon et la progression restent en attente tant que 1g et 1h n'existent pas : n'afficher que ce qui existe.
-2. **Installation** :
-   - sous Chrome, garder l'invite reçue avec `beforeinstallprompt` ;
-   - sous Firefox et sur iPhone, une feuille en 3 étapes ;
-   - la carte n'apparaît qu'à partir de la première partie terminée. « Plus tard » la masque, et elle ne revient qu'une fois, après 3 parties. Le menu garde une ligne tant que l'app n'est pas installée ;
-   - plus rien en `display-mode: standalone` ni après l'événement `appinstalled`.
-3. **Tutoriel**, en 8 étapes :
-   - le texte vit dans un fichier source unique sous `docs/` (par exemple `docs/tutoriel/`), copié dans le site par `make site` comme le glossaire, sous licence CC BY-SA 4.0 ;
-   - positions données par leurs identifiants gnubg ;
-   - sur les écrans « à vous », le moteur vérifie le coup joué en le comparant aux coups attendus de l'étape ;
-   - le coup illustré se joue seul après 1 s, avec « Revoir » ;
-   - un test vérifie que chaque position du tutoriel est valide pour le moteur et que chaque coup attendu est légal ;
-   - ajouter la fiche du glossaire « camp ».
-4. **Aide**, en trois onglets :
-   - « Jouer » : les scénarios deviennent des questions repliables. Le titre est la question et la description la réponse ; les étapes Gherkin sont cachées. Reformuler les titres des `.feature` sans casser les tests ;
-   - « Les mots du jeu » : les cartes du glossaire, avec une recherche ;
-   - « À propos » : licence, crédits, version ;
-   - le tutoriel est proposé en tête de l'aide.
-5. **Scénarios Gherkin** : premier lancement, installation, suivre le tutoriel.
-6. **`make test-browser`** :
-   - premier lancement, tutoriel complet avec ses écrans « à vous », aide ;
-   - `beforeinstallprompt` simulé dans Chromium ;
-   - captures dans `build/browser-shots/accueil-tutoriel/` pour la recette design.
-
-`make lint`, `make test` et `make test-browser` doivent passer. Aucune nouvelle dépendance.
-
-## Critères de réussite
-
-- Un débutant suit le tutoriel jusqu'au bout sur le téléphone, et chaque écran « à vous » accepte le bon coup et refuse les autres.
-- Les trois commandes passent, et les captures sont livrées pour la recette.
-
-## Résultat
-
-À remplir à la clôture.

docs/plans/2026-11-03-bilan-et-analyse.md

@@ -0,0 +1,46 @@
+# Fin de partie et analyse (1e)
+
+- **Date** : 2026-11-03
+- **Étape** : 1e (`docs/etape-1.md`)
+- **Statut** : prévu (après 1d)
+- **Exécutant** : sous-agent general-purpose, dans un worktree
+
+## Objectif
+
+Que le joueur comprenne sa partie : le bilan de fin de partie (ADR 0011), puis un écran d'analyse avec graphe d'équité, liste des erreurs, visualiseur et « Rejouer d'ici ».
+
+## Consignes
+
+Respecter les ADR 0007, 0008, 0011 et 0013. Chaque écran a son adresse : `#/parties/<id>/bilan` et `#/parties/<id>/analyse/<coup>`, à ajouter au tableau de l'ADR 0013 par un amendement. Pour la charte, suivre les maquettes « Fin de partie » du canevas. Aucune nouvelle dépendance : le graphe est dessiné en SVG à la main.
+
+1. **Analyse de la partie.** Elle réutilise les analyses rangées par 1d (coups et videau) et complète celles qui manquent en arrière-plan, de façon progressive et annulable. Elle donne :
+   - le taux d'erreur à la manière de gnubg ;
+   - la chance aux dés (`luck`) pour chaque camp ;
+   - le décompte des coups par appréciation.
+2. **Bilan**, dans le panneau de fin de partie existant :
+   - le résultat ;
+   - les coups par appréciation ;
+   - le taux d'erreur comparé à la chance, en phrases simples ;
+   - « le coup à revoir » : la plus grosse erreur, avec sa position, le coup joué et le meilleur coup ;
+   - un emplacement pour le bouton « Demander à une IA » (1f) ;
+   - « Voir l'analyse ».
+3. **Écran d'analyse** :
+   - un graphe d'équité où toucher un point ouvre la position ;
+   - la liste des erreurs, filtrable par appréciation ;
+   - un visualiseur pas à pas qui montre sur le plateau le coup joué contre le meilleur coup, avec des pions animés ;
+   - « Rejouer d'ici », qui crée une branche (domaine de 1b) sans toucher l'original.
+4. **Tests** :
+   - scénarios Gherkin : bilan, coup à revoir, rejouer d'ici, chacun avec des dés imposés ;
+   - fiches du glossaire : taux d'erreur, graphe d'équité si absentes ;
+   - `make lint`, `make test`, `make test-browser`, avec des captures pour la recette design.
+
+## Critères de réussite
+
+- Après une partie, le bilan nomme le coup à revoir, conforme à l'analyse du moteur.
+- L'analyse s'ouvre par son adresse.
+- « Rejouer d'ici » crée une branche.
+- Les trois commandes passent.
+
+## Résultat
+
+À remplir à la clôture.

docs/plans/2026-11-03-conseil-du-maitre.md

@@ -0,0 +1,60 @@
+# Conseil du maître (1d)
+
+- **Date** : 2026-11-03
+- **Étape** : 1d (`docs/etape-1.md`)
+- **Statut** : prévu (après 1c)
+- **Exécutant** : sous-agent general-purpose, dans un worktree
+
+## Objectif
+
+Le coach bienveillant, « mis en avant mais discret » (Pierre, 2026-11-03) :
+après chaque coup et chaque décision de videau du joueur, jamais avant
+(ADR 0011), une appréciation et une phrase du maître fondées sur les chiffres
+du moteur.
+
+## Références
+
+- ADR 0011 ; maquette « conseil du maître après le coup » du canevas
+  https://claude.ai/artifact/CQw6vbDpi6XQqVWQa4sANe ; règles de la charte
+  (`docs/identite/charte/`, dont interaction.md) ; la ligne réservée de 44 px
+  de la révision UX.
+- Moteur : `analyseMove`, `analyseCube`, `luck`, seuils `SKILL_THRESHOLDS`
+  (gnubg : 0,03 / 0,06 / 0,12).
+
+## Consignes
+
+1. **Analyse en arrière-plan** : après la validation d'un coup (ou une
+   décision de videau), l'analyse à 2 plis part dans le Worker sans retarder le
+   tour de l'ordinateur ; son résultat est rattaché au coup dans le journal
+   (événement d'analyse rétrocompatible, ou cache séparé justifié) pour servir
+   au bilan (1e) sans recalcul.
+2. **Ligne du maître** : icône d'appréciation, mot en couleur (« Bon coup. »,
+   « Imprécision. », « Erreur. », « Grosse erreur. » (choix de Pierre du 2026-11-09, plutôt que « gaffe ») : correspondance avec les seuils
+   de gnubg documentée), phrase courte en italique, chevron. Toucher ouvre la
+   feuille d'explication : coup joué et meilleur coup montrés sur le plateau
+   (pions animés, ADR 0011 « comparaison visuelle »), écart d'équité seulement
+   sur demande, lien vers la fiche du glossaire du concept en jeu si le moteur
+   permet de le déterminer, sinon rien.
+3. **Phrases du maître** : gabarits versionnés en français dans une source
+   unique sous `docs/` (CC BY-SA 4.0), ton encourageant, jamais culpabilisant ;
+   elles ne citent que des faits du moteur (coup recommandé, rang, pions
+   frappés, écart) : aucune explication inventée. Première version à faire
+   valider par Pierre (ton).
+4. **Discret** : rien n'apparaît pendant que le joueur réfléchit ; la ligne
+   s'efface à l'action suivante ; désactivable (réglage de 1c et menu).
+5. **Videau** : même traitement pour doubler, ne pas doubler, prendre, passer.
+6. Scénarios Gherkin (bon coup, erreur avec meilleur coup montré, conseil
+   désactivé, décision de videau commentée) avec positions et dés imposés ;
+   tests unitaires des gabarits (chaque gabarit rendu sur des analyses réelles
+   du moteur). `make lint`, `make test`, `make test-browser`, captures pour la
+   recette design.
+
+## Critères de réussite
+
+Après une erreur volontaire dans une position connue, la ligne du maître dit
+« Erreur. », nomme le coup recommandé par le moteur et le montre sur demande ;
+le tour de l'ordinateur n'est pas retardé ; les trois commandes passent.
+
+## Résultat
+
+À remplir à la clôture.

docs/plans/2026-11-03-lecons.md

@@ -0,0 +1,36 @@
+# Cinq premières leçons et accueil complet (1g)
+
+- **Date** : 2026-11-03
+- **Étape** : 1g (`docs/etape-1.md`) ; le tutoriel des règles est traité en 0e.5
+- **Statut** : prévu (après 0e.5 et 1d)
+- **Exécutant** : sous-agent general-purpose, dans un worktree
+
+## Objectif
+
+Mettre en place les cinq premières leçons numérotées de l'ADR 0011. Chaque leçon est faite d'écrans courts : une explication, une position animée, puis « à vous de jouer ». La progression est stockée localement, et l'accueil propose « Continuer la leçon ».
+
+## Consignes
+
+1. **Contenus.** Ils vivent dans une source unique sous `docs/lecons/`, sous licence CC BY-SA 4.0, au même format que le tutoriel de 0e.5 (réutiliser son moteur d'écrans). Cinq leçons du parcours 2 du cadrage, au niveau débutant :
+   1. Les ouvertures : bien jouer ses premiers dés.
+   2. Construire ses cases et faire des points.
+   3. Frapper ou ne pas frapper : sécurité et risque.
+   4. La course et le compte de points.
+   5. Sortir ses pions sans se faire frapper.
+
+   Chaque leçon compte deux à quatre exercices « à vous ». Leurs positions sont données par identifiants gnubg. La réponse attendue est le meilleur coup du moteur à 2 plis, vérifié par un test. Le texte n'affirme rien que le moteur ne confirme. Les contenus sont livrés en brouillon, marqués « à relire par un joueur fort » (cadrage, risque « contenus »), et Pierre les valide.
+2. **Progression.** Elle est enregistrée dans le stockage de 1b, dans le magasin `settings` ou dans un nouveau magasin avec montée de version (ADR 0007 amendé). Chaque leçon a son état : à commencer, « 2 exercices sur 4 », terminée.
+3. **Adresses** : `#/lecons` et `#/lecons/<n>/<écran>`, à ajouter au tableau de l'ADR 0013.
+4. **Accueil.** Il reçoit la carte « prochaine leçon » prévue par la charte.
+5. **Tests.**
+   - Pour chaque exercice, la position est valide et la réponse attendue est bien le meilleur coup du moteur.
+   - Scénarios Gherkin.
+   - `make lint`, `make test`, `make test-browser`, avec captures.
+
+## Critères de réussite
+
+Les cinq leçons se suivent jusqu'au bout. Chaque exercice accepte le coup du moteur et commente les autres avec bienveillance. Les trois commandes passent.
+
+## Résultat
+
+À remplir à la clôture.

docs/plans/2026-11-03-match-et-reglages.md

@@ -0,0 +1,47 @@
+# Match, niveaux et réglages (1c)
+
+- **Date** : 2026-11-03
+- **Étape** : 1c (`docs/etape-1.md`)
+- **Statut** : prévu (après la révision UX et 1b)
+- **Exécutant** : sous-agent general-purpose, dans un worktree
+
+## Objectif
+
+Choisir sa partie : partie libre ou match en N points, avec les règles de
+Crawford et de Jacoby, contre l'ordinateur au niveau voulu.
+
+## Consignes
+
+ADR 0007, 0008. Le moteur expose depuis 1a les niveaux de gnubg
+(`levelMove`, `levelCubeDecision`) et accepte les matchs dans son API C.
+
+1. **Domaine** : longueur de match, score, règle de Crawford (partie Crawford
+   et suivantes, calculées par le moteur via le Match ID), règle de Jacoby en
+   partie libre ; enchaînement des manches d'un match jusqu'à sa fin ; le
+   journal d'événements reste rétrocompatible (les parties existantes se
+   rechargent).
+2. **Adaptateur** : `EngineCube` étendu au match (score, longueur, Crawford)
+   ou remplacé par le Match ID, sans casser les appels existants.
+3. **Niveau de l'ordinateur** : ses coups et ses décisions de videau au niveau
+   choisi. Reprendre de `ComputerTurn` (gnubg, `play.c`) les règles de
+   déroulement non reprises en 1a : pré-filtre « fenêtre de marché » et double
+   facultatif à 0 pli, avec citation des sources.
+4. **Écran de nouvelle partie** (maquettes de la session « identité » si
+   disponibles, sinon sobre et conforme à la charte) : type de partie, niveau
+   (noms montrés au joueur à proposer simplement : Débutant, Amateur,
+   Intermédiaire, Avancé, Expert, Champion — correspondance avec les niveaux
+   de gnubg documentée), conseil du maître activé ou non. Par défaut : partie
+   libre, Intermédiaire, conseil activé. Le réglage est mémorisé.
+5. Affichage du score de match et de la partie Crawford sur le plateau.
+6. Scénarios Gherkin (match en 3 points jusqu'au bout avec dés imposés,
+   Crawford, Jacoby) et fiches du glossaire (match, Crawford, Jacoby si
+   absentes). `make lint`, `make test`, `make test-browser` (un match court).
+
+## Critères de réussite
+
+Un match en 3 points se joue jusqu'au bout, au niveau choisi, avec Crawford
+appliqué ; les trois commandes passent.
+
+## Résultat
+
+À remplir à la clôture.

docs/plans/2026-11-03-parties-enregistrees.md

@@ -1,57 +0,0 @@
-# Parties enregistrées, branches et export SGF (1b)
-
-- **Date** : 2026-11-03
-- **Étape** : 1b (`docs/etape-1.md`)
-- **Statut** : prévu (lancé après la fusion de 0e.1)
-- **Exécutant** : sous-agent general-purpose, dans un worktree
-
-## Objectif
-
-Garder toutes les parties du joueur sur le téléphone, avec leurs branches, et
-les exporter au format SGF de GNU Backgammon.
-
-## Consignes
-
-ADR 0007 (domaine pur, stockage derrière une interface), ADR 0008 (scénarios
-et glossaire). Aucune nouvelle dépendance : l'API IndexedDB du navigateur
-directement.
-
-1. **Stockage IndexedDB** derrière l'interface de `app/src/storage/` : une
-   liste de parties (identifiant, date de début et de dernière action,
-   adversaire et niveau, score, état en cours ou finie, résultat) et le
-   journal d'événements de chacune. Migration transparente de la partie
-   en cours enregistrée aujourd'hui dans `localStorage`. Si IndexedDB est
-   indisponible (navigation privée), repli sur le comportement actuel.
-2. **Branches** : le journal est déjà un arbre (événements avec parent,
-   `goBackTo`). Exposer dans le domaine la liste des branches d'une partie
-   (feuilles de l'arbre, avec le coup d'origine) et le passage de l'une à
-   l'autre. « Rejouer d'ici » depuis un coup passé crée une branche ; la
-   branche d'origine reste intacte et rechargeable. Pas d'écran d'analyse ici
-   (1e) : un accès minimal suffit pour le test (menu « Mes parties » :
-   reprendre une partie, voir ses branches).
-3. **Nouvelle partie annulable** : l'arbitrage UX (plan
-   `2026-11-03-revision-ux.md`, point 3) prévoit « Reprendre l'ancienne »
-   pendant 10 s. Fournir l'API de stockage qui le permet (reprendre une partie
-   par son identifiant) ; l'interface viendra avec la révision UX.
-4. **Export SGF** : une partie (et ses branches en variantes) au format SGF
-   de GNU Backgammon, téléchargeable depuis « Mes parties ». Vérification par
-   le gnubg de bureau de référence (Docker existant) : le fichier exporté se
-   charge sans erreur et ses positions successives sont les mêmes que celles
-   du journal, sur des parties générées par les tests.
-5. Scénarios Gherkin : reprendre une partie parmi plusieurs, rejouer d'ici
-   sans perdre l'original, exporter une partie. Fiches du glossaire pour les
-   nouveaux termes (branche, SGF…).
-
-`make lint`, `make test` et `make test-browser` passent (ajouter au test
-navigateur : deux parties enregistrées, reprise de la première après
-rechargement). Commits fréquents ; pas de push ni de MR.
-
-## Critères de réussite
-
-- Après rechargement, la liste des parties et chaque branche sont intactes.
-- Un SGF exporté se charge dans gnubg de bureau avec les mêmes positions.
-- Les trois commandes de test passent.
-
-## Résultat
-
-À remplir à la clôture.

docs/plans/2026-11-03-plateau-soigne.md

@@ -0,0 +1,32 @@
+# Plateau soigné : gestes et finitions (1i)
+
+- **Date** : 2026-11-03
+- **Étape** : 1i (`docs/etape-1.md`)
+- **Statut** : prévu
+- **Exécutant** : sous-agent general-purpose, dans un worktree
+
+## Objectif
+
+Terminer le plateau soigné du cadrage, une fois la révision UX en place :
+- les gestes naturels (principe d'expérience 2) ;
+- les écarts restants avec `docs/identite/charte/board.js`.
+
+## Consignes
+
+1. **Glisser-déposer.** On peut glisser un pion en plus du toucher pion puis destination. Le pion suit le doigt, et le lâcher hors d'une case permise le ramène à sa place. Les cibles restent celles du moteur.
+2. **Double toucher.** Un double toucher sur un pion joue le seul coup évident (cadrage). Un « coup évident » est défini ainsi : un seul coup légal complet commence par ce pion, ou le moteur ne propose qu'un coup. Sinon, rien ne se passe.
+3. **Écarts restants avec board.js.** Les relever par comparaison visuelle (filet des pions, numéros sur le cadre, videau…) et les corriger.
+4. **Clavier.** Faire ce que la révision UX a laissé :
+   - le choix des pions aux flèches ;
+   - l'affichage des raccourcis en `kbd` quand un clavier est détecté (interaction.md).
+5. **Tests.**
+   - Scénarios Gherkin si un nouveau comportement est visible.
+   - `make lint`, `make test`, `make test-browser` (glisser-déposer simulé, double toucher), avec captures pour la recette design.
+
+## Critères de réussite
+
+Un coup se joue entièrement au glisser-déposer. Le double toucher joue le coup évident. Les trois commandes passent.
+
+## Résultat
+
+À remplir à la clôture.

docs/plans/2026-11-03-position-dans-l-adresse.md

@@ -1,39 +0,0 @@
-# Position dans l'adresse (0e.4)
-
-- **Date** : 2026-11-03
-- **Étape** : 0e.4 (feuille de route)
-- **Statut** : prévu (après la fusion de la révision UX, qui touche les mêmes fichiers)
-- **Exécutant** : sous-agent general-purpose, dans un worktree
-
-## Objectif
-
-Appliquer l'ADR 0013 : chaque position du plateau a un lien direct.
-
-## Consignes
-
-ADR 0007, 0008 et 0013. Aucune nouvelle dépendance.
-
-1. Lecture du fragment `#position=…&match=…` au chargement et sur
-   `hashchange` ; validation par le moteur ; message clair si illisible.
-2. Vue de la position, non jouable, avec « Jouer à partir d'ici » (nouvelle
-   partie depuis la position, la partie en cours restant reprenable) et
-   « Retour à ma partie ».
-3. Domaine : démarrer une partie depuis une position et un Match ID donnés
-   (événement GameStarted étendu de façon rétrocompatible, ou équivalent
-   justifié), sans règle réimplémentée.
-4. « Copier le lien de la position » depuis le menu de la partie et depuis la
-   vue du coup de l'ordinateur ; le lien copié rouvre exactement la même
-   position (test aller-retour).
-5. Scénarios Gherkin (« Ouvrir un lien vers une position », « Partager la
-   position »), fiches du glossaire (Position ID, Match ID si absentes).
-6. `make lint`, `make test`, `make test-browser` (ouvrir un lien, jouer à
-   partir d'ici, revenir, lien invalide).
-
-## Critères de réussite
-
-Un lien copié depuis l'app, ouvert dans un nouvel onglet, montre la même
-position ; les trois commandes passent.
-
-## Résultat
-
-À remplir à la clôture.

docs/plans/2026-11-03-progression.md

@@ -0,0 +1,30 @@
+# Progression (1h)
+
+- **Date** : 2026-11-03
+- **Étape** : 1h (`docs/etape-1.md`)
+- **Statut** : prévu (après 1e)
+- **Exécutant** : sous-agent general-purpose, dans un worktree
+
+## Objectif
+
+Mettre en place la progression du cadrage pour la V1 : l'historique des parties et la courbe du taux d'erreur.
+
+## Consignes
+
+1. **Écran `#/progression`.** Il est conforme à la charte et s'ajoute au tableau de l'ADR 0013. Il montre :
+   - la courbe du taux d'erreur par partie terminée, en SVG à la main, sans dépendance ;
+   - la liste des parties, reliée à leur bilan et à leur analyse (1e) ;
+   - un résumé en une phrase.
+2. **Accueil.** Il reçoit la « ligne de progression » de la charte.
+3. **Données.** Elles proviennent des analyses enregistrées : rien n'est recalculé si l'analyse existe. Une partie non analysée est analysée en arrière-plan.
+4. **Tests.**
+   - Scénarios Gherkin.
+   - `make lint`, `make test`, `make test-browser` avec trois parties jouées, et captures.
+
+## Critères de réussite
+
+Après trois parties, la courbe a trois points égaux aux taux d'erreur des bilans. Les trois commandes passent.
+
+## Résultat
+
+À remplir à la clôture.

docs/plans/2026-11-03-prompts.md

@@ -0,0 +1,42 @@
+# Prompts à copier (1f)
+
+- **Date** : 2026-11-03
+- **Étape** : 1f (`docs/etape-1.md`)
+- **Statut** : prévu (après 1e)
+- **Exécutant** : sous-agent general-purpose, dans un worktree
+
+## Objectif
+
+Mettre en place la section « IA générative en V1 » du cadrage. Un bouton « Demander à une IA » copie un prompt rempli avec le contexte exact. Le moteur décide, l'IA explique. L'app n'appelle aucune IA.
+
+## Consignes
+
+1. **Gabarits.** Les cinq gabarits du cadrage sont versionnés dans une source unique sous `docs/prompts/`, sous licence CC BY-SA 4.0 :
+   - « pourquoi ce coup est meilleur » ;
+   - « expliquer cette décision de videau » ;
+   - « bilan de ma partie » ;
+   - « expliquer ce concept » ;
+   - « créer des exercices », à garder pour la progression.
+
+   Chaque gabarit contient :
+   - le rôle et le niveau du joueur ;
+   - le Position ID et le Match ID ;
+   - un diagramme texte de la position, produit à partir du plateau décodé par le moteur ;
+   - les chiffres du moteur, avec le niveau d'évaluation ;
+   - la consigne de ne pas contredire ces chiffres ;
+   - la langue.
+
+   Ajouter aussi le lien `#/position/...` de l'ADR 0013, avec l'adresse publique du site.
+2. **Remplissage.** Une fonction pure remplit les gabarits. Elle est testée sur des analyses réelles du moteur : aucun champ vide ni `{inconnu}`, et les chiffres sont identiques à ceux du moteur.
+3. **Boutons.** Ils sont placés sur le conseil du maître (feuille d'explication), le bilan, l'analyse et la fiche d'un terme du glossaire. La copie passe par `navigator.clipboard`, avec un repli de sélection du texte. Un bandeau « Prompt copié » l'accompagne, et le texte reste visible pour qui veut le relire.
+4. **Tests.**
+   - Scénarios Gherkin : copier le prompt d'une erreur, et celui d'un bilan.
+   - `make lint`, `make test` et `make test-browser`, avec lecture du presse-papiers dans Chromium et captures.
+
+## Critères de réussite
+
+Le prompt copié après une erreur contient la position, les identifiants gnubg et le top 3 du moteur avec les mêmes chiffres que l'app. Les trois commandes passent.
+
+## Résultat
+
+À remplir à la clôture.

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

@@ -1,63 +0,0 @@
-# Révision UX : portrait stable, compte de points, menu, paysage « plateau = écran »
-
-- **Date** : 2026-11-03
-- **Étape** : 0e.3 (feuille de route)
-- **Statut** : prévu
-- **Exécutant** : sous-agent general-purpose, dans un worktree
-
-## Objectif
-
-Appliquer la revue UX (0e.2) telle qu'arbitrée par la session « identité » sur
-délégation de Pierre le 2026-11-03, et l'amendement de l'ADR 0012.
-
-## Références
-
-- Maquettes : https://claude.ai/artifact/CQw6vbDpi6XQqVWQa4sANe, rangées
-  « Révision UX » en bas du canevas.
-- Règles : section « Interaction » du design system, copiée dans
-  `docs/identite/charte/interaction.md` (durées, courbes, motifs de vibration,
-  touches) et composant Icons (10 pictogrammes).
-- Rapport du designer UI : conservé dans la description de la MR qui clôt ce
-  plan.
-
-## Décisions à appliquer
-
-1. **Portrait stable** (maquette « Portrait révisé ») :
-   - une barre haute avec le symbole et trois pictogrammes, libellés de 13 px dessous : Aide, Plein écran, Menu ;
-   - le bandeau de l'ordinateur, puis le plateau, puis le bandeau du joueur ;
-   - une ligne réservée de 44 px : le dernier coup de l'ordinateur avec ↻, ou la ligne du maître ;
-   - la consigne ;
-   - une barre d'actions collée en bas, l'action secondaire à gauche et la principale à droite (« Jouer ce coup »). Toucher les dés valide aussi ;
-   - la durée de calcul affichée disparaît.
-2. **Compte de points** :
-   - en portrait, des bandeaux. Les chiffres sont en 20 px gras, alignés. Le bandeau de celui qui a la main est en accent-soft (« Vous · à vous de jouer »). L'écart s'écrit « mène de 8 », en muted, du côté de celui qui mène. Toucher le chiffre ouvre une bulle avec le texte de la fiche du glossaire (source unique, ADR 0008) ;
-   - en paysage, des pastilles aux bouts de la barre.
-3. **Menu en feuille** qui monte du bas :
-   - il contient Nouvelle partie, Plein écran, Aide et glossaire, Thème, et les interrupteurs Vibrations et « Écran allumé pendant la partie » ;
-   - « Nouvelle partie » agit sans confirmation. Un bandeau « Nouvelle partie commencée. Reprendre l'ancienne » reste 10 s avec une barre de temps, et l'ancienne partie se restaure depuis son journal ;
-   - plus de `window.confirm`.
-4. **Pas de passage automatique du tour** quand aucun coup n'est possible : les dés sont barrés avec le message, et le joueur passe en touchant les dés (ou Espace). Ajouter `overscroll-behavior: none` et `user-select: none`. L'écran reste allumé pendant une partie (Wake Lock), activé par défaut, avec un interrupteur.
-5. **Paysage, « le plateau est l'écran »** (ADR 0012 amendé) :
-   - la vue s'applique dès la rotation, sur `100dvh` ;
-   - la géométrie suit l'écran, par une fonction pure testée unitairement, d'après les formules du composant Board des maquettes ;
-   - une colonne de commandes à gauche dans le cadre : menu en haut, videau au milieu, ↶ en bas, remplacé par ↻ quand le coup de l'ordinateur est montré ;
-   - les sorties restent libres ;
-   - numéros des flèches à 12 px au moins ;
-   - la fin de partie s'affiche dans un panneau centré sur un voile ;
-   - le plein écran s'ouvre sur un geste (pictogramme ou menu), avec `requestFullscreen` puis `screen.orientation.lock` et un repli par rotation CSS. Ce n'est pas le réglage par défaut de l'app installée.
-6. **Vibrations** (`navigator.vibrate`, si disponible) aux quatre moments, avec les motifs d'`interaction.md` : pion posé, pion frappé, double proposé par l'ordinateur, fin de partie. Elles sont activées par défaut, rien au lancer des dés, et elles doublent toujours un signal visible.
-7. **Pictogrammes** du composant Icons, en SVG dans le site (CSP : pas de style en ligne).
-8. **Consigne** : forme longue pendant les trois premières parties, puis forme courte.
-9. **Mouvement** :
-   - durées de 90, 160 et 240 ms, avec la courbe cubic-bezier(0.2, 0, 0, 1) ;
-   - l'ordinateur joue pion par pion : 160 ms par pion, 120 ms de pause ;
-   - `prefers-reduced-motion` est respecté.
-10. **Clavier** (priorité basse) : prévoir dans l'architecture une table d'actions commune au toucher et au clavier. Les touches d'`interaction.md` peuvent venir dans une MR ultérieure.
-
-## Consignes
-
-ADR 0007 : ni le domaine ni le moteur ne changent pour la mise en page. ADR 0008 : scénarios Gherkin pour les comportements visibles nouveaux (nouvelle partie annulable, menu). Aucune nouvelle dépendance. `tests/browser/play.mjs` étendu aux deux orientations, avec des captures Playwright en 412×915, 915×412 et 844×320, en thème clair et sombre, rangées dans un dossier indiqué par la session principale pour la revue design. `make lint`, `make test` et `make test-browser` passent.
-
-## Résultat
-
-À remplir à la clôture.

docs/scenarios/README.md

@@ -33,6 +33,15 @@ Fonctionnalité: <la tâche>
     Et <autre constat>
 ```
 
+Dans l'aide, chaque scénario devient une question repliable : son titre est
+la question, formulée comme le joueur se la pose (« Comment jouer un
+coup ? ») ; le paragraphe sous le titre est la réponse, qui doit se lire
+seule ; les étapes ne s'affichent pas. Une étiquette
+`@position:<Position ID>` au-dessus du scénario ajoute à la réponse le lien
+« Voir sur le plateau ». L'adresse d'une question (`#/aide/<identifiant>`)
+est tirée de son titre : changer un titre change son adresse, et les titres
+cités par `app/src/ui/help-context.ts` sont vérifiés par `make test`.
+
 Règles d'écriture :
 
 - la deuxième personne (« vous ») et les mots du glossaire (`docs/glossaire/`) ;
@@ -47,3 +56,9 @@ Règles d'écriture :
 | Fichier | Tâche | Depuis |
 | --- | --- | --- |
 | [jouer-une-partie.feature](jouer-une-partie.feature) | Jouer une partie contre l'ordinateur | Étape 0d |
+| [mes-parties.feature](mes-parties.feature) | Retrouver mes parties, leurs branches, les exporter en SGF | Étape 1b |
+| [partager-une-position.feature](partager-une-position.feature) | Ouvrir et partager le lien d'une position | Étape 0e.4 |
+| [regler-l-application.feature](regler-l-application.feature) | Régler l'application (menu), la mettre à jour | Étape 0e |
+| [decouvrir-l-application.feature](decouvrir-l-application.feature) | Premier lancement et accueil | Étape 0e.5 |
+| [apprendre-les-regles.feature](apprendre-les-regles.feature) | Apprendre les règles avec le tutoriel | Étape 0e.5 |
+| [installer-l-application.feature](installer-l-application.feature) | Installer l'application | Étape 0e.5 |

docs/scenarios/apprendre-les-regles.feature

@@ -0,0 +1,42 @@
+# language: fr
+Fonctionnalité: Apprendre les règles avec le tutoriel
+
+  Le tutoriel explique les règles en huit petites étapes, sur le vrai
+  plateau : les pions bougent pour montrer chaque règle, et une étape sur
+  deux vous fait jouer le geste vous-même. GNU Backgammon vérifie chaque
+  coup, comme en partie.
+
+  Scénario: Comment se passe le tutoriel ?
+    Chaque étape tient en un écran court : un titre, le plateau, deux ou
+    trois phrases. Le coup montré se joue tout seul après une seconde ;
+    « Revoir » le rejoue. La barre du haut montre où vous en êtes et vous
+    ramène aux étapes déjà vues. « Quitter » vous emmène jouer.
+
+    Étant donné que vous commencez le tutoriel
+    Alors il compte huit étapes, dont quatre où c'est à vous de jouer
+    Et chaque position du tutoriel se lit sur le plateau
+    Quand vous arrivez à l'étape 3
+    Alors la barre de progression vous ramène aux étapes 1 et 2, mais pas aux suivantes
+
+  @position:4HPwATDgc/ABMA
+  Scénario: Je joue un autre coup que celui demandé
+    Sur les écrans « à vous », vous jouez sur le vrai plateau. Si votre coup
+    n'est pas celui demandé, le pion revient et une phrase vous dit
+    pourquoi ; réessayez autant que vous voulez. Le bon coup est salué, et
+    « Continuer » vous mène à la suite.
+
+    Étant donné que vous êtes à l'écran « à vous » de l'étape 3
+    Quand vous déplacez un pion de la flèche 24 à la flèche 21
+    Alors le pion revient, et une phrase vous dit pourquoi
+    Quand vous réunissez deux pions sur la flèche 5
+    Alors le tutoriel salue votre coup
+
+  Scénario: Comment répondre au double dans le tutoriel ?
+    À la dernière étape, l'ordinateur vous propose de doubler. Prenez ou
+    passez : le maître vous dit ensuite ce qu'il aurait fait, et pourquoi.
+
+    Étant donné que vous êtes à l'écran « à vous » de l'étape 8
+    Quand vous répondez « Passer »
+    Alors le maître dit qu'il aurait pris
+    Quand vous répondez « Prendre »
+    Alors le tutoriel salue votre réponse

docs/scenarios/decouvrir-l-application.feature

@@ -0,0 +1,31 @@
+# language: fr
+Fonctionnalité: Découvrir l'application
+
+  À la toute première ouverture, Ustagammon vous demande d'où vous partez,
+  puis s'efface : ensuite, il s'ouvre sur l'accueil, avec votre partie en
+  cours à reprendre d'un toucher.
+
+  @position:4HPwATDgc/ABMA
+  Scénario: Que me propose l'application à la première ouverture ?
+    Deux choix, et c'est tout : « Je découvre » ouvre le tutoriel des règles,
+    « Je connais les règles » lance une partie tout de suite. Ce choix ne
+    revient plus ; le tutoriel reste dans le menu.
+
+    Étant donné que vous ouvrez Ustagammon pour la toute première fois
+    Alors l'accueil vous propose de découvrir les règles ou de jouer tout de suite
+    Quand vous choisissez de découvrir les règles
+    Alors le tutoriel s'ouvre à sa première étape
+    Et ce choix ne vous est plus proposé
+
+  Scénario: Où retrouver ma partie en rouvrant l'application ?
+    L'application s'ouvre sur l'accueil. Votre partie en cours y est, avec
+    son plateau et les comptes de points : « Reprendre la partie » vous y
+    ramène. Sans partie en cours, « Nouvelle partie » en commence une.
+
+    Étant donné que vous avez choisi de jouer tout de suite
+    Et qu'une partie est en cours
+    Quand vous rouvrez Ustagammon
+    Alors l'accueil vous propose de reprendre votre partie
+    Quand la partie se termine
+    Et que vous rouvrez Ustagammon
+    Alors l'accueil vous propose une nouvelle partie

docs/scenarios/installer-l-application.feature

@@ -0,0 +1,46 @@
+# language: fr
+Fonctionnalité: Installer l'application
+
+  Installé, Ustagammon a son icône sur l'écran d'accueil du téléphone,
+  s'ouvre en plein écran et marche sans réseau. L'application vous le
+  propose au bon moment, une fois, sans jamais interrompre une partie.
+
+  Scénario: Comment installer l'application ?
+    Touchez « Installer » sur l'accueil, ou « Installer l'application » dans
+    le menu. Avec Chrome, le téléphone vous demande de confirmer. Avec
+    Firefox ou sur iPhone, l'application vous montre la marche à suivre, en
+    trois étapes.
+
+    Étant donné que votre navigateur ne propose pas lui-même l'installation
+    Quand vous demandez à installer l'application avec Firefox
+    Alors la marche à suivre compte trois étapes, en commençant par le menu du navigateur
+    Quand vous demandez à installer l'application sur iPhone
+    Alors la marche à suivre compte trois étapes, en commençant par le bouton de partage
+
+  Scénario: Quand l'application me propose-t-elle de l'installer ?
+    Jamais à la première ouverture ni pendant une partie : l'invitation
+    apparaît sur l'accueil après votre première partie terminée. « Plus
+    tard » la masque ; elle revient une seule fois, trois parties plus tard.
+    Le menu garde « Installer l'application » tant qu'elle n'est pas
+    installée.
+
+    Étant donné que vous ouvrez Ustagammon pour la toute première fois
+    Alors l'accueil ne vous propose pas d'installer l'application
+    Quand vous terminez une partie
+    Alors l'accueil vous propose d'installer l'application
+    Quand vous choisissez « Plus tard »
+    Alors l'accueil ne vous propose pas d'installer l'application
+    Mais le menu vous le propose toujours
+    Quand vous terminez 3 parties de plus
+    Alors l'accueil vous propose d'installer l'application
+    Quand vous choisissez « Plus tard »
+    Et que vous terminez 3 parties de plus
+    Alors l'accueil ne vous propose pas d'installer l'application
+
+  Scénario: Et une fois l'application installée ?
+    Une fois Ustagammon installé, plus rien ne vous propose de l'installer.
+
+    Étant donné que vous avez terminé une partie
+    Quand vous installez l'application
+    Alors l'accueil ne vous propose pas d'installer l'application
+    Et le menu non plus

docs/scenarios/jouer-une-partie.feature

@@ -1,20 +1,26 @@
 # language: fr
 Fonctionnalité: Jouer une partie contre l'ordinateur
 
-  Vous jouez une partie complète contre l'ordinateur, qui s'appuie sur le
-  moteur GNU Backgammon. L'application tire les dés, n'accepte que les coups
+  Vous jouez une partie complète contre l'ordinateur, qui s'appuie sur
+  GNU Backgammon. L'application tire les dés, n'accepte que les coups
   permis par les règles, et l'ordinateur joue et décide du videau tout seul.
 
-  Scénario: Commencer une partie
+  @position:4HPwATDgc/ABMA
+  Scénario: Comment commence une partie ?
+    Les pions sont en position de départ. Chaque camp lance un dé : celui
+    qui a le plus fort commence, et joue ces deux dés. En cas d'égalité, on
+    relance.
+
     Quand vous commencez une nouvelle partie
     Alors les pions sont en position de départ
     Et le premier jet de dés désigne qui commence
 
-  Scénario: Jouer un coup permis
+  @position:4HPwATDgc/ABMA
+  Scénario: Comment jouer un coup ?
     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 ».
+    ou de l'autre du plateau, ou « Jouer ce coup ».
 
     Étant donné que c'est à vous de jouer avec le jet 3-1
     Quand vous jouez 8/5 6/5
@@ -24,16 +30,17 @@ Fonctionnalité: Jouer une partie contre l'ordinateur
     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.
+  Scénario: Pourquoi mon pion part-il dès que je le touche ?
+    Un pion qui n'a qu'une case d'arrivée possible y va dès que vous le
+    touchez, sans attendre un second toucher. Par exemple, avec 3-1, une fois
+    8/5 joué, il ne vous reste que le 1.
 
     É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
+  Scénario: Je me suis trompé de pion
     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.
 
@@ -45,37 +52,44 @@ Fonctionnalité: Jouer une partie contre l'ordinateur
     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.
+  @position:4HPwATDgc/ABMA
+  Scénario: Pourquoi je ne peux pas poser mon pion sur cette flèche ?
+    Une flèche où l'ordinateur a au moins deux pions est fermée : vous ne
+    pouvez pas vous y poser. Au départ, par exemple, la flèche 12 est tenue
+    par cinq de ses pions.
 
     Étant donné que c'est à vous de jouer avec le jet 3-1
     Quand vous essayez de jouer 13/12
     Alors votre coup est refusé
     Et la position n'a pas changé
 
-  Scénario: L'ordinateur joue
+  Scénario: Comment joue l'ordinateur ?
+    L'ordinateur lance ses dés et joue le coup que GNU Backgammon, l'un des
+    meilleurs programmes de backgammon, juge le meilleur. Il répond en
+    moins de deux secondes.
+
     Étant donné que c'est au tour de l'ordinateur
     Quand ses dés sont tirés
     Alors il joue le coup recommandé par le moteur en moins de 2 secondes
 
-  Scénario: Aucun coup possible avec votre jet
+  Scénario: Je ne peux rien jouer avec mes dés
     Il arrive que les dés ne permettent de bouger aucun pion. Votre jet reste
-    affiché avec un message, et le tour ne passe à l'ordinateur qu'une fois
-    que vous avez touché « Continuer ».
+    affiché, barré, avec un message. L'application ne joue jamais à votre
+    place : le tour ne passe à l'ordinateur que quand vous touchez vos dés
+    (ou « Continuer »).
 
     Étant donné que votre pion sur la barre ne peut pas rentrer
     Quand vous lancez les dés
     Alors aucun coup n'est possible avec votre jet
     Et c'est toujours à vous
-    Quand vous continuez
+    Quand vous laissez passer votre tour
     Alors c'est ensuite au tour de l'ordinateur
 
-  Scénario: Voir le coup de l'ordinateur
+  Scénario: Qu'a joué l'ordinateur ?
     Après chaque coup de l'ordinateur, ses pions glissent un par un sur le
     plateau. Restent ensuite, jusqu'à votre prochaine action, une flèche par
     pion déplacé, ses pions arrivés entourés et un pion fantôme là où ils
-    étaient. Le bouton « Revoir » rejoue son coup.
+    étaient. « Revoir » (la flèche circulaire) rejoue son coup.
 
     Étant donné qu'un de vos pions est seul à portée de l'ordinateur
     Quand l'ordinateur a joué
@@ -83,7 +97,21 @@ 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
+  Scénario: À quoi sert le compte de points ?
+    Le compte de points dit combien de cases vos pions doivent encore
+    parcourir avant de sortir : le plus petit mène la course. Au-dessus et
+    au-dessous du plateau, le bandeau de chaque camp donne son compte, et
+    « mène de 7 » s'affiche du côté de celui qui mène. Touchez un compte pour
+    lire ce qu'il veut dire. En paysage, les comptes sont aux deux bouts de
+    la barre.
+
+    Quand vous commencez une nouvelle partie
+    Alors chaque camp a un compte de points de 167
+    Et personne ne mène la course
+    Quand vous jouez 13/8 13/11
+    Alors vous menez la course de 7
+
+  Scénario: Comment doubler ?
     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.
@@ -96,19 +124,29 @@ Fonctionnalité: Jouer une partie contre l'ordinateur
     Et que vous confirmez
     Alors l'ordinateur prend ou passe, comme le recommande le moteur
 
-  Scénario: Prendre le double de l'ordinateur
+  Scénario: L'ordinateur double : que se passe-t-il si je prends ?
+    Si vous prenez, la partie continue et vaut deux fois plus. Le videau
+    passe de votre côté : vous seul pourrez redoubler.
+
     Étant donné que l'ordinateur vous propose de doubler
     Quand vous prenez
     Alors la partie continue à valeur doublée
     Et le videau est de votre côté : vous seul pourrez redoubler
 
-  Scénario: Passer le double de l'ordinateur
+  Scénario: L'ordinateur double : que se passe-t-il si je passe ?
+    Passer, c'est abandonner la partie tout de suite : vous la perdez à sa
+    valeur d'avant le double.
+
     Étant donné que l'ordinateur vous propose de doubler
     Quand vous passez
     Alors la partie s'arrête
     Et vous perdez la partie à sa valeur d'avant le double
 
-  Scénario: Finir la partie
+  Scénario: Comment se termine une partie ?
+    La partie s'arrête dès qu'un joueur a sorti tous ses pions. Le panneau de
+    fin dit qui gagne, et combien de points : la valeur du videau, doublée
+    pour un gammon et triplée pour un backgammon, une fois le videau doublé.
+
     Étant donné qu'un joueur a sorti tous ses pions
     Alors la partie s'arrête
     Et le résultat indique le gagnant et les points gagnés

docs/scenarios/mes-parties.feature

@@ -0,0 +1,44 @@
+# language: fr
+Fonctionnalité: Retrouver mes parties
+
+  Toutes vos parties restent sur votre téléphone, finies ou en cours, avec
+  leurs branches : chacune est enregistrée après chacune de vos actions, et
+  fermer l'application ne perd rien. Dans « Mes parties », vous en reprenez
+  une, vous passez d'une branche à l'autre, ou vous l'exportez au format SGF
+  pour l'ouvrir dans GNU Backgammon.
+
+  Scénario: Comment reprendre une autre partie ?
+    Toutes vos parties restent sur le téléphone. Dans « Mes parties », depuis
+    le menu, la dernière jouée vient en premier : « Reprendre » vous ramène à
+    une partie telle que vous l'aviez laissée.
+
+    Étant donné que vous avez joué deux parties, l'une après l'autre
+    Quand vous fermez l'application puis la rouvrez
+    Alors la dernière partie jouée est à l'écran
+    Et « Mes parties » montre vos deux parties, la dernière jouée en premier
+    Quand vous reprenez la première partie
+    Alors elle est à l'écran, telle que vous l'aviez laissée
+
+  Scénario: Puis-je rejouer un moment de la partie autrement ?
+    Revenez à un moment passé de la partie et jouez autre chose : une
+    nouvelle branche commence là, et la partie d'origine reste entière.
+
+    Étant donné que vous avez joué plusieurs coups
+    Quand vous rejouez d'ici à partir de votre deuxième coup
+    Et que vous choisissez un autre coup
+    Alors la partie a deux branches
+    Et la partie d'origine est intacte
+    Quand vous fermez l'application puis la rouvrez
+    Alors vous êtes sur la nouvelle branche
+    Et vous pouvez revenir à la partie d'origine, au coup près
+
+  Scénario: Comment garder une partie dans un fichier ?
+    Dans « Mes parties », « Exporter (SGF) » enregistre la partie dans un
+    fichier que GNU Backgammon sait ouvrir ; les suites rejouées y sont des
+    variantes.
+
+    Étant donné que vous avez joué plusieurs coups
+    Et que vous avez rejoué d'ici une autre suite
+    Quand vous exportez la partie
+    Alors vous obtenez un fichier SGF de GNU Backgammon
+    Et il contient vos coups, et l'autre branche en variante

docs/scenarios/partager-une-position.feature

@@ -0,0 +1,43 @@
+# language: fr
+Fonctionnalité: Partager une position
+
+  Chaque position du plateau a son lien : une adresse qui la rouvre telle
+  quelle, à envoyer à un ami, à garder pour plus tard ou à coller dans une
+  question. Le lien contient les deux identifiants de GNU Backgammon, celui
+  de la position et celui du match, et rien d'autre.
+
+  Scénario: Comment partager une position ?
+    Pendant la partie, « Copier le lien de la position », dans le menu ou à
+    côté du dernier coup de l'ordinateur, copie l'adresse de la position à
+    l'écran. Ouvert ailleurs, le lien montre la même position.
+
+    Étant donné que votre partie en cours compte quelques coups
+    Quand vous copiez le lien de la position
+    Alors le lien contient l'identifiant de la position et celui du match
+    Quand vous ouvrez ce lien
+    Alors vous voyez exactement la même position, avec le même videau
+
+  Scénario: On m'a envoyé le lien d'une position
+    Un lien vers une position montre le plateau, sans le rendre jouable :
+    vous y êtes en bas, avec la main. « Jouer à partir d'ici » commence une
+    nouvelle partie contre l'ordinateur depuis cette position, et votre
+    partie en cours reste dans « Mes parties ». « Retour à ma partie » vous
+    ramène à votre partie, intacte.
+
+    Étant donné que votre partie en cours compte quelques coups
+    Quand vous ouvrez un lien vers une position où le videau est à 2, chez l'ordinateur
+    Alors vous voyez cette position, avec la main
+    Et votre partie n'a pas changé
+    Quand vous choisissez « Jouer à partir d'ici »
+    Alors une nouvelle partie commence à cette position, à vous de lancer les dés
+    Et le videau est à 2, chez l'ordinateur
+    Et votre partie précédente est toujours enregistrée
+
+  Scénario: Le lien d'une position ne s'ouvre pas
+    Un lien coupé ou mal recopié ne casse rien : un message le dit, et
+    « Retour à ma partie » reste là.
+
+    Quand vous ouvrez un lien dont l'identifiant de position est abîmé
+    Alors le lien est déclaré illisible
+    Quand vous ouvrez un lien dont l'identifiant de match est abîmé
+    Alors le lien est déclaré illisible

docs/scenarios/regler-l-application.feature

@@ -0,0 +1,67 @@
+# language: fr
+Fonctionnalité: Régler l'application
+
+  Le menu, qui monte du bas de l'écran, regroupe ce qui ne sert pas à chaque
+  coup : commencer une nouvelle partie, passer en plein écran, ouvrir l'aide
+  et le glossaire, choisir le thème, couper les vibrations, et laisser ou non
+  l'écran allumé pendant la partie. Rien de ce qu'il contient ne vous pose de
+  question : ce qui se fait se rattrape.
+
+  Scénario: J'ai commencé une nouvelle partie par erreur
+    Une nouvelle partie commence tout de suite, sans question. Pendant 10
+    secondes, le bandeau « Reprendre l'ancienne » vous rend la partie que
+    vous venez de quitter, exactement là où vous l'aviez laissée.
+
+    Étant donné qu'une partie est en cours depuis quelques coups
+    Quand vous commencez une nouvelle partie depuis le menu
+    Alors une nouvelle partie commence aussitôt
+    Et l'ancienne partie peut être reprise pendant 10 secondes
+    Quand vous reprenez l'ancienne partie
+    Alors vous retrouvez exactement la partie quittée
+
+  Scénario: Comment couper les vibrations ?
+    Le téléphone vibre brièvement quand votre pion se pose, quand un pion est
+    frappé, quand l'ordinateur vous propose de doubler et à la fin de la
+    partie. Ces vibrations accompagnent toujours ce que montre l'écran ; rien
+    ne vibre quand vous lancez les dés. Elles se coupent dans le menu.
+
+    Étant donné que vous ouvrez l'application pour la première fois
+    Quand un pion est frappé
+    Alors le téléphone vibre deux fois, brièvement
+    Quand vous coupez les vibrations dans le menu
+    Et qu'un pion est frappé
+    Alors le téléphone ne vibre pas
+
+  Scénario: Pourquoi l'écran ne se met-il pas en veille ?
+    Pour que le téléphone ne se mette pas en veille pendant que vous
+    réfléchissez, l'écran reste allumé tant qu'une partie est en cours.
+
+    Étant donné que vous ouvrez l'application pour la première fois
+    Alors l'écran reste allumé pendant une partie
+    Quand vous coupez « Écran allumé pendant la partie » dans le menu
+    Alors l'écran peut se mettre en veille comme d'habitude
+
+  Scénario: Comment passer en thème sombre ?
+    Le thème suit d'abord celui du téléphone. Dans le menu, « Thème » passe à
+    clair, puis à sombre, puis revient à automatique.
+
+    Étant donné que vous ouvrez l'application pour la première fois
+    Alors le thème suit celui du téléphone
+    Quand vous changez de thème dans le menu
+    Alors il passe à clair, puis à sombre, puis revient à automatique
+
+  Scénario: Comment mettre l'application à jour ?
+    Dès qu'une nouvelle version d'Ustagammon est publiée, l'application la
+    télécharge d'elle-même, puis affiche en bas de l'écran « Nouvelle
+    version prête. », seulement entre deux tours, jamais pendant que vous
+    jouez un coup. « Mettre à jour » l'installe et vous ramène où vous en
+    étiez. Dans le menu, « Rechercher une mise à
+    jour » vérifie tout de suite s'il y en a une.
+
+    Étant donné qu'une nouvelle version d'Ustagammon est disponible
+    Et que vous avez des dés à jouer
+    Alors l'application ne vous propose pas encore de mettre à jour
+    Quand vous déplacez un pion de votre coup
+    Alors l'application ne vous propose pas encore de mettre à jour
+    Quand vous avez joué votre coup
+    Alors l'application vous propose de mettre à jour

docs/tutoriel/README.md

@@ -0,0 +1,65 @@
+# Tutoriel des règles
+
+Le texte du tutoriel de l'application, en une seule source (ADR 0008) :
+`regles.md`. `make site` copie ce dossier dans le site publié
+(`docs/tutoriel/`) ; l'application le lit à l'exécution
+(`app/src/ui/tutorial-text.ts`), et `make test` vérifie chaque position et
+chaque coup avec le vrai moteur (`app/tests/tutorial.test.ts`).
+
+Texte sous licence **CC BY-SA 4.0**. Première version, rédigée par Claude
+Code d'après la charte (`docs/identite/charte/accueil-tutoriel-aide.md`),
+**à valider par Pierre**.
+
+## Format
+
+Tout ce qui précède la première étape (ce titre, cette notice) n'est pas
+affiché.
+
+```markdown
+## 3. Les dés et les doubles
+
+- position: 4HPwATDgc/ABMA
+- jet: 5-2
+- coup: 13/11 13/8
+
+Un paragraphe, avec un [mot du glossaire](pion.md) et du **gras**.
+
+### À vous
+
+- position: 4HPwATDgc/ABMA
+- jet: 3-1
+- attendu: 8/5 6/5
+- juste: La phrase affichée quand le coup est juste.
+- refus: La phrase affichée quand le coup est refusé.
+
+La consigne de l'écran.
+
+## Fin
+
+- action: Jouer ma première partie
+
+Le texte de la fin du tutoriel.
+```
+
+- `## <n>. <titre>` commence l'étape *n* (huit au plus, dans l'ordre) ;
+  `### À vous` commence son écran « à vous », facultatif ; `## Fin`, l'écran
+  qui suit la dernière étape.
+- Les lignes `- clé: valeur` en tête d'écran le décrivent :
+  - `position` : l'identifiant de position de GNU Backgammon (ADR 0013), vu
+    du camp au trait ;
+  - `trait` : `ordinateur` si c'est l'ordinateur qui a la main dans cette
+    position (par défaut, vous) ;
+  - `jet` et `coup` : sur un écran d'explication, le coup illustré, qui se
+    joue tout seul (notation de gnubg) ;
+  - `chemin: oui` : le sens du jeu, dessiné en pointillés sur le plateau ;
+  - `attendu` (une ligne par coup accepté) : sur un écran « à vous », les
+    coups justes, en notation de gnubg, tels que le moteur les écrit ;
+  - `réponse` : `prendre` ou `passer`, pour un écran « à vous » où
+    l'ordinateur double ; le moteur doit donner la même réponse ;
+  - `juste` et `refus` : les phrases qui suivent un geste juste, ou refusé ;
+  - `action` : le libellé du bouton de la fin.
+- Les autres lignes forment les paragraphes. `[mot](fiche.md)` renvoie à une
+  fiche du glossaire, à la première apparition du mot.
+
+Aucune règle n'est écrite dans le code : le moteur lit les positions,
+illustre les coups, juge les coups joués et les décisions de videau.

docs/tutoriel/regles.md

@@ -0,0 +1,128 @@
+# Les règles du backgammon
+
+Tutoriel d'Ustagammon, en huit étapes. Texte sous licence CC BY-SA 4.0,
+validé par Pierre le 9 novembre 2026. Format : voir README.md.
+
+## 1. Le but du jeu
+
+- position: 4HPwATDgc/ABMA
+
+Vous avez quinze [pions](pion.md) ivoire, l'ordinateur quinze pions noyer. Chacun fait faire le tour du [plateau](plateau.md) à ses pions, puis les [sort](sortie.md).
+
+Le premier qui a sorti tous les siens gagne la [partie](partie.md).
+
+## 2. Dans quel sens avancer
+
+- position: 4HPwATDgc/ABMA
+- chemin: oui
+
+Vos pions ivoire font le tour du plateau dans le sens des pointillés : ils partent d'en haut à droite, passent à gauche, puis reviennent en bas jusqu'aux **six dernières flèches**, en bas à droite. C'est là que vous les rassemblerez avant de les sortir.
+
+Les pions noyer de l'ordinateur font le même chemin, en sens inverse.
+
+## 3. Les dés et les doubles
+
+- position: 4HPwATDgc/ABMA
+- jet: 5-2
+- coup: 13/11 13/8
+
+Chaque dé déplace un pion d'autant de flèches. Avec 5 et 2, vous jouez un pion de 5 et un pion de 2, ou le même pion de 5 puis de 2.
+
+Un double se joue quatre fois : avec 4-4, vous avancez quatre fois de 4.
+
+### À vous
+
+- position: 4HPwATDgc/ABMA
+- jet: 3-1
+- attendu: 8/5 6/5
+- juste: Deux pions sur la flèche 5 : elle est à vous, l'ordinateur ne peut plus s'y poser.
+- refus: Ce coup est permis, mais il ne réunit pas deux pions sur la flèche 5. Jouez un pion de la flèche 8 avec le 3, et un de la flèche 6 avec le 1.
+
+Vous avez 3 et 1. Réunissez deux pions sur la flèche 5 : touchez un pion, puis sa case d'arrivée.
+
+## 4. Frapper un pion seul
+
+- position: 4HPwESDgc/ABMA
+- jet: 4-2
+- coup: 13/11 13/9*
+
+Un pion seul sur une flèche s'appelle un [blot](blot.md). Si vous vous posez dessus, vous le frappez : il part sur la [barre](barre.md) et devra refaire tout le chemin.
+
+Une flèche où l'adversaire a deux pions ou plus est fermée : vous ne pouvez pas vous y poser.
+
+### À vous
+
+- position: 4HPwIDDgc/ABMA
+- jet: 6-1
+- attendu: 13/7* 8/7
+- attendu: 13/7*/6
+- attendu: 13/7* 6/5
+- attendu: 24/23 13/7*
+- attendu: 24/18 8/7*
+- attendu: 8/7* 8/2
+- juste: Touché : le pion noyer part sur la barre, il devra refaire tout le chemin.
+- refus: Ce coup ne frappe pas le pion seul de la flèche 7. Un pion qui s'y pose le frappe : celui de la flèche 13 avec le 6, ou celui de la flèche 8 avec le 1.
+
+Vous avez 6 et 1. Le pion noyer de la flèche 7 est seul : frappez-le.
+
+## 5. Rentrer depuis la barre
+
+- position: 4HPwATDgc/ABUA
+- jet: 4-3
+- coup: bar/22 13/9
+
+Votre pion frappé attend sur la barre, au milieu. Avant de jouer quoi que ce soit d'autre, il doit rentrer dans le [camp](camp.md) adverse, en haut à droite.
+
+Chaque dé indique une flèche d'entrée : avec 3 et 4, la 22 ou la 21. Si les deux flèches sont fermées, votre tour passe.
+
+## 6. Sortir ses pions
+
+- position: bHcAANh2dwAAAA
+- jet: 5-2
+- coup: 5/off 2/off
+
+Quand vos quinze pions sont dans les six dernières flèches, vous pouvez commencer à les sortir : un 6 sort un pion de la flèche 6, un 1 un pion de la flèche 1.
+
+Touchez le pion, puis la sortie à droite.
+
+### À vous
+
+- position: bHcAANh2dwAAAA
+- jet: 6-3
+- attendu: 6/off 3/off
+- juste: Deux pions sortis. Plus que treize !
+- refus: Ce coup est permis, mais il ne sort qu'un pion. Le 6 sort un pion de la flèche 6, le 3 un pion de la flèche 3.
+
+Vous avez 6 et 3 : sortez deux pions.
+
+## 7. Gammon et backgammon
+
+- position: 8J4HBwAFAAAAAA
+- jet: 2-1
+- coup: 2/off 1/off
+
+Une partie gagnée vaut 1 point. Si l'adversaire n'a sorti aucun pion, c'est un [gammon](gammon.md) : 2 points ; s'il lui reste en plus un pion sur la barre ou dans votre camp, c'est un [backgammon](backgammon.md) : 3 points. En partie libre, gammon et backgammon ne comptent que si le videau a été doublé : c'est la [règle de Jacoby](regle-de-jacoby.md).
+
+## 8. Le videau
+
+- position: 4HPwATDgc/ABMA
+
+Le cube aux faces 2, 4, 8, 16, 32 et 64 s'appelle le [videau](videau.md) : il sert à miser. Avant de lancer vos dés, vous pouvez proposer de [doubler](doubler.md) la valeur de la partie.
+
+L'ordinateur [prend](prendre.md), et la partie continue en valant le double, ou il [passe](passer.md), et vous gagnez tout de suite. Celui qui a pris garde le cube : lui seul pourra redoubler.
+
+### À vous
+
+- position: 7O7YAADs7jYAAA
+- trait: ordinateur
+- réponse: prendre
+- juste: Le maître prend aussi. L'ordinateur mène la course, mais vous gagnez encore assez souvent pour que prendre vous coûte moins cher, en moyenne, que passer.
+- refus: Le maître prendrait. Passer vous coûte un point tout de suite ; en prenant, vous gardez vos chances de gagner, et le videau est chez vous.
+
+C'est à l'ordinateur de jouer, et il mène la course. Il vous propose de doubler : prenez-vous, ou passez-vous ?
+
+## Fin
+
+- action: Jouer ma première partie
+
+Vous connaissez les règles. Le reste s'apprend en jouant, et le maître vous accompagne.

tests/browser.sh

@@ -2,7 +2,11 @@
 # Joue une partie complète par l'interface dans Chromium et Firefox sans
 # écran (tests/browser/play.mjs), sur le site servi par l'image de production
 # construite en local, comme tests/test_site.sh. Les captures d'écran vont
-# dans build/browser-shots/.
+# dans build/browser-shots/. Puis l'accueil, le tutoriel, l'aide,
+# l'installation et la mise à jour (tests/browser/accueil.mjs), avec leurs
+# captures dans build/browser-shots/accueil-tutoriel/.
+#
+# BROWSERS=chromium et SCRIPTS=accueil (ou play) restreignent le test.
 #
 # Outils : l'image de Playwright (navigateurs) et le paquet playwright,
 # installé une fois par npm dans build/browser-tools/ (réseau nécessaire la
@@ -14,15 +18,16 @@ cd "$(dirname "$0")/.."
 
 image="${PLAYWRIGHT_IMAGE:?lancer via make test-browser}"
 browsers="${BROWSERS:-chromium firefox}"
+# Les scripts à lancer (tests/browser/<nom>.mjs), tous par défaut.
+scripts="${SCRIPTS:-play accueil}"
 
 unset MAKEFLAGS MFLAGS MAKELEVEL
 make -s package >/dev/null
 
-site_image="ustagammon/site-test:local"
-docker build -q -t "$site_image" build/deploy >/dev/null
-container="$(docker run -d --rm -p 127.0.0.1::80 "$site_image")"
-trap 'docker stop "$container" >/dev/null' EXIT
-port="$(docker port "$container" 80/tcp | head -n1 | sed 's/.*://')"
+# Image de production lancée, étiquette propre à ce dépôt : site_image,
+# container, port.
+# shellcheck source=tests/site-image.sh
+. tests/site-image.sh
 
 # Le paquet playwright, à la version des navigateurs de l'image.
 tools=build/browser-tools
@@ -34,15 +39,40 @@ if [ ! -f "$tools/node_modules/playwright/package.json" ]; then
 		"$image" npm install --no-audit --no-fund --save-exact "playwright@$version" >/dev/null
 fi
 
+# Pour la mise à jour de l'application (tests/browser/accueil.mjs) : une
+# copie du site, servie par la même image mais depuis un dossier que le test
+# modifie, pour publier une deuxième version sur la même adresse.
+updates=build/browser-site
+rm -rf "$updates"
+cp -r build/site "$updates"
+update_container="$(docker run -d --rm -p 127.0.0.1::80 -v "$PWD/$updates:/srv:ro" "$site_image")"
+# shellcheck disable=SC2317 # appelée par trap, à la sortie
+update_cleanup() {
+	docker rm -f "$update_container" >/dev/null 2>&1 || true
+	site_cleanup
+}
+trap update_cleanup EXIT
+update_port="$(docker port "$update_container" 80/tcp | head -n1 | sed 's/.*://')"
+
 rm -rf build/browser-shots
 mkdir -p build/browser-shots
-cp tests/browser/play.mjs "$tools/"
+cp tests/browser/play.mjs tests/browser/accueil.mjs "$tools/"
 status=0
 for browser in $browsers; do
 	# Réseau de l'hôte : le site est sur 127.0.0.1. Le service worker
 	# demande un contexte sûr, ce qu'est localhost.
+	if [[ " $scripts " == *" play "* ]]; then
+		docker run --rm --init --ipc=host --network host --user "$(id -u):$(id -g)" -e HOME=/tmp \
+			-e TRACE -v "$PWD/$tools:/tools" -v "$PWD/build/browser-shots:/shots" -w /tools "$image" \
+			node play.mjs "http://localhost:$port/" "$browser" /shots || status=1
+	fi
+	[[ " $scripts " == *" accueil "* ]] || continue
+	# Accueil, tutoriel, aide, installation et mise à jour ; captures de la
+	# recette dans build/browser-shots/accueil-tutoriel/.
 	docker run --rm --init --ipc=host --network host --user "$(id -u):$(id -g)" -e HOME=/tmp \
-		-e TRACE -v "$PWD/$tools:/tools" -v "$PWD/build/browser-shots:/shots" -w /tools "$image" \
-		node play.mjs "http://localhost:$port/" "$browser" /shots || status=1
+		-v "$PWD/$tools:/tools" -v "$PWD/build/browser-shots:/shots" -v "$PWD/$updates:/site" \
+		-w /tools "$image" \
+		node accueil.mjs "http://localhost:$port/" "$browser" /shots \
+		"http://localhost:$update_port/" /site || status=1
 done
 exit "$status"

tests/browser/accueil.mjs

@@ -0,0 +1,548 @@
+// accueil.mjs -- l'accueil, le tutoriel des règles, l'aide, l'installation
+// et la mise à jour de l'application, dans un vrai navigateur sans écran
+// (Playwright), sur le site servi par l'image de production
+// (docs/plans/2026-11-03-accueil-tutoriel-aide.md, point 7).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Usage : node accueil.mjs <adresse du site> <chromium|firefox> <dossier des
+// captures> <adresse du site modifiable> <dossier de ce site>
+// Lancé par tests/browser.sh. Le second site sert la même chose depuis un
+// dossier que ce script modifie : il y publie une deuxième version pour
+// essayer la mise à jour. Captures de la recette design (Chromium) dans
+// <dossier des captures>/accueil-tutoriel/, en 412×915 et 915×412, et aussi
+// en 844×320 pour le tutoriel.
+
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { chromium, firefox } from "playwright";
+
+const [base, browserName, shots, updateBase, updateDir] = process.argv.slice(2);
+const browserType = { chromium, firefox }[browserName];
+if (!base || !browserType || !shots || !updateBase || !updateDir) {
+    console.error("usage : node accueil.mjs <adresse> <chromium|firefox> <captures> <adresse 2> <dossier 2>");
+    process.exit(2);
+}
+const full = browserName === "chromium";
+const dir = `${shots}/accueil-tutoriel`;
+mkdirSync(dir, { recursive: true });
+const SIZES = [
+    [412, 915],
+    [915, 412],
+];
+// Le tutoriel est aussi vérifié dans le plus petit paysage de la recette.
+const TUTORIAL_SIZES = [...SIZES, [844, 320]];
+
+const browser = await browserType.launch();
+const problems = [];
+const log = (text) => console.log(`[${browserName}] ${text}`);
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+let captures = 0;
+
+function check(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}
+
+/** Un contexte neuf (stockage vide), avec des réglages déjà enregistrés si
+ * settings est donné. Erreurs de la page et violations de la CSP relevées. */
+async function newPage(settings = null, url = base) {
+    const context = await browser.newContext({
+        viewport: { width: 412, height: 915 },
+        deviceScaleFactor: 1,
+        locale: "fr-FR",
+    });
+    await context.addInitScript((saved) => {
+        window.__csp = [];
+        document.addEventListener("securitypolicyviolation", (e) =>
+            window.__csp.push(`${e.effectiveDirective} ${e.blockedURI}`),
+        );
+        // Un élément est-il à l'écran ? (Utilisé par les attentes.)
+        window.__shown = (id) => {
+            const el = document.getElementById(id);
+            return el !== null && !el.closest("[hidden]") && el.getClientRects().length > 0;
+        };
+        window.__vibrations = [];
+        Object.defineProperty(Navigator.prototype, "vibrate", {
+            configurable: true,
+            value: (pattern) => {
+                window.__vibrations.push(String(pattern));
+                return true;
+            },
+        });
+        if (saved !== null && localStorage.getItem("ustagammon.settings") === null) {
+            localStorage.setItem("ustagammon.settings", saved);
+        }
+    }, settings === null ? null : JSON.stringify(settings));
+    const page = await context.newPage();
+    page.on("pageerror", (error) => problems.push(`erreur de la page : ${error.message}`));
+    page.on("console", (message) => {
+        if (message.type() === "error") {
+            problems.push(`console : ${message.text()}`);
+        }
+    });
+    page.on("dialog", (dialog) => {
+        problems.push(`boîte native : ${dialog.type()}`);
+        void dialog.dismiss();
+    });
+    await page.goto(url);
+    return { context, page };
+}
+
+/** Attend que test (évalué dans la page) soit vrai, au plus ms. (Pas de
+ * waitForFunction : Playwright y passe par eval, que la CSP interdit.) */
+async function until(page, what, test, arg, ms = 30_000) {
+    let last = null;
+    for (const end = Date.now() + ms; Date.now() < end; ) {
+        last = await page.evaluate(test, arg).catch((error) => `page illisible : ${error.message}`);
+        if (last === true) {
+            return;
+        }
+        await sleep(100);
+    }
+    await page.screenshot({ path: `${shots}/${browserName}-accueil-echec.png` }).catch(() => {});
+    throw new Error(`${what} : attente dépassée (${JSON.stringify(last)})`);
+}
+
+/** Range une capture de l'écran courant dans chaque taille (Chromium). */
+async function capture(page, name, settle = async () => {}, sizes = SIZES) {
+    if (!full) {
+        return;
+    }
+    for (const [width, height] of sizes) {
+        await page.setViewportSize({ width, height });
+        await sleep(250);
+        await settle();
+        await page.screenshot({ path: `${dir}/${name}-${width}x${height}.png`, fullPage: true });
+        captures++;
+    }
+    await page.setViewportSize({ width: 412, height: 915 });
+    await sleep(150);
+}
+
+/** Vérifie la CSP et ferme le contexte. */
+async function close(context, page) {
+    const csp = await page.evaluate(() => window.__csp).catch(() => []);
+    check(csp.length === 0, `violations de la CSP : ${csp.join(", ")}`);
+    await context.close();
+}
+
+// ------------------------------------------------- Premier lancement
+
+/** L'écran du tutoriel prêt : plateau dessiné pour cette adresse, coup
+ * illustré joué (« Revoir » utilisable) s'il y en a un. */
+async function tutorialReady(page, hash) {
+    await until(page, `tutoriel ${hash}`, (hash) => {
+        const section = document.getElementById("tutorial");
+        const replay = document.getElementById("tutorial-replay");
+        return location.hash === hash && section.dataset.ready !== undefined &&
+            document.querySelectorAll("#tutorial-board polygon[data-point]").length === 24 &&
+            (replay.hidden || !replay.disabled);
+    }, hash);
+}
+
+/** Recette du tutoriel dans la taille courante : numéros des flèches de
+ * 12 px au moins ; en paysage, rien ne défile et les boutons sont en vue. */
+async function checkTutorialView(page, name) {
+    const view = await page.evaluate(() => {
+        const svg = document.getElementById("tutorial-board");
+        const box = svg.getBoundingClientRect();
+        const vb = svg.viewBox.baseVal;
+        const scale = Math.min(box.width / vb.width, box.height / vb.height);
+        const numbers = [...svg.querySelectorAll(".point-number")]
+            .map((t) => Number(t.getAttribute("font-size")) * scale);
+        const buttons = ["tutorial-back", "tutorial-next", "tutorial-drop", "tutorial-take"]
+            .map((id) => document.getElementById(id))
+            .filter((el) => el !== null && el.closest("[hidden]") === null)
+            .map((el) => {
+                const r = el.getBoundingClientRect();
+                return { id: el.id, top: r.top, bottom: r.bottom };
+            });
+        return {
+            landscape: document.documentElement.classList.contains("landscape"),
+            minNumber: numbers.length === 0 ? 0 : Math.min(...numbers),
+            scroll: document.scrollingElement.scrollHeight - innerHeight,
+            body: (() => {
+                const b = document.querySelector("#tutorial .tutorial-body");
+                return b.scrollHeight - b.clientHeight;
+            })(),
+            height: innerHeight,
+            buttons,
+        };
+    });
+    const size = `${name} en ${await page.evaluate(() => `${innerWidth}x${innerHeight}`)}`;
+    check(view.minNumber >= 12, `${size} : numéros des flèches de ${view.minNumber.toFixed(1)} px`);
+    if (view.landscape) {
+        check(view.scroll <= 1, `${size} : la page défile de ${view.scroll} px`);
+        check(view.body <= 1, `${size} : le texte défile de ${view.body} px`);
+        if (view.body > tutorialBodyScroll.px) {
+            tutorialBodyScroll = { px: view.body, where: size };
+        }
+        for (const b of view.buttons) {
+            check(b.top >= 0 && b.bottom <= view.height + 0.5,
+                `${size} : « ${b.id} » hors de l'écran (${b.top}-${b.bottom} pour ${view.height})`);
+        }
+    }
+    tutorialViews++;
+    tutorialMinNumber = Math.min(tutorialMinNumber, view.minNumber);
+}
+let tutorialViews = 0;
+let tutorialBodyScroll = { px: 0, where: "" };
+let tutorialMinNumber = Infinity;
+
+/** Capture d'un écran du tutoriel, recette comprise, dans les trois tailles. */
+async function tutorialCapture(page, name) {
+    await capture(page, name, () => checkTutorialView(page, name), TUTORIAL_SIZES);
+}
+
+/** Touche une case du plateau du tutoriel. */
+async function touch(page, place) {
+    await page.click(`#tutorial-board [data-place="${place}"]`);
+    await sleep(200);
+}
+
+async function verdict(page) {
+    await until(page, "verdict", () => {
+        const v = document.getElementById("tutorial-feedback").dataset.verdict;
+        return v === "right" || v === "wrong";
+    });
+    return page.evaluate(() => document.getElementById("tutorial-feedback").dataset.verdict);
+}
+
+/** Les gestes des écrans « à vous » : un coup refusé, puis le bon. */
+const PRACTICE = {
+    // 24/21 : ne peut plus mener à 8/5 6/5, refusé tout de suite.
+    3: { wrong: [["p24", "p21"]], right: [["p8", "p5"], ["p6"]] },
+    // 24/23 puis 24/18 : un coup complet qui ne frappe pas.
+    4: { wrong: [["p24", "p23"], ["p24"]], right: [["p13"], ["p8"]] },
+    // 6/3 : ne sort pas deux pions.
+    6: { wrong: [["p6", "p3"]], right: [["p6", "off-player"], ["p3"]] },
+};
+
+async function playTouches(page, touches) {
+    for (const group of touches) {
+        for (const place of group) {
+            await touch(page, place);
+        }
+        await until(page, "demi-coup joué", () => !document.querySelector("#tutorial[data-busy]"));
+        await sleep(150);
+    }
+}
+
+{
+    const { context, page } = await newPage();
+    await until(page, "premier lancement", () =>
+        location.hash === "#/accueil" && !document.getElementById("home-welcome").hidden);
+    const first = await page.evaluate(() => ({
+        topbar: getComputedStyle(document.querySelector(".topbar")).display,
+        links: [...document.querySelectorAll("#home-welcome a.choice")].map((a) => a.getAttribute("href")),
+        main: document.getElementById("home-main").hidden,
+    }));
+    check(first.topbar === "none" && first.main, `premier lancement : ${JSON.stringify(first)}`);
+    check(JSON.stringify(first.links) === '["#/tutoriel/1","#/"]', `choix : ${first.links}`);
+    await capture(page, "01-premier-lancement");
+    log("premier lancement : « Je découvre » et « Je connais les règles », de vrais liens");
+
+    // Le tutoriel complet, par ses liens « Continuer ».
+    await page.click("#welcome-discover");
+    let screens = 0;
+    for (let step = 1; step <= 8; step++) {
+        const hash = `#/tutoriel/${step}`;
+        await tutorialReady(page, hash);
+        // La barre ne mène qu'aux étapes déjà vues.
+        const links = await page.evaluate(() =>
+            [...document.querySelectorAll("#tutorial-progress a")].map((a) => a.getAttribute("href")));
+        const expected = Array.from({ length: step - 1 }, (_, i) => `#/tutoriel/${i + 1}`);
+        check(JSON.stringify(links) === JSON.stringify(expected),
+            `étape ${step} : barre de progression ${JSON.stringify(links)}`);
+        const illustrated = await page.evaluate(() => !document.getElementById("tutorial-replay").hidden);
+        if (illustrated) {
+            check(await page.locator("#tutorial-board .trace-arrow").count() > 0,
+                `étape ${step} : le coup illustré n'a pas laissé de traces`);
+            // « Revoir » rejoue le coup.
+            await page.click("#tutorial-replay");
+            await tutorialReady(page, hash);
+        }
+        if (step === 2) {
+            check(await page.locator("#tutorial-board .tutorial-path").count() === 1,
+                "étape 2 : pas de chemin en pointillés");
+            // Sous les pions et sous les numéros des flèches.
+            const order = await page.evaluate(() => {
+                const children = [...document.getElementById("tutorial-board").children];
+                const at = (selector) => children.findIndex((c) => c.matches(selector));
+                const numbers = children.filter((c) => c.matches(".point-number")).map((c) => children.indexOf(c));
+                return { path: at(".tutorial-path"), pieces: at("g.pieces"), firstNumber: Math.min(...numbers) };
+            });
+            check(order.path >= 0 && order.path < order.pieces && order.path < order.firstNumber,
+                `étape 2 : le chemin passe au-dessus des pions ou des numéros ${JSON.stringify(order)}`);
+        }
+        await tutorialCapture(page, `tutoriel-${step}`);
+        screens++;
+        await page.click("#tutorial-next");
+        const practice = await page.evaluate(() => location.hash.endsWith("/a-vous"));
+        if (!practice) {
+            continue;
+        }
+        const avous = `${hash}/a-vous`;
+        await tutorialReady(page, avous);
+        check(await page.evaluate(() => document.getElementById("tutorial-next").classList.contains("secondary")),
+            `étape ${step}, à vous : « Continuer » principal avant le geste`);
+        await tutorialCapture(page, `tutoriel-${step}-a-vous`);
+        if (step === 8) {
+            await page.click("#tutorial-drop");
+            check(await verdict(page) === "wrong", "étape 8 : « Passer » accepté");
+            await tutorialCapture(page, "tutoriel-8-a-vous-refuse");
+            await page.click("#tutorial-take");
+            await until(page, "étape 8 juste", () =>
+                document.getElementById("tutorial-feedback").dataset.verdict === "right");
+        } else {
+            const moves = PRACTICE[step];
+            await playTouches(page, moves.wrong);
+            check(await verdict(page) === "wrong", `étape ${step} : coup faux accepté`);
+            // Le pion revient : de nouveau des pions jouables.
+            await until(page, "pion revenu", () => document.querySelectorAll("#tutorial-board .hit.can-move").length > 0);
+            const words = await page.textContent("#tutorial-feedback");
+            check(!/erreur/i.test(words), `étape ${step} : « erreur » dans le refus`);
+            await tutorialCapture(page, `tutoriel-${step}-a-vous-refuse`);
+            await playTouches(page, moves.right);
+            check(await verdict(page) === "right", `étape ${step} : bon coup refusé`);
+            check(await page.locator("#tutorial-board .hit.can-move").count() === 0,
+                `étape ${step} : plateau encore jouable après le bon coup`);
+        }
+        check(!(await page.evaluate(() => document.getElementById("tutorial-next").classList.contains("secondary"))),
+            `étape ${step} : « Continuer » pas principal après le bon geste`);
+        const vibrated = await page.evaluate(() => window.__vibrations.at(-1));
+        check(vibrated === "12", `étape ${step} : vibration ${vibrated}`);
+        await tutorialCapture(page, `tutoriel-${step}-a-vous-reussi`);
+        screens++;
+        await page.click("#tutorial-next");
+    }
+    await until(page, "fin du tutoriel", () => location.hash === "#/tutoriel/fin" &&
+        document.getElementById("tutorial").dataset.ready !== undefined);
+    await tutorialCapture(page, "tutoriel-fin");
+    // Le retour du téléphone : l'écran d'avant.
+    await page.goBack();
+    await tutorialReady(page, "#/tutoriel/8/a-vous");
+    await page.goForward();
+    await until(page, "fin", () => location.hash === "#/tutoriel/fin");
+    await page.click("#tutorial-next");
+    await until(page, "première partie", () => location.hash === "#/" && window.__shown("game"));
+    log(`tutoriel : ${screens} écrans, gestes refusés puis justes sur les 4 écrans « à vous », fin` +
+        (full ? ` ; recette sur ${tutorialViews} vues, numéros de ${tutorialMinNumber.toFixed(1)} px au moins, ` +
+            `texte défilant au plus de ${tutorialBodyScroll.px} px${tutorialBodyScroll.px > 0 ? ` (${tutorialBodyScroll.where})` : ""}` : ""));
+
+    // Le choix ne revient plus : l'accueil, ensuite.
+    await page.goto(base);
+    await until(page, "accueil", () => location.hash === "#/accueil" &&
+        document.getElementById("home-welcome").hidden && !document.getElementById("home-main").hidden);
+    await close(context, page);
+}
+
+// --------------------------------------------------- Accueil, installation
+
+{
+    // Une partie terminée : l'invitation à installer apparaît.
+    const settings = { welcomed: true, gamesStarted: 2, gamesFinished: 1, tutorialSeen: 99 };
+    const { context, page } = await newPage(settings);
+    await until(page, "accueil prêt", () => location.hash === "#/accueil" &&
+        !document.getElementById("home-new").disabled && !document.getElementById("install-card").hidden);
+    const home = await page.evaluate(() => ({
+        resume: document.getElementById("home-resume").getAttribute("href"),
+        primaries: [...document.querySelectorAll("#home a.button:not(.secondary), #home button:not(.secondary):not(.icon-button)")]
+            .filter((el) => !el.closest("[hidden]")).length,
+        rules: document.getElementById("home-rules").getAttribute("href"),
+    }));
+    check(home.resume === "#/" && home.primaries === 1 && home.rules === "#/tutoriel/1",
+        `accueil : ${JSON.stringify(home)}`);
+    await capture(page, "02-accueil");
+    await capture(page, "03-carte-installation", async () => {
+        await page.locator("#install-card").scrollIntoViewIfNeeded();
+    });
+    // Sans invite du navigateur : la marche à suivre, une feuille avec son
+    // adresse, que le retour referme.
+    await page.click("#install-card-button");
+    await until(page, "feuille d'installation", () => location.hash === "#/installer" && window.__shown("install-sheet"));
+    check((await page.locator("#install-steps li").count()) === 3, "marche à suivre sans trois étapes");
+    await capture(page, "04-feuille-installation");
+    await page.goBack();
+    await until(page, "feuille refermée", () => location.hash === "#/accueil" && !window.__shown("install-sheet"));
+    if (browserName === "chromium") {
+        // L'invite de Chrome, simulée : « Installer » l'ouvre.
+        await page.evaluate(() => {
+            window.__prompted = 0;
+            const event = new Event("beforeinstallprompt", { cancelable: true });
+            event.prompt = () => {
+                window.__prompted++;
+                return Promise.resolve();
+            };
+            event.userChoice = Promise.resolve({ outcome: "dismissed" });
+            window.dispatchEvent(event);
+        });
+        await page.click("#install-card-button");
+        await until(page, "invite du navigateur", () => window.__prompted === 1);
+        check(await page.evaluate(() => location.hash) === "#/accueil", "l'invite a ouvert la feuille");
+        // Installée : plus aucune proposition.
+        await page.evaluate(() => window.dispatchEvent(new Event("appinstalled")));
+        await until(page, "installée", () => document.getElementById("install-card").hidden &&
+            document.getElementById("menu-install").hidden);
+        log("installation : invite de Chrome simulée, puis plus rien une fois installée");
+    } else {
+        await page.click("#install-later");
+        await until(page, "plus tard", () => document.getElementById("install-card").hidden);
+        log("installation : marche à suivre, « Plus tard »");
+    }
+    await close(context, page);
+}
+
+// ------------------------------------------------------------------- Aide
+
+{
+    const { context, page } = await newPage({ welcomed: true, gamesStarted: 2 }, `${base}#/aide`);
+    await until(page, "aide", () => window.__shown("help-play") && document.getElementById("help-content").dataset.loaded === "true");
+    const help = await page.evaluate(() => ({
+        steps: document.querySelectorAll("#help-play .steps, #help-play li").length,
+        questions: [...document.querySelectorAll("#help-play .question h3")].map((h) => h.textContent),
+        tutorial: document.getElementById("help-tutorial")?.getAttribute("href"),
+    }));
+    check(help.steps === 0, "aide : les étapes Gherkin sont affichées");
+    check(help.questions.length >= 25 && help.tutorial === "#/tutoriel/1", `aide : ${JSON.stringify(help)}`);
+    check(help.questions.filter((q) => q.endsWith("?")).length >= 20, "aide : trop peu de questions");
+    await capture(page, "05-aide-jouer");
+    const question = await page.evaluate(() =>
+        [...document.querySelectorAll("#help-play .question")].find((q) => q.querySelector(".see-board"))?.id);
+    await page.click(`#${question} h3 a`);
+    await until(page, "question ouverte", (id) => document.getElementById(id).classList.contains("open"), question);
+    await capture(page, "06-aide-question");
+    // Le retour du téléphone referme la question.
+    await page.goBack();
+    await until(page, "question refermée", () => location.hash === "#/aide" && !document.querySelector(".question.open"));
+    await page.click('#help-tabs a[data-screen="glossary"]');
+    await until(page, "glossaire", () => window.__shown("help-glossary"));
+    const before = await page.locator("#help-glossary .term-card:not([hidden])").count();
+    await page.fill("#glossary-search", "sortir");
+    await sleep(200);
+    const after = await page.locator("#help-glossary .term-card:not([hidden])").count();
+    check(after > 0 && after < before, `recherche : ${after} fiches sur ${before}`);
+    await capture(page, "07-aide-glossaire-recherche");
+    await page.click('#help-tabs a[data-screen="about"]');
+    await until(page, "à propos", () => window.__shown("help-about"));
+    const version = await page.textContent("#about-version");
+    check(/^Version publiée : [0-9a-f]{12}\.$/.test(version), `version : « ${version} »`);
+    await capture(page, "08-aide-a-propos");
+    log(`aide : ${help.questions.length} questions, recherche dans le glossaire (${after}/${before}), ${version}`);
+    await close(context, page);
+}
+
+// ----------------------------------------------------------- Mise à jour
+
+if (browserName === "chromium") {
+    const { context, page } = await newPage({ welcomed: true, gamesStarted: 2 }, `${updateBase}#/`);
+    await until(page, "partie prête", () => !document.body.classList.contains("busy"), undefined, 60_000);
+    // Le service worker installé et aux commandes (première installation :
+    // sans attendre l'accord du joueur).
+    await until(page, "service worker", async () => {
+        const reg = await navigator.serviceWorker.getRegistration();
+        return reg?.active?.state === "activated" && navigator.serviceWorker.controller !== null;
+    }, undefined, 120_000);
+    const journal = () => page.evaluate(() => localStorage.length >= 0 &&
+        new Promise((resolve) => {
+            const open = indexedDB.open("ustagammon");
+            open.onsuccess = () => {
+                const db = open.result;
+                const tx = db.transaction(["settings"]);
+                const current = tx.objectStore("settings").get("current");
+                current.onsuccess = () => {
+                    db.close();
+                    resolve(current.result?.value ?? null);
+                };
+            };
+            open.onerror = () => resolve(null);
+        }));
+    check(await page.isHidden("#update-banner"), "bandeau de mise à jour sans nouvelle version");
+    // Si vous avez la main (jet d'ouverture), le bandeau attend la fin du
+    // tour : on publie la nouvelle version d'abord, puis on joue le coup.
+    const toPlay = () => page.evaluate(() => {
+        if (document.body.classList.contains("busy")) {
+            return "busy";
+        }
+        const usable = (id) => {
+            const b = document.getElementById(id);
+            return b !== null && !b.hidden && !b.disabled;
+        };
+        for (const id of ["roll", "again", "confirm", "skip", "take"]) {
+            if (usable(id)) {
+                return id;
+            }
+        }
+        if (document.querySelector("#board .hit.can-land")) {
+            return "land";
+        }
+        return document.querySelector("#board .hit.can-move") ? "move" : "busy";
+    });
+    // Une deuxième version publiée : autre version.json, autre sw.js.
+    writeFileSync(`${updateDir}/version.json`, '{"commit": "0123456789abcdef0123", "dirty": false}\n');
+    const sw = readFileSync(`${updateDir}/sw.js`, "utf8");
+    writeFileSync(`${updateDir}/sw.js`, sw.replace(/^const VERSION = "[0-9a-f]+";$/m, 'const VERSION = "0000000000000002";'));
+    await page.click("#menu-button");
+    await page.waitForSelector("#menu", { state: "visible" });
+    await page.click("#menu-update");
+    await until(page, "nouvelle version trouvée", () =>
+        document.getElementById("update-text")?.textContent !== "Recherche d'une mise à jour…", undefined, 120_000);
+    // Pendant votre coup, jamais de bandeau : seulement entre deux tours.
+    let waited = false;
+    for (let i = 0; i < 40; i++) {
+        const todo = await toPlay();
+        if (todo === "roll" || todo === "again") {
+            break;
+        }
+        if (todo === "busy") {
+            await sleep(100);
+            continue;
+        }
+        if (todo === "move" || todo === "land" || todo === "confirm") {
+            await sleep(400);
+            check(await page.isHidden("#update-banner"), `bandeau de mise à jour pendant votre coup (${todo})`);
+            waited = true;
+        }
+        await page.click(todo === "move" ? "#board .hit.can-move" : todo === "land" ? "#board .hit.can-land" : `#${todo}`);
+        await sleep(200);
+    }
+    await until(page, "bandeau de mise à jour", () => window.__shown("update-banner") && window.__shown("update-apply"), undefined, 120_000);
+    check((await page.textContent("#update-text")) === "Nouvelle version prête.",
+        `bandeau : « ${await page.textContent("#update-text")} »`);
+    // En bas, au-dessus de la barre d'actions, comme « Reprendre l'ancienne ».
+    const place = await page.evaluate(() => {
+        const banner = document.getElementById("update-banner").getBoundingClientRect();
+        const actions = document.getElementById("actions").getBoundingClientRect();
+        const top = document.querySelector(".topbar").getBoundingClientRect();
+        return { bottom: banner.bottom, top: banner.top, actions: actions.top, bar: top.bottom };
+    });
+    check(place.bottom <= place.actions && place.top > place.bar,
+        `bandeau de mise à jour mal placé : ${JSON.stringify(place)}`);
+    const gameBefore = await journal();
+    await capture(page, "09-mise-a-jour");
+    await Promise.all([page.waitForEvent("load", { timeout: 60_000 }), page.click("#update-apply")]);
+    await until(page, "partie reprise", () => location.hash === "#/" && !document.body.classList.contains("busy"), undefined, 60_000);
+    check(await journal() === gameBefore, "après la mise à jour, ce n'est plus la même partie");
+    await page.goto(`${updateBase}#/a-propos`);
+    await until(page, "nouvelle version", () =>
+        document.getElementById("about-version")?.textContent === "Version publiée : 0123456789ab.");
+    log(`mise à jour : deuxième version publiée, bandeau ${waited ? "retenu pendant votre coup, puis " : ""}entre deux tours, « Mettre à jour », partie retrouvée, nouvelle version`);
+    // Rien de neuf : « Vous avez la dernière version ».
+    await page.goto(`${updateBase}#/`);
+    await until(page, "partie", () => !document.body.classList.contains("busy"), undefined, 60_000);
+    await page.click("#menu-button");
+    await page.waitForSelector("#menu", { state: "visible" });
+    await page.click("#menu-update");
+    await until(page, "dernière version", () =>
+        document.getElementById("update-text").textContent === "Vous avez la dernière version.", undefined, 60_000);
+    await close(context, page);
+}
+
+await browser.close();
+if (problems.length > 0) {
+    console.error(problems.join("\n"));
+    process.exit(1);
+}
+log(`aucune erreur dans la page${full ? ` ; ${captures} captures dans accueil-tutoriel/` : ""}`);

tests/sgf/check.py

@@ -0,0 +1,87 @@
+# Relit dans GNU Backgammon de référence les parties exportées en SGF par
+# Ustagammon (app/src/domain/game/sgf.ts) et vérifie qu'il y retrouve les
+# positions du journal.
+#
+# Ce script s'exécute DANS gnubg (scripting Python intégré), dans l'image
+# Docker ustagammon/gnubg-reference : voir tests/test_web.sh. Le dossier
+# SGF_DIR contient, pour chaque partie, <nom>.sgf et <nom>.json (écrits par
+# app/tests/tools/sgf-samples.ts) :
+#   after  : après chaque coup du journal, la position vue de celui qui a
+#            alors la main ;
+#   result : le résultat de la partie ({winner, points}) ou null.
+#
+# Pour chaque partie, gnubg charge le fichier (load game), puis avance
+# enregistrement par enregistrement (next) : après chaque coup, sa position
+# doit être celle du journal. Une position de départ mal posée, un coup mal
+# écrit ou refusé changent donc la suite des positions. Le résultat (RE)
+# doit aussi être celui du journal. Code de sortie : 0 si tout concorde.
+
+import glob
+import json
+import os
+import sys
+
+import gnubg
+
+FOLDER = os.environ.get("SGF_DIR", "/sgf")
+
+
+def check(path):
+    """Les écarts entre gnubg et le journal pour une partie (liste vide si
+    tout concorde)."""
+    with open(path[:-4] + ".json") as f:
+        expected = json.load(f)
+    gnubg.command("load game " + path)
+    games = gnubg.match(analysis=0, boards=0, statistics=0, verbose=0)["games"]
+    if len(games) != 1:
+        return ["gnubg n'a pas chargé la partie"]
+    game = games[0]
+    records = list(game["game"])
+
+    # Le premier « next » applique le premier enregistrement.
+    gnubg.command("first move")
+    after = []
+    for record in records:
+        gnubg.command("next")
+        if record["action"] == "move":
+            after.append(gnubg.positionid())
+
+    errors = []
+    if len(after) != len(expected["after"]):
+        errors.append("%d coups lus, %d attendus" % (len(after), len(expected["after"])))
+    for i, (got, want) in enumerate(zip(after, expected["after"])):
+        if got != want:
+            errors.append("après le coup %d : gnubg %s, journal %s" % (i + 1, got, want))
+            break
+
+    # Dans gnubg, X est le joueur 0 (W, l'ordinateur) et O le joueur 1 (B).
+    info = game["info"]
+    result = expected["result"]
+    if result is None:
+        if info.get("winner") is not None:
+            errors.append("gnubg voit une partie finie : %s" % info)
+    else:
+        winner = "O" if result["winner"] == "player" else "X"
+        if (info.get("winner"), info.get("points-won")) != (winner, result["points"]):
+            errors.append("résultat : gnubg %s, journal %s" % (info, result))
+    return errors
+
+
+failures = 0
+paths = sorted(glob.glob(os.path.join(FOLDER, "*.sgf")))
+for path in paths:
+    errors = check(path)
+    name = os.path.basename(path)
+    if errors:
+        failures += 1
+        print("ÉCHEC  %s : %s" % (name, " ; ".join(errors)))
+    else:
+        print("OK     %s" % name)
+
+if not paths:
+    print("aucun SGF dans %s" % FOLDER)
+    failures += 1
+sys.stdout.flush()
+# Un script --python de gnubg ne transmet pas son code de sortie : la
+# dernière ligne le donne au script shell.
+print("SGF-RESULTAT %s" % ("OK" if failures == 0 else "ECHEC"))

tests/site-image.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+# Construit l'image de production (build/deploy, voir make package) sous une
+# étiquette propre à ce dépôt, et la lance. À sourcer depuis la racine du
+# dépôt ; définit site_image, container et port, et arrête le conteneur puis
+# supprime l'image à la sortie du script.
+#
+# Plusieurs copies de travail (worktrees) peuvent lancer leurs tests en même
+# temps : avec une étiquette commune, docker échouait (« parent snapshot ...
+# does not exist »). Le suffixe est un hachage court du chemin du dépôt.
+
+site_image="ustagammon/site-test:$(pwd -P | sha1sum | cut -c1-12)"
+docker build -q -t "$site_image" build/deploy >/dev/null
+container="$(docker run -d --rm -p 127.0.0.1::80 "$site_image")"
+# docker rm -f, et non docker stop : avec --rm, stop rend la main avant que
+# le conteneur soit supprimé, et l'image serait encore utilisée.
+site_cleanup() {
+	docker rm -f "$container" >/dev/null 2>&1 || true
+	docker rmi "$site_image" >/dev/null 2>&1 || true
+}
+trap site_cleanup EXIT
+port="$(docker port "$container" 80/tcp | head -n1 | sed 's/.*://')"
+export site_image container port

tests/test_site.sh

@@ -11,11 +11,10 @@ cd "$(dirname "$0")/.."
 unset MAKEFLAGS MFLAGS MAKELEVEL
 make -s package >/dev/null
 
-image="ustagammon/site-test:local"
-docker build -q -t "$image" build/deploy >/dev/null
-container="$(docker run -d --rm -p 127.0.0.1::80 "$image")"
-trap 'docker stop "$container" >/dev/null' EXIT
-port="$(docker port "$container" 80/tcp | head -n1 | sed 's/.*://')"
+# Image de production lancée, étiquette propre à ce dépôt : site_image,
+# container, port.
+# shellcheck source=tests/site-image.sh
+. tests/site-image.sh
 base="http://127.0.0.1:$port"
 
 # Caddy démarre en une fraction de seconde : on attend qu'il réponde.
@@ -84,6 +83,15 @@ check "docs/glossaire/README.md" "text/markdown"
 check "docs/glossaire/videau.md" "text/markdown"
 cmp -s <(curl -s "$base/docs/glossaire/videau.md") docs/glossaire/videau.md \
 	|| report "/docs/glossaire/videau.md diffère de la source"
+# Tutoriel : copie de sa source unique (ADR 0008).
+check "docs/tutoriel/regles.md" "text/markdown"
+cmp -s <(curl -s "$base/docs/tutoriel/regles.md") docs/tutoriel/regles.md \
+	|| report "/docs/tutoriel/regles.md diffère de la source"
+for feature in apprendre-les-regles decouvrir-l-application installer-l-application; do
+	check "docs/scenarios/$feature.feature" "text/plain"
+done
+# Le service worker attend l'accord du joueur avant de prendre la main.
+grep -q 'skip-waiting' build/site/sw.js || report "sw.js : pas d'attente de l'accord du joueur"
 
 # Le manifeste désigne des icônes servies, et l'application à la racine.
 manifest="$(curl -s "$base/manifest.webmanifest")"

tests/test_web.sh

@@ -5,7 +5,10 @@
 # - scénarios de docs/scenarios/ exécutés par Cucumber sur le domaine branché
 #   au vrai moteur (ADR 0008) ;
 # - règles d'architecture (dependency-cruiser, ADR 0007), et preuve qu'une
-#   violation volontaire de chaque règle est bien détectée.
+#   violation volontaire de chaque règle est bien détectée ;
+# - export SGF : des parties jouées sur le vrai moteur, exportées, relues par
+#   le GNU Backgammon de référence, qui doit y retrouver les positions du
+#   journal (tests/sgf/check.py).
 #
 # Lance `make engine-wasm` et `make web` (sans effet si tout est à jour).
 
@@ -39,6 +42,24 @@ web . node --test --test-reporter=dot 'build/web/tests/**/*.test.js' \
 web . cucumber-js --format summary --import 'build/web/tests/steps/*.js' docs/scenarios/*.feature \
 	|| report "scénarios en échec (voir ci-dessus)"
 
+# Export SGF relu par gnubg de bureau. Le script Python de gnubg ne
+# transmet pas de code de sortie : sa dernière ligne donne le verdict.
+samples=build/sgf-samples
+rm -rf "$samples"
+if ! docker image inspect "${REFERENCE_IMAGE:?lancer via make test}" >/dev/null 2>&1; then
+	report "gnubg de référence absent : lancer d'abord make setup"
+elif ! web . node build/web/tests/tools/sgf-samples.js "$samples" >/dev/null; then
+	report "parties d'exemple SGF non produites (voir ci-dessus)"
+else
+	output="$(docker run --rm --user "$(id -u):$(id -g)" -e HOME=/tmp \
+		-v "$PWD/$samples:/sgf:ro" -v "$PWD/tests/sgf:/check:ro" "$REFERENCE_IMAGE" \
+		gnubg --tty --quiet --no-rc --python=/check/check.py 2>&1)" || true
+	if ! grep -q '^SGF-RESULTAT OK$' <<<"$output"; then
+		grep -E '^(ÉCHEC|aucun|Traceback|  File|[A-Za-z]*Error)' <<<"$output" || true
+		report "export SGF : gnubg ne retrouve pas les positions du journal"
+	fi
+fi
+
 web app depcruise --config .dependency-cruiser.cjs src tests \
 	|| report "règles d'architecture non respectées (voir ci-dessus)"