Versione 0.1.69

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GiECd9RWGMKV7n3K1mdy8T

.gitea/workflows/test.yml

@@ -0,0 +1,45 @@
+# Le Gitea Actions del gioco: girano sul runner del PC di Andrea (make runner; label ubuntu-latest = node:22-bookworm).
+# A ogni push su main e a ogni tag i test unitari; su un tag vX.Y.Z, se passano, la release con i commit dal tag prima.
+# Il controllo dei file pubblicabili non sta qui (a pipeline partita il push è già pubblico): è l'hook pre-push.
+name: test
+on:
+  push:
+    branches: [main]
+    tags: ['v*']
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Test unitari
+        run: node --version && node --test tests/*.test.mjs
+
+  release:
+    needs: test
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Release del tag
+        env:
+          TOKEN: ${{ secrets.GITEA_TOKEN }}
+          TAG: ${{ github.ref_name }}
+          API: ${{ github.server_url }}/api/v1/repos/${{ github.repository }}
+        run: |
+          prev=$(git describe --tags --abbrev=0 "$TAG^" 2>/dev/null || true)
+          {
+            echo "Si gioca su https://50037.manzolo.it; qui sotto lo zip di questa versione."
+            echo
+            echo "Cosa cambia${prev:+ da $prev}:"
+            echo
+            git log --no-merges --format='- %s' ${prev:+$prev..}"$TAG" | grep -v -e '^- Versione [0-9]' | cut -c1-400
+          } > note.md
+          node -e 'const fs=require("fs");process.stdout.write(JSON.stringify({tag_name:process.env.TAG,name:"Versione "+process.env.TAG.slice(1),body:fs.readFileSync("note.md","utf8")}))' > release.json
+          code=$(curl -s -o risposta.json -w '%{http_code}' -X POST -H "Authorization: token $TOKEN" -H 'Content-Type: application/json' --data @release.json "$API/releases")
+          cat risposta.json | head -c 400; echo
+          [ "$code" = 201 ] || [ "$code" = 409 ]

.gitignore

@@ -7,3 +7,4 @@ assets/generated/
 .venv/
 .env
 deploy.local.mk
+.verify-ok.json

CLAUDE.md

@@ -16,9 +16,16 @@ i suoi ricordi: non inventare persone, luoghi o fatti del paese al posto suoi; p
   (`tools/slice_sprites.py`, `scripts/build-site.sh`, `scripts/bump.sh`, `scripts/check-public.sh`, action di Pages).
 - Nessun build step: ES modules statici, server locale con `python3 -m http.server`.
 - Ogni funzionalità con il suo test; un test automatico percorre tutta la soluzione dell'avventura.
+- Le prove nel browser sono a sezioni (`scripts/verify.mjs`, dal 2026-11-01): `make verify` rifà solo quelle i cui ingressi
+  sono cambiati dall'ultimo verde (la briscola se cambia la briscola, la partita intera se cambiano storia, motore, stile
+  o risorse). Una prova nuova in `tests/*.browser.mjs` va aggiunta a `SUITES` (il test `verify.test.mjs` lo pretende).
 - Verifica visiva nel browser con Playwright e swiftshader prima di dichiarare finito qualcosa di grafico.
 - Pubblicare (tag/bump/push) solo quando Andrea lo chiede.
 - Persone vere nel gioco solo con consenso; niente nomi, personaggi o musiche di giochi esistenti.
 - Prompt delle immagini in `prompts/` e fogli grezzi in `assets/raw/`: esclusi da git.
 - Sfondi nuovi: li genera **Codex** con il suo strumento immagini integrato, gratis e senza chiave API
   (`codex exec`, ricetta in `docs/GENERAZIONE_SFONDI.md`, «Generare con Codex»). Si lancia da qui, senza chiedere la chiave ad Andrea.
+- **Pubblicare (dal 2026-11-01)**: origin è https://git.manzolo.it/manzolo/leggenda-del-regolo, pubblico: prima `make check-public`, poi `git push origin main --tags`, solo se Andrea lo chiede.
+  `make deploy` costruisce l'immagine dal tag della versione, la spinge su `git.manzolo.it/manzolo/leggenda-regolo:vX.Y.Z` (e `:latest`); sul VPS il compose fissa quel tag e fa `docker compose pull && up -d`.
+  Per tornare indietro: sul VPS (`Workspaces/docker/leggenda-regolo/docker-compose.yml`) si rimette il tag precedente e si rifà pull e up.
+  Hook pre-push (`make hooks`, una volta per clone) lancia check-public; le Gitea Actions (`.gitea/workflows/test.yml`: test, e release sui tag) girano sul runner del PC, che si crea o riavvia con `make runner`.

Makefile

@@ -23,8 +23,8 @@ DST         ?= assets/scenes/$(notdir $(SRC))
 CROP        ?=
 COLORS      ?= 64
 
-.PHONY: help serve open test browser verify check-public bump voci voci-elenco sfondi sfondi-genera sfondi-confronto background character \
-        build up down restart logs ps shell image-size deploy deploy-logs clean distclean
+.PHONY: help serve open test browser verify verify-browser verify-plan check-public hooks bump voci voci-elenco sfondi sfondi-genera sfondi-confronto background character \
+        build up down restart logs ps shell image-size deploy deploy-logs runner clean distclean
 
 ## ------------------------------------------------------------ sviluppo
 
@@ -47,14 +47,26 @@ test: ## Test della logica, della storia, della soluzione completa e del generat
 	$(NODE) --test tests/*.test.mjs
 	$(PYTHON) -m unittest discover -s tests -p "test_*.py" -q
 
-browser: ## Partita completa nel browser con Playwright
+browser: ## Partita completa nel browser con Playwright (tre parti in processi paralleli, ~4,5 min)
 	$(NODE) tests/browser.mjs
 
-verify: test browser check-public ## Tutti i controlli
+verify: test check-public verify-browser ## Tutti i controlli: test unitari, file pubblicabili, prove nel browser cambiate (ALL=1: tutte)
+
+# Le prove nel browser a sezioni: si rifanno solo quelle i cui ingressi sono cambiati dall'ultimo verde (.verify-ok.json,
+# fuori da git); make verify-browser ALL=1 le rifà tutte, make verify-plan dice solo cosa rifarebbe; JOBS=2 in parallelo (con 4 vanno in timeout).
+verify-browser: ## Le prove nel browser da rifare (ALL=1 tutte; PROVE="briscola flipper" solo quelle)
+	$(NODE) scripts/verify.mjs $(if $(ALL),--all,) $(PROVE)
+
+verify-plan: ## Dice quali prove nel browser rifarebbe make verify, e perché
+	$(NODE) scripts/verify.mjs --plan
 
 check-public: ## Prima di pubblicare: niente prompt, fogli grezzi, segreti o nomi della rete di casa (tutta la storia)
 	bash scripts/check-public.sh
 
+hooks: ## Attiva gli hook del repo (pre-push: check-public prima di ogni push)
+	git config core.hooksPath scripts/git-hooks
+	@echo "hook attivi da scripts/git-hooks: $$(ls scripts/git-hooks | tr '\n' ' ')"
+
 bump: ## Nuova versione (PARTE=patch|minor|major): verifica, commit e tag v<versione>; poi make deploy
 	scripts/bump.sh $(or $(PARTE),patch)
 
@@ -121,40 +133,53 @@ image-size: ## Dimensione dell'immagine
 
 ## ------------------------------------------------------------ deploy su un server proprio
 
-# Host e indirizzo stanno in deploy.local.mk, fuori da git, per esempio:
+# Host e cartella stanno in deploy.local.mk, fuori da git, per esempio:
 #   DEPLOY_HOST  = root@mio-server
 #   DEPLOY_URL   = https://gioco.esempio
 #   DEPLOY_DIR   = docker/leggenda-regolo   (la cartella del compose sul server)
+#   DEPLOY_IMAGE = registry.esempio/utente/leggenda-regolo
 -include deploy.local.mk
 DEPLOY_DIR   ?= /root/leggenda-regolo
+DEPLOY_IMAGE ?= git.manzolo.it/manzolo/leggenda-regolo
 DEPLOY_TMP   := $(shell mktemp -d -u /tmp/regolo-deploy.XXXXXX)
+# La versione dell'ultimo commit (non della cartella di lavoro): il tag git, dell'immagine e del compose.
+DEPLOY_VER   := v$(shell git show HEAD:src/version.js 2>/dev/null | sed -n "s/.*VERSION = '\([^']*\)'.*/\1/p")
 
-# Si pubblica l'ultimo commit (git archive HEAD), mai la cartella di lavoro: un'altra sessione può avere modifiche a
-# metà. Test su quella copia, immagine costruita e provata qui, poi spedita già pronta (docker save | docker load):
-# sul server non si compila niente.
+# Si pubblica il tag della versione dichiarata dall'ultimo commit (git archive vX.Y.Z, quello di make bump), mai la
+# cartella di lavoro: un'altra sessione può avere modifiche a metà, e i commit dopo il tag aspettano la versione dopo.
+# Test su quella copia, immagine costruita e provata qui, spinta sul registry di Gitea come :vX.Y.Z e :latest; il
+# VPS la scarica con il tag scritto nel suo compose (preso da HEAD, docker-compose.deploy.yml).
 SMOKE_PORT  ?= 18737
-deploy: ## Pubblica l'ultimo commit: test, immagine costruita e provata qui, spedita al server e riavviata
+deploy: ## Pubblica la versione dell'ultimo commit: test, immagine provata qui, push sul registry, pull e riavvio sul server
 	@test -n "$(DEPLOY_HOST)" || { echo "manca DEPLOY_HOST: scrivilo in deploy.local.mk"; exit 2; }
-	mkdir -p $(DEPLOY_TMP) && git archive HEAD | tar -x -C $(DEPLOY_TMP)
+	@git rev-parse -q --verify 'refs/tags/$(DEPLOY_VER)' >/dev/null || { echo "manca il tag $(DEPLOY_VER): prima make bump"; exit 2; }
+	mkdir -p $(DEPLOY_TMP) && git archive $(DEPLOY_VER) | tar -x -C $(DEPLOY_TMP)
 	cd $(DEPLOY_TMP) && $(NODE) --test tests/*.test.mjs
-	docker build -q -t $(IMAGE):latest -t $(IMAGE):$$(git rev-parse --short HEAD) $(DEPLOY_TMP)
+	docker build -q -t $(DEPLOY_IMAGE):$(DEPLOY_VER) -t $(DEPLOY_IMAGE):latest $(DEPLOY_TMP)
 	@docker rm -f $(IMAGE)-prova >/dev/null 2>&1 || true
-	docker run -d --rm --name $(IMAGE)-prova -p 127.0.0.1:$(SMOKE_PORT):80 $(IMAGE):latest >/dev/null
+	docker run -d --rm --name $(IMAGE)-prova -p 127.0.0.1:$(SMOKE_PORT):80 $(DEPLOY_IMAGE):$(DEPLOY_VER) >/dev/null
 	@ok=1; sleep 1; for u in / /src/main.js /assets/voices/index.json /assets/audio/cartello.mp3; do \
 	  c=$$(curl -s -o /dev/null -w '%{http_code}' http://127.0.0.1:$(SMOKE_PORT)$$u); echo "  prova $$u → $$c"; [ "$$c" = 200 ] || ok=0; done; \
 	  docker rm -f $(IMAGE)-prova >/dev/null; [ $$ok = 1 ] || { echo "l'immagine non risponde come deve: non la spedisco"; exit 1; }
-	ssh $(DEPLOY_HOST) 'mkdir -p $(DEPLOY_DIR)'
-	scp -q $(DEPLOY_TMP)/docker-compose.homeserver.yml $(DEPLOY_HOST):$(DEPLOY_DIR)/docker-compose.yml
-	docker save $(IMAGE):latest | gzip | ssh $(DEPLOY_HOST) 'gunzip | docker load -q && cd $(DEPLOY_DIR) && docker compose up -d && docker image prune -f >/dev/null'
+	docker push -q $(DEPLOY_IMAGE):$(DEPLOY_VER)
+	docker push -q $(DEPLOY_IMAGE):latest
+	git show HEAD:docker-compose.deploy.yml | sed 's|$(DEPLOY_IMAGE):VERSIONE|$(DEPLOY_IMAGE):$(DEPLOY_VER)|' | \
+	  ssh $(DEPLOY_HOST) 'mkdir -p $(DEPLOY_DIR) && cat > $(DEPLOY_DIR)/docker-compose.yml'
+	ssh $(DEPLOY_HOST) 'cd $(DEPLOY_DIR) && docker compose pull -q && docker compose up -d && \
+	  docker image ls $(DEPLOY_IMAGE) --format "{{.Repository}}:{{.Tag}}" | grep -v -x -e $(DEPLOY_IMAGE):$(DEPLOY_VER) | xargs -r docker image rm >/dev/null; \
+	  docker image prune -f >/dev/null'
 	rm -rf $(DEPLOY_TMP)
-	@# Sul server il prune toglie l'immagine vecchia; qui restano solo latest e quella appena pubblicata.
-	@docker image ls $(IMAGE) --format '{{.Tag}}' | grep -v -x -e latest -e $$(git rev-parse --short HEAD) | \
-	  xargs -r -I{} docker image rm -f $(IMAGE):{} >/dev/null
+	@# Qui restano solo latest e la versione appena pubblicata.
+	@docker image ls $(DEPLOY_IMAGE) --format '{{.Tag}}' | grep -v -x -e latest -e $(DEPLOY_VER) | \
+	  xargs -r -I{} docker image rm -f $(DEPLOY_IMAGE):{} >/dev/null
 	@# L'indirizzo pubblico deve servire la versione appena spedita.
-	@v=$$(grep -o "VERSION = '[^']*'" src/version.js); \
+	@v=$$(git show $(DEPLOY_VER):src/version.js | grep -o "VERSION = '[^']*'"); \
 	  for i in 1 2 3 4 5; do curl -s $(DEPLOY_URL)/src/version.js | grep -qF "$$v" && break; sleep 2; done; \
 	  curl -s $(DEPLOY_URL)/src/version.js | grep -qF "$$v" || { echo "$(DEPLOY_URL) non serve $$v"; exit 1; }
-	@echo "→ $(DEPLOY_URL) ($$(git log -1 --format='%h %s'))"
+	@echo "→ $(DEPLOY_URL) ($(DEPLOY_IMAGE):$(DEPLOY_VER), $$(git log -1 --format='%h %s' $(DEPLOY_VER)))"
+
+runner: ## Crea (se manca) e avvia sul PC il runner delle Gitea Actions (tools/gitea-runner, scripts/runner.sh)
+	bash scripts/runner.sh
 
 deploy-logs: ## Log del container sul server di deploy
 	@test -n "$(DEPLOY_HOST)" || { echo "manca DEPLOY_HOST: scrivilo in deploy.local.mk"; exit 2; }

README.md

@@ -23,7 +23,9 @@ Si gioca online su **https://50037.manzolo.it** (50037 è il CAP di San Piero),
 
 ## Giocare in locale
 
-Niente da installare e niente da compilare: HTML, CSS e moduli JavaScript ES.
+Il gioco si scarica da **https://git.manzolo.it/manzolo/leggenda-del-regolo**: nella pagina dei
+[tag](https://git.manzolo.it/manzolo/leggenda-del-regolo/tags) c'è lo zip di ogni versione (l'ultima è quella online).
+Niente da installare e niente da compilare: HTML, CSS e moduli JavaScript ES. Dentro la cartella scompattata:
 
 ```zsh
 python3 -m http.server 8000     # poi http://localhost:8000
@@ -40,16 +42,16 @@ Oppure `make up` (Docker, su http://localhost:8080). Non aprire `index.html` con
 - `assets/`: sfondi, sprite, musiche, voci, carattere, video.
 - `tools/`: gli strumenti (sprite dai fogli, voci con XTTS, musiche sintetizzate, favicon, taratura dei minigiochi).
 - `tests/`: `npm test` (unità: regole, storia coerente, voci, salvataggi) e `npm run browser` (Playwright: percorre
-  tutta la soluzione dell'avventura, su desktop e telefono); `npm run browser:briscola`, `:tressette`, `:scopa`,
-  `:biliardo`, `:effects` per le parti singole.
+  tutta la soluzione dell'avventura, su desktop e telefono, in tre processi paralleli; `--parte=` per una sola);
+  `npm run browser:briscola`, `:tressette`, `:scopa`, `:biliardo`, `:effects` per le parti singole.
 - `video/`: i copioni dei video «Come si gioca» e della demo, girati in una macchina virtuale.
 - `docs/`: `PROGETTO.md` (l'idea, i personaggi, la mappa) e `STATO.md` (dove siamo, cosa manca).
 
 ```zsh
-make verify        # sintassi, test, prova nel browser: quello che gira prima di ogni versione
+make verify        # test, file pubblicabili e le prove nel browser cambiate dall'ultimo verde (ALL=1: tutte)
 make voci          # le voci delle battute nuove (XTTS-v2 su GPU)
 make bump          # nuova versione: verifica, commit e tag
-make deploy        # pubblica l'ultimo commit (immagine Docker spedita al server)
+make deploy        # pubblica la versione: immagine sul registry di Gitea, il server la scarica
 ```
 
 ## Chi ha fatto cosa

docker-compose.deploy.yml

@@ -0,0 +1,15 @@
+# Il compose del VPS (make deploy lo copia in DEPLOY_DIR con il tag della versione al posto di VERSIONE).
+# L'immagine viene dal registry di Gitea; niente porte esposte: il container sta sulla rete esterna nginx-net,
+# dove Nginx Proxy Manager del VPS lo pubblica col suo nome (50037.manzolo.it → leggenda-regolo:80).
+# Per tornare indietro: sul VPS si rimette il tag precedente qui sotto e si rifà `docker compose pull && docker compose up -d`.
+services:
+  leggenda-regolo:
+    image: git.manzolo.it/manzolo/leggenda-regolo:VERSIONE
+    container_name: leggenda-regolo
+    restart: unless-stopped
+    networks:
+      - nginx-net
+
+networks:
+  nginx-net:
+    external: true

docker-compose.homeserver.yml

@@ -1,13 +0,0 @@
-# Deploy dietro un reverse proxy (make deploy): l'immagine arriva già costruita dal PC (docker load), niente porte esposte, il container sta sulla rete esterna nginx-net,
-# dove Nginx Proxy Manager del VPS lo pubblica col suo nome (50037.manzolo.it → leggenda-regolo:80).
-services:
-  leggenda-regolo:
-    image: leggenda-regolo:latest
-    container_name: leggenda-regolo
-    restart: unless-stopped
-    networks:
-      - nginx-net
-
-networks:
-  nginx-net:
-    external: true

docs/STATO.md

@@ -302,6 +302,21 @@ versione nuova.
 - **Test**: `make test` (29 test, compresa la soluzione completa da `src/story/solution.js`) e `make browser`
   (partita completa con clic veri in Chromium, ripresa del salvataggio, telefono).
 
+- **Impaginazione (1 novembre, Andrea: «come mai non sfruttiamo tutto lo schermo?»):** la scena prende la finestra. La
+  riserva sotto non è più 250 px fissi ma l'altezza vera del pannello, 13,3 unità `--u` (un centesimo della larghezza
+  del gioco, `cqw`, fra 8,75 e 12,8 px: `#app` è un container). Frase, verbi, inventario, risposte, HUD e fumetti scalano
+  col gioco, non con la finestra: i verbi non si tagliano più nelle finestre piccole. Il pannello è alto sempre uguale
+  (ci stanno quattro risposte; da cinque il carattere cala, da sette ancora) così la scena non si muove nei dialoghi;
+  la frase è una riga sola coi puntini. «Schermo intero» nella Pausa (dove il browser lo permette). A 1040×590 la scena
+  passa da 604 a 842 px di larghezza, a 1366×650 da 711 a 935; sui telefoni niente cambia. Prova in `browser.mjs`.
+
+- **Prove a sezioni (1 novembre, idea di Andrea):** `scripts/verify.mjs` conosce gli ingressi di ogni prova nel browser
+  (i file da cui dipende: i propri, più il motore comune; per la partita intera tutto il gioco tranne i minigiochi a sé)
+  e rifà solo quelle la cui impronta è cambiata dall'ultimo verde, ricordato in `.verify-ok.json` fuori da git. Così
+  `make bump` dopo una modifica alla briscola riprova la briscola e basta; dopo una modifica alla storia la partita intera
+  e le scene speciali (ambient, veicoli, ingorgo, smarronata), non la briscola; dopo `style.css` o `game.js` tutto.
+  Le prove dei minigiochi, che prima non entravano in `make verify`, ora ci stanno. `make verify-plan` spiega.
+
 ## Materiale ricevuto da Andrea (in `assets/raw/`, escluso da git)
 
 | File | Cosa | Uso previsto |

index.html

@@ -86,6 +86,7 @@
       <div class="buttons pause-buttons">
         <button id="resume">Riprendi</button>
         <button id="pause-map" class="secondary">Mappa</button>
+        <button id="fullscreen" class="secondary" title="Il gioco su tutto lo schermo; Esc per uscire">Schermo intero</button>
         <button id="save-file" class="secondary" title="Scarica la partita in un file da aprire su un altro dispositivo">Salva su file</button>
         <button class="open-credits secondary">Ringraziamenti</button>
         <button id="to-title" class="secondary">Torna al titolo</button>

package.json

@@ -1,6 +1,6 @@
 {
   "name": "leggenda-del-regolo",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "private": true,
   "type": "module",
   "scripts": {

scripts/git-hooks/pre-push

@@ -0,0 +1,5 @@
+#!/bin/bash
+# Prima di ogni push: il repo su git.manzolo.it è pubblico, quindi niente che check-public bocci deve partire.
+# Si attiva una volta con `make hooks` (core.hooksPath = scripts/git-hooks).
+cd "$(git rev-parse --show-toplevel)" || exit 1
+bash scripts/check-public.sh || { echo; echo "pre-push: push bloccato da check-public (vedi sopra)."; exit 1; }

scripts/runner.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Crea (se manca) e avvia il runner delle Gitea Actions su questo PC: `make runner`.
+# Rifarlo da zero: `docker compose -f tools/gitea-runner/docker-compose.yml down`, cancellare $RUNNER_DATA e il runner
+# vecchio da Gitea (repo → Impostazioni → Actions → Runner), poi di nuovo `make runner`.
+# Il token di registrazione si chiede all'API di Gitea con le credenziali di git (serve lo scope write:repository).
+set -euo pipefail
+ROOT=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)
+COMPOSE="$ROOT/tools/gitea-runner/docker-compose.yml"
+REPO=${RUNNER_REPO:-manzolo/leggenda-del-regolo}
+export RUNNER_DATA=${RUNNER_DATA:-$HOME/.local/share/gitea-runner}
+export GITEA_RUNNER_NAME=${GITEA_RUNNER_NAME:-pc-$(hostname | tr '[:upper:]' '[:lower:]')}
+mkdir -p "$RUNNER_DATA"
+
+if [[ ! -s $RUNNER_DATA/.runner ]]; then
+    pass=$(printf 'protocol=https\nhost=git.manzolo.it\n\n' | git credential fill | sed -n 's/^password=//p')
+    user=$(printf 'protocol=https\nhost=git.manzolo.it\n\n' | git credential fill | sed -n 's/^username=//p')
+    [[ -n $pass ]] || { echo "nessuna credenziale git per git.manzolo.it"; exit 1; }
+    tok=$(curl -sf -X POST -u "$user:$pass" "https://git.manzolo.it/api/v1/repos/$REPO/actions/runners/registration-token" |
+          python3 -c 'import json,sys; print(json.load(sys.stdin)["token"])') ||
+        { echo "Gitea non ha dato il token di registrazione (scope write:repository?)"; exit 1; }
+    echo "registro il runner $GITEA_RUNNER_NAME su $REPO"
+    GITEA_RUNNER_REGISTRATION_TOKEN=$tok docker compose -f "$COMPOSE" up -d
+    for _ in $(seq 30); do [[ -s $RUNNER_DATA/.runner ]] && break; sleep 1; done
+    [[ -s $RUNNER_DATA/.runner ]] || { docker logs --tail 20 gitea-runner; echo "registrazione non riuscita"; exit 1; }
+    chmod 600 "$RUNNER_DATA/.runner" 2>/dev/null || true
+fi
+# Senza token nell'ambiente del container: da qui in poi si autentica con .runner.
+docker compose -f "$COMPOSE" up -d
+sleep 2; docker logs --tail 1 gitea-runner

scripts/verify.mjs

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+// Le prove nel browser a sezioni (idea di Andrea, 1 novembre 2026): ogni prova ha i suoi ingressi, i file da cui dipende;
+// si rifà solo se la loro impronta (i blob di git, più i file modificati nella cartella di lavoro) è cambiata dall'ultimo
+// verde, ricordato in .verify-ok.json (fuori da git). Se cambia la briscola si riprova la briscola; se cambia la storia, il
+// motore, l'impaginazione o le risorse si riprova la partita intera (e le prove delle scene speciali), non la briscola.
+//   node scripts/verify.mjs            le prove da rifare, in parallelo (JOBS=2: con quattro Chromium swiftshader insieme le schermate vanno in timeout), e aggiorna i verdi
+//   node scripts/verify.mjs --plan     dice solo cosa rifarebbe e perché
+//   node scripts/verify.mjs --all      tutte, senza guardare i verdi
+//   node scripts/verify.mjs briscola   solo quelle nominate (anche se verdi)
+// I test unitari e check-public non stanno qui: costano pochi secondi e girano sempre (make verify).
+import { execFileSync, spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { cpus } from 'node:os';
+
+// Il motore comune a tutto: cambia questo e si riprova ogni minigioco.
+export const ENGINE = ['index.html', 'style.css', 'src/main.js', 'src/engine/game.js', 'src/engine/render.js',
+    'tests/helpers.mjs', 'package-lock.json'];
+// Non toccano il gioco nel browser: documenti, strumenti, pubblicazione, versione (make bump la cambia prima di verificare),
+// test unitari (girano sempre, a parte), e questo stesso script (lo prova verify.test.mjs).
+export const IGNORED = [/^docs\//, /^[^/]*\.md$/, /^src\/version\.js$/, /^package\.json$/, /^Makefile$/, /^scripts\//,
+    /^tools\//, /^video\//, /^\.gitea\//, /^prompts\//, /^LICENSE$/, /^Dockerfile$/, /^nginx\.conf$/, /^docker-compose/, /^requirements\.txt$/,
+    /^\.(gitignore|dockerignore|verify-ok\.json)$/, /^tests\/[^/]*\.test\.mjs$/, /^tests\/test_[^/]*\.py$/, /^deploy\.local\.mk$/, /(^|\/)__pycache__\//];
+
+// Le prove. `core: true` = dipende da tutto il gioco tranne i file dei minigiochi a sé (che hanno la loro prova); altrimenti
+// solo dal motore e dai propri file: quelli che si chiamano come la prova (src/engine/flipper.js, flipper-render.js,
+// assets/closeups/flipper-*.png, docs/BRISCOLA.md…) più gli `extra`. `run` sono gli argomenti di node.
+export const SUITES = {
+    principale: { core: true, run: ['tests/browser.mjs', '--parte=principale'], note: 'la partita intera, pausa e salvataggi' },
+    minigiochi: { core: true, run: ['tests/browser.mjs', '--parte=minigiochi'], note: 'libro, bocce, tiri, pesca e biliardo dalla partita' },
+    telefoni:   { core: true, run: ['tests/browser.mjs', '--parte=telefoni'], note: 'multimedia, telefoni, la finestra di Andrea, debug' },
+    ambient:    { core: true, run: ['tests/ambient.browser.mjs'], note: 'tutte le scene nelle tre fasi e gli effetti' },
+    veicoli:    { core: true, run: ['tests/veicoli.browser.mjs'], note: 'i veicoli nelle scene' },
+    ingorgo:    { core: true, run: ['tests/ingorgo.browser.mjs'], note: "l'Ingorgo Sonoro" },
+    smarronata: { core: true, run: ['tests/smarronata.browser.mjs'], note: 'la Smarronata del 1993' },
+    briscola:   { run: ['tests/briscola.browser.mjs'] },
+    tressette:  { run: ['tests/tressette.browser.mjs'] },
+    scopa:      { run: ['tests/scopa.browser.mjs'] },
+    biliardo:   { run: ['tests/biliardo.browser.mjs'] },
+    flipper:    { run: ['tests/flipper.browser.mjs'] },
+    micro:      { run: ['tests/micro.browser.mjs'] },
+    cerbottana: { run: ['tests/cerbottana.browser.mjs'] },
+    condor:     { run: ['tests/condor.browser.mjs'] },
+    campana:    { run: ['tests/campana.browser.mjs'] },
+    bruciate:   { run: ['tests/bruciate.browser.mjs'] },
+    gara:       { run: ['tests/gara.browser.mjs'], extra: ['src/engine/corsa.js', 'src/story/piloti.js', /^assets\/[^/]*\/(gara|gp|pilot)/] },
+    telefono:   { run: ['tests/telefono.browser.mjs'], extra: [/^assets\/muro\//] },
+    risveglio:  { run: ['tests/risveglio.browser.mjs'] },
+};
+
+const ownRe = name => new RegExp(`(^|/)${name}([-_.][^/]*)?$`, 'i');
+const matches = (path, rule) => rule instanceof RegExp ? rule.test(path) : rule === path;
+export const ignored = path => IGNORED.some(r => r.test(path));
+export function ownFiles(name, files) {
+    const s = SUITES[name], re = ownRe(name);
+    return files.filter(p => re.test(p) || (s.extra || []).some(r => matches(p, r)));
+}
+// Gli ingressi di una prova fra i file dati (tutti quelli di git più quelli nuovi nella cartella).
+export function inputsOf(name, files) {
+    const s = SUITES[name], live = files.filter(p => !ignored(p));
+    if (!s.core) return [...new Set([...ENGINE.filter(p => files.includes(p)), ...ownFiles(name, live)])].sort();
+    const others = Object.keys(SUITES).filter(n => !SUITES[n].core);
+    // I file degli altri minigiochi, e i file di prova delle altre prove (tests/ambient.browser.mjs non riguarda la partita).
+    const foreign = new Set([...others.flatMap(n => ownFiles(n, live)),
+        ...Object.keys(SUITES).filter(n => SUITES[n].run[0] !== s.run[0]).map(n => SUITES[n].run[0])]);
+    return live.filter(p => !foreign.has(p)).sort();
+}
+export const fingerprint = (paths, hashOf) => createHash('sha1').update(paths.map(p => `${p} ${hashOf(p)}`).join('\n')).digest('hex');
+
+const ROOT = fileURLToPath(new URL('..', import.meta.url));
+const git = (...a) => execFileSync('git', a, { cwd: ROOT, encoding: 'utf8', maxBuffer: 1 << 26 });
+
+// I file del progetto con l'impronta di ognuno: il blob dell'indice di git, o il contenuto attuale se modificato o nuovo.
+export function snapshot() {
+    const hashes = new Map();
+    for (const line of git('ls-files', '-s', '-z').split('\0')) if (line) { const [meta, path] = line.split('\t'); hashes.set(path, meta.split(' ')[1]); }
+    const dirty = [];
+    for (const line of git('status', '--porcelain', '-z', '--untracked-files=all').split('\0')) {
+        if (!line) continue;
+        const code = line.slice(0, 2), path = line.slice(3);
+        if (code.includes('D')) hashes.delete(path); else dirty.push(path);
+    }
+    for (const path of dirty) if (existsSync(`${ROOT}/${path}`)) hashes.set(path, git('hash-object', '--', path).trim());
+    return hashes;
+}
+
+const OK_FILE = `${ROOT}/.verify-ok.json`;
+const readOk = () => { try { return JSON.parse(readFileSync(OK_FILE, 'utf8')); } catch { return {}; } };
+
+export function plan(hashes, ok, names = Object.keys(SUITES)) {
+    const files = [...hashes.keys()], out = [];
+    for (const name of names) {
+        const inputs = inputsOf(name, files), fp = fingerprint(inputs, p => hashes.get(p));
+        const was = ok[name], changed = was?.fingerprint === fp ? [] : inputs.filter(p => !was?.hashes || was.hashes[p] !== hashes.get(p));
+        out.push({ name, fp, inputs, changed, green: was?.fingerprint === fp, seconds: was?.seconds });
+    }
+    return out;
+}
+
+function run(name) {
+    return new Promise(resolve => {
+        const t0 = Date.now(), lines = [];
+        const p = spawn(process.execPath, SUITES[name].run, { cwd: ROOT, stdio: ['ignore', 'pipe', 'pipe'] });
+        let rest = '';
+        const onData = chunk => { const parts = (rest + chunk).split('\n'); rest = parts.pop(); for (const l of parts) { lines.push(l); console.log(`[${name}] ${l}`); } };
+        p.stdout.on('data', onData); p.stderr.on('data', onData);
+        p.on('close', code => { if (rest) console.log(`[${name}] ${rest}`); resolve({ name, code, seconds: Math.round((Date.now() - t0) / 1000) }); });
+    });
+}
+
+async function main() {
+    const args = process.argv.slice(2), all = args.includes('--all'), onlyPlan = args.includes('--plan');
+    const named = args.filter(a => !a.startsWith('--'));
+    for (const n of named) if (!SUITES[n]) { console.error(`prova sconosciuta: ${n} (${Object.keys(SUITES).join(', ')})`); process.exit(2); }
+    const hashes = snapshot(), ok = readOk();
+    const todo = plan(hashes, ok, named.length ? named : undefined).filter(p => all || named.length || !p.green);
+    const green = Object.keys(SUITES).filter(n => !todo.some(t => t.name === n));
+    if (!todo.length) { console.log(`Prove nel browser: tutte verdi dall'ultimo giro (${green.length}); niente da rifare.`); return; }
+    for (const t of todo) {
+        const why = all ? 'tutte' : named.includes(t.name) ? 'chiesta' : !ok[t.name] ? 'mai provata' : !t.changed.length ? "cambiato l'elenco dei file da cui dipende" : `cambiati ${t.changed.slice(0, 4).join(', ')}${t.changed.length > 4 ? ` e altri ${t.changed.length - 4}` : ''}`;
+        console.log(`da rifare: ${t.name}${t.seconds ? ` (~${t.seconds} s)` : ''}: ${why}`);
+    }
+    if (green.length) console.log(`già verdi: ${green.join(', ')}`);
+    if (onlyPlan) return;
+    const jobs = Math.max(1, Number(process.env.JOBS) || Math.min(2, Math.floor(cpus().length / 4)));
+    const queue = todo.sort((a, b) => (b.seconds || 999) - (a.seconds || 999)), results = [];
+    const worker = async () => { for (let t; (t = queue.shift());) {
+        const r = await run(t.name); results.push(r);
+        if (r.code === 0) {
+            const now = readOk();
+            now[t.name] = { fingerprint: t.fp, seconds: r.seconds, when: new Date().toISOString(), hashes: Object.fromEntries(t.inputs.map(p => [p, hashes.get(p)])) };
+            writeFileSync(OK_FILE, JSON.stringify(now, null, 1) + '\n');
+        }
+    } };
+    await Promise.all(Array.from({ length: Math.min(jobs, queue.length) }, worker));
+    for (const r of results.sort((a, b) => a.name.localeCompare(b.name))) console.log(`${r.code === 0 ? 'OK  ' : 'FAIL'} ${r.name} (${r.seconds} s)`);
+    const failed = results.filter(r => r.code !== 0).map(r => r.name);
+    if (failed.length) { console.log(`Prove fallite: ${failed.join(', ')}`); process.exit(1); }
+    console.log(`Prove nel browser OK: ${results.length} rifatte, ${green.length} già verdi.`);
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) main();

src/main.js

@@ -399,6 +399,18 @@ addEventListener('pagehide', () => leave(true));
 addEventListener('pageshow', () => leave(document.hidden));
 $('resume').addEventListener('click', closePause);
 $('pause-map').addEventListener('click', () => { closePause(); openMap(); });
+// Schermo intero dalla Pausa, dove il browser lo permette (su iPhone no: il pulsante sparisce); Esc o il pulsante per uscire.
+{
+    const full = $('fullscreen');
+    if (!document.fullscreenEnabled) full.hidden = true;
+    else {
+        full.addEventListener('click', () => {
+            if (document.fullscreenElement) document.exitFullscreen();
+            else document.documentElement.requestFullscreen({ navigationUI: 'hide' }).catch(() => {});
+        });
+        document.addEventListener('fullscreenchange', () => { full.textContent = document.fullscreenElement ? 'Esci da schermo intero' : 'Schermo intero'; });
+    }
+}
 $('to-title').addEventListener('click', () => {
     $('pause').hidden = true;
     music.hold = false;

src/version.js

@@ -1,5 +1,5 @@
 // La versione del gioco: la cambia scripts/bump.sh, insieme a package.json.
-export const VERSION = '0.1.67';
+export const VERSION = '0.1.69';
 
 // Immagini, musiche e voci con ?v=<versione>: a ogni versione l'indirizzo cambia e il browser le riscarica,
 // mentre fra una versione e l'altra le tiene in cache a lungo (nginx.conf).

style.css

@@ -20,7 +20,14 @@ html, body { margin: 0; height: 100%; background: var(--bg); color: var(--ink);
 button, input { font-family: var(--font); }
 body { line-height: 1.5; }
 body { display: flex; justify-content: center; overflow-x: hidden; -webkit-tap-highlight-color: transparent; }
-#app { width: min(100vw, 1280px, calc((100dvh - 250px) * 16 / 9)); min-width: min(100vw, 320px); margin-block: auto; display: flex; flex-direction: column; padding: env(safe-area-inset-top) 0 env(safe-area-inset-bottom); }
+/* Il gioco è largo quanto può: tutta la finestra fino a 1280px, oppure quanto ci sta in altezza con il pannello sotto la
+   scena 16:9. Il pannello (frase, poi verbi e inventario o le risposte di un dialogo) è alto --side-h unità --u, dove --u
+   è un centesimo della larghezza del gioco (1cqw) fra 8,75px e 12,8px: tutto il pannello cresce e cala col gioco, non con
+   la finestra, e la riserva in altezza è esatta (prima erano 250px fissi, un centinaio di troppo, che in una finestra
+   1040×590 costavano un terzo della scena). I due calc sono i due regimi di --u: proporzionale, e al minimo. */
+#app { --u: clamp(8.75px, 1cqw, 12.8px); --side-h: 13.3; container-type: inline-size;
+  width: min(100vw, 1280px, calc(100dvh / (9 / 16 + var(--side-h) / 100)), calc((100dvh - var(--side-h) * 8.75px) * 16 / 9));
+  min-width: min(100vw, 320px); margin-block: auto; display: flex; flex-direction: column; padding: env(safe-area-inset-top) 0 env(safe-area-inset-bottom); }
 
 #stage { position: relative; width: 100%; aspect-ratio: 16 / 9; background: #000; user-select: none; touch-action: manipulation; }
 #scene { width: 100%; height: 100%; display: block; image-rendering: pixelated; cursor: crosshair; }
@@ -80,7 +87,7 @@ body { display: flex; justify-content: center; overflow-x: hidden; -webkit-tap-h
 
 /* max-content: vicino al bordo destro il fumetto non si stringe a colonna (lo spazio dopo `left` non conta). */
 #speech { position: absolute; left: 0; top: 0; width: max-content; max-width: 46%; transform: translate(-50%, -100%); pointer-events: none;
-  font-size: clamp(10.08px, 1.66vw, 18.72px); font-weight: bold; line-height: 1.2; text-align: center;
+  font-size: calc(1.4625 * var(--u)); font-weight: bold; line-height: 1.2; text-align: center;
   text-shadow: 2px 0 #000, -2px 0 #000, 0 2px #000, 0 -2px #000, 2px 2px #000, -2px -2px #000; }
 #speech:empty { display: none; }
 #speech { z-index: 3; }
@@ -89,7 +96,7 @@ body { display: flex; justify-content: center; overflow-x: hidden; -webkit-tap-h
 #muro { position: absolute; left: 0; top: 0; width: 1067px; height: 600px; border: 0; z-index: 1; background: #f7e1c0;
   transform: scale(var(--muro-scale, 0.6)); transform-origin: 0 0; }
 /* Il primo piano del libro si chiude da qui (o con Esc). */
-#closeup-close { position: absolute; right: 10px; bottom: 10px; z-index: 2; font: bold clamp(10px, 1.5vw, 15px) var(--font);
+#closeup-close { position: absolute; right: 10px; bottom: 10px; z-index: 2; font: bold calc(1.17 * var(--u)) var(--font);
   padding: .45em 1.2em; border-radius: 6px; border: 0; cursor: pointer; color: var(--bg); background: var(--accent); }
 /* Al biliardo audio, pausa e uscita hanno spazio proprio: nessun comando copre biglie o punteggio. */
 #stage.biliardo { padding-top: 44px; aspect-ratio: auto; background: #17110c; }
@@ -104,24 +111,27 @@ body { display: flex; justify-content: center; overflow-x: hidden; -webkit-tap-h
   background: rgba(27, 20, 32, .62); border-radius: 18px; }
 #mute { width: 30px; height: 30px; padding: 0; font: bold 12.96px var(--font); color: var(--accent); background: none; border: 0; cursor: pointer; }
 #mute[aria-pressed="true"] { color: var(--dim); text-decoration: line-through; }
-#volume, #voice-volume { width: clamp(50px, 9vw, 100px); accent-color: var(--accent); cursor: pointer; }
+#volume, #voice-volume { width: calc(7.8 * var(--u)); accent-color: var(--accent); cursor: pointer; }
 .sound-label { margin-left: 4px; font-size: 9px; color: var(--accent); }
 
-#sentence { min-height: 1.8em; padding: .25em .6em; text-align: center; color: var(--blue); font-size: clamp(10.8px, 1.44vw, 15.84px); font-weight: bold; background: var(--panel); }
+/* La frase: una riga sola, alta sempre uguale (2,5 --u); una frase lunghissima finisce coi puntini invece di spostare la scena. */
+#sentence { height: calc(2.5 * var(--u)); line-height: 1.5; padding: .25em .6em; text-align: center; color: var(--blue); font-size: calc(1.2375 * var(--u)); font-weight: bold; background: var(--panel);
+  white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
 
-#panel { display: grid; grid-template-columns: minmax(0, 1.1fr) minmax(0, 1fr); gap: 8px; padding: 8px; background: var(--panel); }
+/* Verbi e inventario: alti sempre uguale (10,8 --u, dove stanno anche quattro risposte di dialogo: vedi #choices). */
+#panel { display: grid; grid-template-columns: minmax(0, 1.1fr) minmax(0, 1fr); gap: calc(.625 * var(--u)); padding: calc(.625 * var(--u)); height: calc(10.8 * var(--u)); background: var(--panel); }
 /* Otto verbi su due righe piene, quattro per riga. */
-#verbs { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 4px; align-content: start; }
+#verbs { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: calc(.3125 * var(--u)); align-content: stretch; }
 #verbs button, #inventory button { font: inherit; color: var(--dim); background: #3a2d42; border: 2px solid #4b3a55; border-radius: 4px;
-  padding: .35em .2em; font-size: clamp(9.36px, 1.22vw, 13.68px); font-weight: bold; cursor: pointer; }
+  padding: .35em .2em; font-size: calc(1.069 * var(--u)); font-weight: bold; cursor: pointer; }
 #verbs button:hover, #inventory button:hover { color: var(--ink); }
 #verbs button[aria-pressed="true"] { color: var(--bg); background: var(--accent); border-color: var(--accent); }
-#inventory { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); grid-auto-rows: minmax(2.4em, auto); gap: 4px; align-content: start;
-  min-height: 5.4em; padding: 4px; background: #231a29; border: 2px solid #4b3a55; border-radius: 4px;
+#inventory { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); grid-auto-rows: minmax(2.4em, auto); gap: calc(.3125 * var(--u)); align-content: start;
+  min-height: 0; padding: calc(.3125 * var(--u)); background: #231a29; border: 2px solid #4b3a55; border-radius: 4px;
   /* L'inventario non allunga mai il pannello: è alto quanto i verbi, e se gli oggetti sono tanti si scorre. */
   contain: size; overflow-y: auto; overscroll-behavior: contain; scrollbar-width: thin; scrollbar-color: #6a557a transparent; }
 #inventory:empty::before { content: 'Inventario'; grid-column: 1 / -1; align-self: center; text-align: center; color: var(--dim); opacity: .45;
-  font-size: clamp(9.36px, 1.22vw, 13.68px); font-weight: bold; letter-spacing: .08em; }
+  font-size: calc(1.069 * var(--u)); font-weight: bold; letter-spacing: .08em; }
 #inventory button { display: flex; align-items: center; gap: .35em; justify-content: center; color: var(--ink); }
 #inventory button { min-width: 0; overflow: hidden; }
 #inventory button span.long { min-width: 0; font-size: .72em; line-height: 1.15; text-align: left; }
@@ -130,8 +140,14 @@ body { display: flex; justify-content: center; overflow-x: hidden; -webkit-tap-h
 #inventory img { width: 1.9em; height: 1.9em; flex: none; image-rendering: pixelated; }
 
 /* Il carattere sta sull'elenco, non sulle righe: il rientro in em segue il carattere. «1. » nel carattere pixel è largo tre caratteri e mezzo. */
-#choices { margin: 0; padding: 10px 14px 12px 3.6em; background: var(--panel); min-height: 6.5em; font-size: clamp(10.8px, 1.44vw, 15.84px); }
-#choices li { padding: .25em 0; font-weight: bold; color: var(--dim); cursor: pointer; }
+/* Le risposte: alte quanto il pannello dei verbi, così la scena non si muove quando parte un dialogo. Quattro risposte ci
+   stanno al carattere pieno; da cinque in su il carattere cala (e se mai non bastasse, si scorre). */
+#choices { margin: 0; padding: calc(.78 * var(--u)) calc(1.1 * var(--u)) calc(.94 * var(--u)) 3.6em; background: var(--panel); height: calc(10.8 * var(--u));
+  overflow-y: auto; scrollbar-width: thin; font-size: calc(1.2375 * var(--u)); line-height: 1.4; }
+#choices li { padding: .2em 0; font-weight: bold; color: var(--dim); cursor: pointer; }
+#choices:has(li:nth-child(5)) { font-size: calc(.96 * var(--u)); line-height: 1.25; }
+#choices:has(li:nth-child(5)) li { padding: .15em 0; }
+#choices:has(li:nth-child(7)) { font-size: calc(.72 * var(--u)); }
 #choices li:hover, #choices li:focus { color: var(--accent); outline: none; }
 
 .overlay { position: absolute; inset: 0; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: .6em;
@@ -223,10 +239,11 @@ body.full #sound { position: fixed; z-index: 13; top: max(8px, env(safe-area-ins
 /* Mappa: la pianta del paese a gradini, i posti visti come cartellini, le strade come linee. */
 /* In alto a sinistra: Pausa e Mappa. */
 #corner { position: absolute; top: 6px; left: 6px; z-index: 2; display: flex; gap: 6px; }
-#map-button, #pause-button, #notebook-button, #spots-button, #back-button { font: bold clamp(8.64px, 1.15vw, 11.52px) var(--font); padding: .35em .8em;
+#map-button, #pause-button, #notebook-button, #spots-button, #back-button { font: bold calc(.9 * var(--u)) var(--font); padding: .35em .8em;
   color: var(--accent); background: rgba(27, 20, 32, .62); border: 0; border-radius: 18px; cursor: pointer; }
 #back-button { color: #1b1420; background: #9fd0ff; }
-#pause { z-index: 3; background: rgba(15, 10, 20, .9); }
+/* Con molti pulsanti la Pausa può essere più alta della scena: «safe» la fa partire dall'alto e scorrere, invece di tagliare il titolo. */
+#pause { z-index: 3; background: rgba(15, 10, 20, .9); justify-content: safe center; }
 /* Il player dei video «Come si gioca»: sopra a tutto, il video grande quanto può. */
 #tutorial { position: fixed; inset: 0; z-index: 20; background: rgba(10, 8, 14, .97); padding: 8px; }
 #tutorial video { max-width: min(100%, 1100px); max-height: calc(100dvh - 9em); background: #000; }
@@ -323,6 +340,9 @@ body.full #sound { position: fixed; z-index: 13; top: max(8px, env(safe-area-ins
   #pause { position: fixed; inset: 0; z-index: 10; overflow-y: auto; background: rgba(15, 10, 20, .97); } }
 /* Schermi stretti: il carattere a pixel è largo, i verbi vanno sopra l'inventario e su due righe da quattro. */
 @media (max-width: 600px) {
+  #sentence { height: auto; min-height: 1.8em; white-space: normal; }
+  #panel, #choices { height: auto; }
+  #choices { min-height: 6.5em; }
   #panel { grid-template-columns: 1fr; gap: 6px; padding: 6px; }
   #verbs button { font-size: 9px; padding: .7em .1em; }
   #inventory { height: 7.6em; }
@@ -341,7 +361,8 @@ body.full #sound { position: fixed; z-index: 13; top: max(8px, env(safe-area-ins
   .card-hand-many button, .card-buttons button { flex-basis: 40%; overflow-wrap: anywhere; }
   .card-hand { flex-direction: column; gap: 4px; }
   #side { flex: 1; min-width: 0; display: flex; flex-direction: column; background: var(--panel); }
-  #sentence { font-size: 10.08px; }
+  #sentence { height: auto; min-height: 1.8em; white-space: normal; font-size: 10.08px; }
+  #panel, #choices { height: auto; }
   /* Il fumetto: più largo e più piccolo, sennò una battuta lunga diventa una colonna alta quanto la scena. */
   #speech { max-width: 72%; font-size: 11px; }
   #panel { grid-template-columns: 1fr; grid-template-rows: auto minmax(0, 1fr); flex: 1; min-height: 0; gap: 6px; padding: 6px; }
@@ -358,6 +379,7 @@ body.full #sound { position: fixed; z-index: 13; top: max(8px, env(safe-area-ins
   .buttons { gap: 6px; margin-top: .2em; }
   .buttons button { font-size: 10px; padding: .45em 1em; }
   .pause-buttons { min-width: 12em; }
+  #pause .hint { display: none; }
   /* Mappa: schede più piccole, ne stanno cinque o sei per riga. */
   #map-board button { width: 68px; }
   #map-board button img { width: 60px; }

tests/browser.mjs

@@ -1,6 +1,8 @@
 // Prova nel browser vero (Chromium headless con swiftshader): titolo, partita giocata con clic veri
 // fino alla fine, salvataggio e impaginazione su telefono. Schermate in $OUT (predefinito: /tmp/regolo-shots).
-// npm run browser
+// npm run browser: le tre parti (--parte=principale, minigiochi, telefoni) girano insieme come processi separati, ognuna
+// col suo server e il suo Chromium; la prova passa quasi tutto il tempo ad aspettare animazioni in tempo reale, e così le
+// attese si sovrappongono. Una parte sola: node tests/browser.mjs --parte=minigiochi (--media-only: solo multimedia).
 import { chromium } from 'playwright';
 import { staticServer } from './helpers.mjs';
 import { mkdirSync, readFileSync } from 'node:fs';
@@ -12,6 +14,22 @@ import { checkMultimedia } from './multimedia.browser.mjs';
 
 const OUT = process.env.OUT ?? '/tmp/regolo-shots';
 mkdirSync(OUT, { recursive: true });
+const PARTI = ['principale', 'minigiochi', 'telefoni'];
+const PARTE = process.argv.find(a => a.startsWith('--parte='))?.slice('--parte='.length);
+if (PARTE && !PARTI.includes(PARTE)) { console.error(`parte sconosciuta: ${PARTE} (${PARTI.join(', ')})`); process.exit(2); }
+if (!PARTE && !process.argv.includes('--media-only')) {
+    const { spawn } = await import('node:child_process');
+    const t0 = Date.now();
+    const esiti = await Promise.all(PARTI.map(parte => new Promise(resolve => {
+        const p = spawn(process.execPath, [process.argv[1], `--parte=${parte}`], { stdio: ['ignore', 'pipe', 'pipe'] });
+        let resto = '';
+        const riga = chunk => { const righe = (resto + chunk).split('\n'); resto = righe.pop(); for (const r of righe) console.log(`[${parte}] ${r}`); };
+        p.stdout.on('data', riga); p.stderr.on('data', riga);
+        p.on('close', code => { if (resto) console.log(`[${parte}] ${resto}`); resolve({ parte, code, s: Math.round((Date.now() - t0) / 1000) }); });
+    })));
+    for (const e of esiti) console.log(`${e.code === 0 ? 'OK  ' : 'FAIL'} ${e.parte} (${e.s} s)`);
+    process.exit(esiti.every(e => e.code === 0) ? 0 : 1);
+}
 const server = await staticServer(), PORT = server.port;
 const browser = await chromium.launch({ args: ['--autoplay-policy=no-user-gesture-required', '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'] });
 const errors = [];
@@ -19,7 +37,8 @@ const errors = [];
 async function open(viewport, query = '') {
     const page = await browser.newPage({ viewport, acceptDownloads: true });
     page.on('pageerror', e => errors.push(e.message));
-    page.on('console', m => m.type() === 'error' && errors.push(m.text()));
+    // ERR_NETWORK_CHANGED è il PC che cambia rete a metà prova (Docker che crea o toglie una rete): non è il gioco.
+    page.on('console', m => m.type() === 'error' && !m.text().includes('ERR_NETWORK_CHANGED') && errors.push(m.text()));
     for (let i = 0; i < 50; i++) {
         try { await page.goto(`http://127.0.0.1:${PORT}/${query}`); break; } catch { await page.waitForTimeout(100); }
     }
@@ -49,332 +68,8 @@ const hotspotCenter = async (page, id) => {
     return c;
 };
 
-try {
-    await checkMultimedia(browser, PORT, OUT, errors);
-    if (!process.argv.includes('--media-only')) {
-    const page = await open({ width: 1280, height: 860 });
-    // Il cartello d'apertura, poi da solo il titolo.
-    assert.match(await page.textContent('#splash'), /Manzolo\s*\(Poca\)\s*Art\s*Presents/);
-    assert.ok(await page.isHidden('#title'), 'il titolo aspetta la fine del cartello');
-    // Il gioco parte con un import() dinamico, che l'evento load della pagina non aspetta.
-    await page.waitForFunction(() => window.jingle, null, { timeout: 10000 });
-    assert.match(await page.evaluate(() => jingle.src), /assets\/audio\/cartello\.mp3\?v=\d+\.\d+\.\d+$/, 'la musichetta del cartello');
-    assert.equal(await page.evaluate(() => music.want), null, 'la musica del titolo aspetta il titolo');
-    await page.waitForTimeout(2800);
-    await page.screenshot({ path: `${OUT}/00-cartello.png` });
-    // Il titolo arriva sotto il cartello mentre sfuma: in nessun momento si vede la scena nuda.
-    await page.waitForSelector('#title:not([hidden])', { timeout: 8000 });
-    assert.ok(await page.isVisible('#splash'), 'il titolo compare quando il cartello è ancora sopra');
-    await page.waitForTimeout(350);
-    await page.screenshot({ path: `${OUT}/00b-dissolvenza.png` });
-    await page.waitForSelector('#splash', { state: 'hidden', timeout: 3000 });
-    // Senza un gesto il browser può bloccare la musichetta (succede online su un sito mai visto, non in locale): allora
-    // il cartello aspetta un tocco, con l'invito a toccare, e solo dopo parte coi suoi tempi.
-    {
-        const muto = await chromium.launch(), p = await muto.newPage();
-        await p.goto(`http://127.0.0.1:${PORT}/`);
-        await p.waitForTimeout(800);
-        if (await p.evaluate(() => document.getElementById('splash').classList.contains('wait'))) {
-            assert.ok(await p.isVisible('#splash .splash-hint'), 'l\'invito a toccare');
-            await p.waitForTimeout(5500);
-            assert.ok(await p.isHidden('#title'), 'il cartello aspetta il tocco');
-            await p.click('#splash');
-            assert.ok(await p.isHidden('#splash .splash-hint'));
-            await p.waitForSelector('#title:not([hidden])', { timeout: 8000 });
-            console.log('Cartello senza suono permesso: aspetta il tocco, poi parte.');
-        } else console.log('(questo Chromium lascia suonare senza gesto: il caso bloccato non si prova qui)');
-        await muto.close();
-    }
-    await page.screenshot({ path: `${OUT}/01-titolo.png` });
-    assert.match(await page.textContent('#title .version'), /^v\d+\.\d+\.\d+$/, 'la versione nell\'angolo del titolo');
-    // Col codice lento ad arrivare (rete vera) il cartello aspetta il titolo: non sfuma prima per conto suo.
-    {
-        const slow = await browser.newPage({ viewport: { width: 1280, height: 860 } });
-        // Misura al momento dell'apparizione: il polling di Playwright può arrivare dopo
-        // diversi fotogrammi su una macchina occupata, quando la dissolvenza è già in corso.
-        await slow.addInitScript(() => {
-            const observer = new MutationObserver(() => {
-                const title = document.getElementById('title'), splash = document.getElementById('splash');
-                if (title && !title.hidden && splash) {
-                    window.titleRevealOpacity = Number(getComputedStyle(splash).opacity);
-                    observer.disconnect();
-                }
-            });
-            observer.observe(document, { subtree: true, childList: true, attributes: true, attributeFilter: ['hidden'] });
-        });
-        await slow.route('**/src/main.js', async route => { await new Promise(r => setTimeout(r, 2000)); await route.continue(); });
-        await slow.goto(`http://127.0.0.1:${PORT}/`);
-        await slow.waitForSelector('#splash');
-        await slow.waitForTimeout(300);
-        if (await slow.evaluate(() => document.getElementById('splash').classList.contains('wait'))) await slow.click('#splash');
-        await slow.waitForSelector('#title:not([hidden])', { timeout: 12000 });
-        const opacity = await slow.evaluate(() => window.titleRevealOpacity);
-        assert.ok(opacity > 0.9, `il cartello era già sfumato (${opacity}) quando è comparso il titolo`);
-        await slow.close();
-    }
-    // I crediti dal titolo: si aprono, mostrano i nomi, Esc li chiude.
-    await page.click('#title .open-credits');
-    assert.match(await page.textContent('#credits'), /Ringraziamenti\s*Al Lele/, 'la dedica al Lele viene per prima');
-    assert.match(await page.textContent('#credits'), /Baldoria \(Yuri Baldi\)/);
-    assert.match(await page.textContent('#credits'), /Francesco Bacci/);
-    // I nomi col ritratto: si tocca il nome, compare il volto; un altro tocco lo chiude.
-    await page.click('#credits .credit-face >> text=Mariano');
-    assert.ok(await page.isVisible('#face img'));
-    await page.waitForFunction(() => document.querySelector('#face img').naturalWidth > 0, null, { timeout: 5000 });
-    await page.screenshot({ path: `${OUT}/01d-ritratto.png` });
-    await page.click('#face');
-    assert.ok(await page.isHidden('#face'));
-    // Il carosello: tutte le immagini (due giri), scorre da solo, si ferma sotto il mouse, le frecce lo spingono di una
-    // foto, un tocco su una foto la mostra grande col nome del posto.
-    {
-        const track = page.locator('#credits-reel .track');
-        assert.equal(await track.locator('img').count(), reelPictures(story).length * 2, 'ogni sfondo e ogni ritratto, due giri');
-        await page.mouse.move(5, 5);
-        const x0 = await track.evaluate(t => t.scrollLeft);
-        await page.waitForTimeout(600);
-        const x1 = await track.evaluate(t => t.scrollLeft);
-        assert.ok(x1 > x0, `il carosello scorre da solo (${x0} → ${x1})`);
-        await track.hover({ position: { x: 20, y: 20 } });
-        const x2 = await track.evaluate(t => t.scrollLeft);
-        await page.waitForTimeout(500);
-        assert.equal(await track.evaluate(t => t.scrollLeft), x2, 'sotto il mouse si ferma');
-        await page.click('#credits-reel .arrow.next');
-        await page.waitForTimeout(800);
-        const x3 = await track.evaluate(t => t.scrollLeft);
-        assert.ok(x3 - x2 > 150, `la freccia spinge di una foto (${x2} → ${x3})`);
-        const third = track.locator('img').nth(2);
-        const name = await third.getAttribute('alt');
-        await third.click();
-        assert.ok(await page.isVisible('#face img.scene'), 'la foto si vede grande');
-        assert.equal(await page.textContent('#face figcaption'), name);
-        await page.waitForFunction(() => document.querySelector('#face img').naturalWidth > 0, null, { timeout: 5000 });
-        await page.screenshot({ path: `${OUT}/01e-carosello-zoom.png` });
-        await page.keyboard.press('Escape');
-        assert.ok(await page.isHidden('#face'), 'Esc chiude la foto grande, non i crediti');
-        assert.ok(await page.isVisible('#credits'));
-    }
-    const onTop = await page.evaluate(() => { const r = document.getElementById('close-credits').getBoundingClientRect();
-        return document.elementFromPoint(r.x + r.width / 2, r.y + r.height / 2)?.id === 'close-credits'; });
-    assert.ok(onTop, 'i crediti stanno sopra il titolo, non dietro');
-    await page.screenshot({ path: `${OUT}/01c-crediti.png` });
-    // L'elenco può scorrere; la dedica e il pulsante Chiudi devono restare dentro lo schermo.
-    const fitsCredits = await page.evaluate(() => { const c = document.getElementById('credits').getBoundingClientRect(), b = document.getElementById('close-credits').getBoundingClientRect(); return b.bottom <= c.bottom && b.top >= c.top; });
-    assert.ok(fitsCredits, 'il pulsante Chiudi dei crediti è in vista');
-    await page.keyboard.press('Escape');
-    assert.ok(await page.isHidden('#credits'), 'Esc chiude i crediti');
-    await page.click('#new-game');
-    // Il rione: quattro scelte; la Pieve cambia la riga dell'introduzione e resta nella partita.
-    await page.waitForSelector('#rione:not([hidden])');
-    assert.equal(await page.locator('#rione-buttons button').count(), 4);
-    await page.screenshot({ path: `${OUT}/01a-rione.png` });
-    assert.equal(await page.locator('#rione-buttons button:disabled').count(), 3, 'per ora gli altri tre rioni sono chiusi');
-    await page.click('#rione [data-rione="campomigliaio"]');
-    // L'introduzione: una riga per clic, poi comincia la partita.
-    await page.waitForSelector('#intro:not([hidden])');
-    for (let i = 0; i < 2; i++) await page.click('#intro', { position: { x: 40, y: 40 } });
-    assert.match(await page.textContent('#intro-text'), /Campomigliaio, i blu/, 'la riga del rione scelto');
-    await page.screenshot({ path: `${OUT}/01b-intro.png` });
-    for (let i = 0; i < 10 && await page.isVisible('#intro'); i++) await page.click('#intro', { position: { x: 40, y: 40 } });
-    assert.ok(await page.isHidden('#intro'), 'l\'introduzione non finisce');
-    await page.waitForFunction(() => game.speech);
-    // La prima battuta ha la sua voce, e sotto la voce la musica si abbassa.
-    await page.waitForFunction(() => voices.playing, null, { timeout: 5000 });
-    assert.match(await page.evaluate(() => voices.audio.src), /assets\/voices\/andrea-[0-9a-f]+\.mp3\?v=\d+\.\d+\.\d+$/);
-    await page.waitForFunction(() => music.duck === 0.45, null, { timeout: 2000 });
-    await page.screenshot({ path: `${OUT}/02-inizio.png` });
-    assert.ok(await page.evaluate(() => game.state.flags['rione:campomigliaio']), 'il rione resta nella partita');
-    const fits = async p => p.evaluate(() => document.querySelector('#panel').getBoundingClientRect().bottom <= innerHeight);
-    assert.ok(await fits(page), 'verbi e inventario fuori dallo schermo');
-    await settle(page);
-
-    // Doppio clic su un punto della scena: Andrea ci va di corsa.
-    const r = await page.locator('#scene').boundingBox();
-    await page.mouse.dblclick(r.x + 300 / 640 * r.width, r.y + 330 / 360 * r.height);
-    assert.ok(await page.evaluate(() => game.hurry), 'il doppio clic fa correre');
-    await settle(page);
-    // «?» mostra per qualche secondo cosa si può toccare.
-    await page.click('#spots-button');
-    await page.screenshot({ path: `${OUT}/02c-punti.png` });
-    // Inventario pieno (16 oggetti di prova): resta alto quanto i verbi, dentro lo schermo, si scorre e mostra l'ultimo preso.
-    await page.evaluate(() => {
-        const items = game.story.items, kinds = ['chiave_oratorio', 'libro', 'squama'];
-        for (let i = 1; i <= 16; i++) { items['prova' + i] = { name: 'prova ' + i, icon: items[kinds[i % 3]].icon }; game.state.inventory.push('prova' + i); }
-    });
-    await page.waitForTimeout(150);
-    const inv = await page.evaluate(() => { const e = document.getElementById('inventory'), r = e.getBoundingClientRect(), last = e.lastElementChild.getBoundingClientRect();
-        return { inside: r.bottom <= innerHeight, scrolls: e.scrollHeight > e.clientHeight, lastVisible: last.bottom <= r.bottom + 1 && last.top >= r.top - 1 }; });
-    assert.deepEqual(inv, { inside: true, scrolls: true, lastVisible: true }, 'inventario pieno');
-    await page.screenshot({ path: `${OUT}/02d-inventario-pieno.png` });
-    await page.evaluate(() => { game.state.inventory = game.state.inventory.filter(i => !i.startsWith('prova')); for (let i = 1; i <= 16; i++) delete game.story.items['prova' + i]; });
-    // Pausa: Esc o il pulsante fermano il gioco; Riprendi torna dov'eri; il titolo offre «Continua».
-    await page.keyboard.press('Escape');
-    await page.waitForSelector('#pause:not([hidden])');
-    await page.screenshot({ path: `${OUT}/02b-pausa.png` });
-    // Salva su file: si scarica la partita; dal titolo «Carica» la riapre anche senza il salvataggio del browser.
-    const [download] = await Promise.all([page.waitForEvent('download'), page.click('#save-file')]);
-    assert.match(download.suggestedFilename(), /^regolo-\d{4}-\d\d-\d\d-\d{4}\.json$/);
-    const savedFile = `${OUT}/partita.json`;
-    await download.saveAs(savedFile);
-    const before = await page.evaluate(() => game.snapshot());
-    await page.click('#to-title');
-    await page.evaluate(() => localStorage.removeItem('leggenda-regolo-save'));
-    await page.setInputFiles('#load-file', { name: 'altro.json', mimeType: 'application/json', buffer: Buffer.from('{"ciao":1}') });
-    await page.waitForSelector('#load-error:not([hidden])');
-    assert.ok(await page.isVisible('#title'), 'un file sbagliato lascia il titolo dov\'è');
-    // Una scena che non esiste: rifiutato, e il salvataggio del browser resta com'era.
-    await page.evaluate(() => localStorage.setItem('leggenda-regolo-save', '{"scene":"piazza","resta":true}'));
-    const lost = JSON.parse(readFileSync(savedFile, 'utf8'));
-    lost.state.scene = 'luna';
-    await page.setInputFiles('#load-file', { name: 'luna.json', mimeType: 'application/json', buffer: Buffer.from(JSON.stringify(lost)) });
-    await page.waitForFunction(() => /non torna/.test(document.getElementById('load-error').textContent));
-    assert.ok(await page.isVisible('#title'));
-    assert.equal(await page.evaluate(() => JSON.parse(localStorage.getItem('leggenda-regolo-save')).resta), true, 'il salvataggio del browser non è toccato');
-    await page.evaluate(() => localStorage.removeItem('leggenda-regolo-save'));
-    await page.setInputFiles('#load-file', savedFile);
-    await page.waitForSelector('#title', { state: 'hidden' });
-    assert.deepEqual(await page.evaluate(() => game.snapshot()), before, 'la partita caricata è quella salvata');
-    assert.ok(await page.evaluate(() => !!localStorage.getItem('leggenda-regolo-save')), 'e diventa quella di «Continua»');
-    await page.keyboard.press('Escape');
-    await page.waitForSelector('#pause:not([hidden])');
-    await page.click('#resume');
-    assert.ok(await page.isHidden('#pause'));
-    await page.click('#pause-button');
-    await page.click('#to-title');
-    await page.waitForSelector('#continue:not([hidden])');
-    await page.click('#continue');
-    await settle(page);
-    // Musica: dopo il primo clic suona il brano del paese; muto e volume si ricordano.
-    // Il brano cambia al fotogramma dopo «Continua»: si aspetta quello, senza indovinare i tempi.
-    const playing = await page.waitForFunction(() => music.current?.src.endsWith('paese.mp3'), null, { timeout: 3000 }).then(() => true, () => false);
-    assert.ok(playing, 'musica del paese: ' + await page.evaluate(() => music.current?.src));
-    await page.click('#mute');
-    await page.locator('#volume').fill('30');
-    await page.locator('#voice-volume').fill('70');
-    assert.deepEqual(await page.evaluate(() => JSON.parse(localStorage.getItem('leggenda-regolo-audio'))), { volume: 0.3, muted: false, voices: 0.7, effects: 0.45 });
-    assert.equal(await page.evaluate(() => voices.volume), 0.7);
-    // Sul telefono si passa a un'altra app: la pagina diventa nascosta, la musica si ferma subito e la partita va in
-    // pausa; tornando la musica riparte solo con Riprendi (la pausa la tiene ferma).
-    const hide = hidden => page.evaluate(h => { Object.defineProperty(document, 'hidden', { value: h, configurable: true }); document.dispatchEvent(new Event('visibilitychange')); }, hidden);
-    await hide(true);
-    assert.equal(await page.evaluate(() => ambience.nodes.size), 0, 'nascosta la pagina, gli effetti si fermano subito');
-    assert.ok(await page.evaluate(() => music.current.audio.paused), 'nascosta la pagina, la musica è ferma');
-    assert.ok(await page.isVisible('#pause'), 'e la partita è in pausa');
-    await hide(false);
-    await page.click('#resume');
-    await page.waitForFunction(() => !music.current.audio.paused, null, { timeout: 5000 });
-
-    for (const [verb, target, item] of solution) {
-        if (verb === 'choose') {
-            await page.locator('#choices li', { hasText: target }).click();
-        } else {
-            const smart = await page.evaluate(([v, t]) => game.defaultVerb(t) === v, [verb, target]);
-            if (item) {
-                await page.click(`#verbs [data-verb="${verb}"]`);
-                await page.click(`#inventory [data-item="${item}"]`);
-            } else if (!smart) await page.click(`#verbs [data-verb="${verb}"]`);
-            // Un oggetto dell'inventario su un altro (cedrata col ghiacciolo) si clicca nell'inventario, non nella scena.
-            if (await page.evaluate(t => !!game.story.items[t], target)) await page.click(`#inventory [data-item="${target}"]`);
-            else await clickScene(page, await hotspotCenter(page, target));
-        }
-        await page.waitForTimeout(80);
-        if (verb === 'talk') await page.screenshot({ path: `${OUT}/03-dialogo.png` });
-        // La torcia nella fessura: il palio illuminato e i due occhi gialli, prima che spariscano.
-        if (target === 'fessura' && item) {
-            await page.waitForFunction(() => game.closeup?.id === 'fessura', null, { timeout: 30000 });
-            for (let i = 0; i < 3; i++) {
-                const at = await page.evaluate(i => game.story.closeups.fessura.targets[i].at, i);
-                const box = await page.locator('#scene').boundingBox();
-                await page.mouse.move(box.x + at[0] / 640 * box.width, box.y + at[1] / 360 * box.height);
-                await page.waitForFunction(() => game.closeup?.step === 'reveal');
-                await page.screenshot({ path: `${OUT}/05b-fessura-${i}.png` });
-                for (let n = 0; n < 200; n++) {
-                    if (await page.evaluate(i => game.closeup.found > i, i)) break;
-                    if (await page.evaluate(() => !!game.speech)) await page.keyboard.press('Space');
-                    await page.waitForTimeout(30);
-                }
-                assert.equal(await page.evaluate(() => game.closeup.found), i + 1);
-            }
-            await page.click('#closeup-close');
-        }
-        await settle(page);
-        if (target === 'cosa_luccicante') await page.screenshot({ path: `${OUT}/04-squama.png` });
-        if (target === 'su_fortezza') await page.screenshot({ path: `${OUT}/05-fortezza.png` });
-    }
-    await page.waitForSelector('#ending:not([hidden])');
-    await page.screenshot({ path: `${OUT}/06-fine.png` });
-    await page.click('#ending .open-credits');
-    assert.ok(await page.isVisible('#credits'), 'crediti anche dalla fine');
-    assert.ok(await page.evaluate(() => { const r = document.getElementById('close-credits').getBoundingClientRect();
-        return document.elementFromPoint(r.x + r.width / 2, r.y + r.height / 2)?.id === 'close-credits'; }), 'i crediti stanno sopra la fine');
-    await page.click('#close-credits');
-    assert.ok(await page.isHidden('#credits'));
-    const saved = await page.evaluate(() => JSON.parse(localStorage.getItem('leggenda-regolo-save')));
-    assert.ok(saved.ended && saved.inventory.includes('squama'), 'salvataggio finale');
-
-    // Una partita a metà riprende da dove era rimasta.
-    await page.click('#restart');
-    await settle(page);
-    for (const [, exit] of route('piazza', 'trebbio')) {
-        await clickScene(page, await hotspotCenter(page, exit));
-        await settle(page);
-    }
-    await page.click('#verbs [data-verb="talk"]');
-    await clickScene(page, await hotspotCenter(page, 'torre'));
-    await page.locator('#choices li', { hasText: 'bloccato' }).click();
-    await page.waitForFunction(() => game.speech?.who === 'castello');
-    await page.waitForTimeout(100);
-    await page.screenshot({ path: `${OUT}/07-trebbio.png` });
-    await settle(page);
-    await page.locator('#choices li', { hasText: 'pace' }).click();
-    await settle(page);
-    await page.reload();
-    await page.waitForSelector('#continue:not([hidden])');
-    await page.click('#continue');
-    assert.equal(await page.evaluate(() => game.state.scene), 'trebbio');
-    await settle(page);
-    // Il taccuino (N): la tappa di adesso in evidenza, Esc lo chiude.
-    await page.keyboard.press('n');
-    assert.ok(await page.isVisible('#notebook'));
-    assert.ok((await page.textContent('#notebook-list li.now')).length > 10, 'c\'è l\'obiettivo di adesso');
-    await page.screenshot({ path: `${OUT}/07a-taccuino.png` });
-    await page.keyboard.press('Escape');
-    assert.ok(await page.isHidden('#notebook'));
-    // La mappa: dal Trebbio alla Piazza con due clic; i posti mai visti (la Pieve) non ci sono.
-    await page.click('#map-button');
-    assert.equal(await page.locator('#map-board button[data-scene="pieve"]').count(), 0, 'la Pieve non è ancora vista');
-    assert.ok(await page.isVisible('#map-board button.here[data-scene="trebbio"]'));
-    await page.screenshot({ path: `${OUT}/07b-mappa.png` });
-    // La ricerca: scrivendo restano solo i posti giusti; una «p» nella casella non chiude la mappa; Invio ci va.
-    await page.fill('#map-search', 'xyz');
-    assert.ok(await page.isVisible('#map-none'), 'nessun posto: lo dice');
-    await page.fill('#map-search', '');
-    await page.click('#map-search');
-    await page.keyboard.type('piazza col'); // «piaz» da solo trova anche la Piazzetta Cambray Digny
-    assert.ok(await page.isVisible('#map'), 'scrivere «p» nella ricerca non chiude la mappa');
-    assert.ok(await page.isHidden('#map-none'));
-    const shown = await page.locator('#map-board button:visible').evaluateAll(bs => bs.map(b => b.dataset.scene));
-    assert.deepEqual(shown, ['piazza']);
-    await page.screenshot({ path: `${OUT}/07c-mappa-ricerca.png` });
-    await page.keyboard.press('Enter');
-    assert.ok(await page.isHidden('#map'));
-    assert.equal(await page.evaluate(() => game.state.scene), 'piazza');
-    // Con tutti i posti visti e la finestra piccola la mappa si scorre: filtrando da in fondo, i posti trovati si vedono
-    // (prima la mappa restava lunga quanto quella intera, scorsa su un fondo vuoto).
-    await page.setViewportSize({ width: 560, height: 340 });
-    await page.evaluate(() => { for (const id of Object.keys(game.story.scenes)) game.state.flags['visto:' + id] = true; });
-    await page.click('#map-button');
-    assert.ok(await page.evaluate(() => { const s = document.getElementById('map-scroll'); s.scrollTop = s.scrollHeight; return s.scrollTop > 0; }), 'la mappa piena si scorre');
-    await page.fill('#map-search', 'campo');
-    const found = await page.evaluate(() => {
-        const s = document.getElementById('map-scroll'), r = s.getBoundingClientRect();
-        const c = [...document.querySelectorAll('#map-board button')].find(b => !b.hidden && !b.parentElement.hidden).getBoundingClientRect();
-        return { inside: c.top >= r.top && c.bottom <= r.bottom, scrollTop: s.scrollTop, h: s.scrollHeight, ch: s.clientHeight, top: c.top - r.top, q: document.getElementById('map-search').value };
-    });
-    assert.ok(found.inside, `filtrando, il primo posto trovato non si vede: ${JSON.stringify(found)}`);
-    await page.screenshot({ path: `${OUT}/07d-mappa-ricerca-piccola.png` });
-    await page.click('#close-map');
-    await page.setViewportSize({ width: 1280, height: 860 });
-
+// Le parti che aprono una pagina propria (col suo salvataggio), ognuna nel suo processo (vedi in cima).
+async function minigiochi() {
     // Il libro dell'oratorio: preso, il primo piano; si sfoglia coi clic veri, «FINE» senza che nessuno lo dica,
     // Esc chiude; dall'inventario «Apri» lo riapre e il pulsante Chiudi lo chiude. Intanto la scena dietro non risponde.
     {
@@ -551,10 +246,36 @@ try {
         await b.waitForFunction(() => game.speech?.text.startsWith('Lasci a metà?'), null, { timeout: 5000 });
         await b.close();
     }
+}
 
+async function telefoni() {
+    // La finestra di Andrea (1040×590: Firefox con le sue barre su un portatile): la scena era larga 604 px con 100 px
+    // vuoti sotto, ora prende l'altezza; i verbi stanno nei pulsanti; un dialogo a quattro risposte e uno a cinque
+    // non muovono la scena e stanno nel pannello.
+    {
+        const win = await open({ width: 1040, height: 590 });
+        await win.click('#splash'); await win.click('#new-game'); await win.click('#rione [data-rione="campomigliaio"]'); await win.click('#skip-intro');
+        await settle(win);
+        const box = async () => { const r = await win.locator('#stage').boundingBox(); return [r.x, r.y, r.width, r.height].map(Math.round); };
+        const b0 = await box();
+        assert.ok(b0[2] >= 820 && b0[1] >= 0, `a 1040×590 la scena è larga ${b0[2]} px e comincia a ${b0[1]}`);
+        assert.ok(await win.evaluate(() => document.documentElement.scrollHeight <= innerHeight), 'la pagina scorre a 1040×590');
+        assert.ok(await win.evaluate(() => [...document.querySelectorAll('#verbs button')].every(b => b.scrollWidth <= b.clientWidth + 1 && b.scrollHeight <= b.clientHeight + 1)), 'verbi tagliati a 1040×590');
+        for (const id of ['giocatore_carte', 'arcu']) {
+            await win.evaluate(id => { game.dialogue = { id, node: 'start' }; }, id);
+            await win.waitForFunction(() => !document.getElementById('choices').hidden);
+            const n = await win.evaluate(() => game.options().length);
+            assert.deepEqual(await box(), b0, `la scena si muove col dialogo ${id}`);
+            assert.ok(await win.evaluate(() => { const c = document.getElementById('choices'); return c.scrollHeight <= c.clientHeight + 1; }), `le ${n} risposte di ${id} non stanno nel pannello`);
+            if (id === 'arcu') await win.screenshot({ path: `${OUT}/11-finestra-1040-dialogo.png` });
+            await win.evaluate(() => { game.dialogue = null; });
+        }
+        await win.screenshot({ path: `${OUT}/11-finestra-1040.png` });
+        await win.close();
+    }
     const phone = await open({ width: 390, height: 844 });
     await phone.click('#splash'); // un clic salta il cartello
-    assert.ok(await phone.isVisible('#title'), 'il clic sul cartello porta al titolo');
+    assert.ok(await phone.waitForSelector('#title:not([hidden])', { timeout: 5000 }).then(() => true, () => false), 'il clic sul cartello porta al titolo');
     await phone.click('#new-game');
     await phone.click('#rione [data-rione="campomigliaio"]');
     await phone.click('#skip-intro');
@@ -619,9 +340,345 @@ try {
     await dbg.waitForTimeout(200);
     assert.deepEqual(await dbg.evaluate(() => [game.state.x, game.state.y]), start, 'Maiusc+clic non muove Andrea');
     await dbg.screenshot({ path: `${OUT}/10-debug.png` });
+}
+
+try {
+    if (process.argv.includes('--media-only')) await checkMultimedia(browser, PORT, OUT, errors);
+    else if (PARTE === 'minigiochi') { await minigiochi(); console.log('Browser OK: libro, bocce, tiri, pesca, biliardo.'); }
+    else if (PARTE === 'telefoni') { await checkMultimedia(browser, PORT, OUT, errors); await telefoni(); console.log('Browser OK: telefoni e debug.'); }
+    else {
+    const page = await open({ width: 1280, height: 860 });
+    // Il cartello d'apertura, poi da solo il titolo.
+    assert.match(await page.textContent('#splash'), /Manzolo\s*\(Poca\)\s*Art\s*Presents/);
+    assert.ok(await page.isHidden('#title'), 'il titolo aspetta la fine del cartello');
+    // Il gioco parte con un import() dinamico, che l'evento load della pagina non aspetta.
+    await page.waitForFunction(() => window.jingle, null, { timeout: 10000 });
+    assert.match(await page.evaluate(() => jingle.src), /assets\/audio\/cartello\.mp3\?v=\d+\.\d+\.\d+$/, 'la musichetta del cartello');
+    assert.equal(await page.evaluate(() => music.want), null, 'la musica del titolo aspetta il titolo');
+    await page.waitForTimeout(2800);
+    await page.screenshot({ path: `${OUT}/00-cartello.png` });
+    // Il titolo arriva sotto il cartello mentre sfuma: in nessun momento si vede la scena nuda.
+    await page.waitForSelector('#title:not([hidden])', { timeout: 8000 });
+    assert.ok(await page.isVisible('#splash'), 'il titolo compare quando il cartello è ancora sopra');
+    await page.waitForTimeout(350);
+    await page.screenshot({ path: `${OUT}/00b-dissolvenza.png` });
+    await page.waitForSelector('#splash', { state: 'hidden', timeout: 3000 });
+    // Senza un gesto il browser può bloccare la musichetta (succede online su un sito mai visto, non in locale): allora
+    // il cartello aspetta un tocco, con l'invito a toccare, e solo dopo parte coi suoi tempi.
+    {
+        const muto = await chromium.launch(), p = await muto.newPage();
+        await p.goto(`http://127.0.0.1:${PORT}/`);
+        await p.waitForTimeout(800);
+        if (await p.evaluate(() => document.getElementById('splash').classList.contains('wait'))) {
+            assert.ok(await p.isVisible('#splash .splash-hint'), 'l\'invito a toccare');
+            await p.waitForTimeout(5500);
+            assert.ok(await p.isHidden('#title'), 'il cartello aspetta il tocco');
+            await p.click('#splash');
+            assert.ok(await p.isHidden('#splash .splash-hint'));
+            await p.waitForSelector('#title:not([hidden])', { timeout: 8000 });
+            console.log('Cartello senza suono permesso: aspetta il tocco, poi parte.');
+        } else console.log('(questo Chromium lascia suonare senza gesto: il caso bloccato non si prova qui)');
+        await muto.close();
+    }
+    await page.screenshot({ path: `${OUT}/01-titolo.png` });
+    assert.match(await page.textContent('#title .version'), /^v\d+\.\d+\.\d+$/, 'la versione nell\'angolo del titolo');
+    // Col codice lento ad arrivare (rete vera) il cartello aspetta il titolo: non sfuma prima per conto suo.
+    {
+        const slow = await browser.newPage({ viewport: { width: 1280, height: 860 } });
+        // Misura al momento dell'apparizione: il polling di Playwright può arrivare dopo
+        // diversi fotogrammi su una macchina occupata, quando la dissolvenza è già in corso.
+        await slow.addInitScript(() => {
+            const observer = new MutationObserver(() => {
+                const title = document.getElementById('title'), splash = document.getElementById('splash');
+                if (title && !title.hidden && splash) {
+                    window.titleRevealOpacity = Number(getComputedStyle(splash).opacity);
+                    observer.disconnect();
+                }
+            });
+            observer.observe(document, { subtree: true, childList: true, attributes: true, attributeFilter: ['hidden'] });
+        });
+        await slow.route('**/src/main.js', async route => { await new Promise(r => setTimeout(r, 2000)); await route.continue(); });
+        await slow.goto(`http://127.0.0.1:${PORT}/`);
+        await slow.waitForSelector('#splash');
+        await slow.waitForTimeout(300);
+        if (await slow.evaluate(() => document.getElementById('splash').classList.contains('wait'))) await slow.click('#splash');
+        await slow.waitForSelector('#title:not([hidden])', { timeout: 12000 });
+        const opacity = await slow.evaluate(() => window.titleRevealOpacity);
+        assert.ok(opacity > 0.9, `il cartello era già sfumato (${opacity}) quando è comparso il titolo`);
+        await slow.close();
+    }
+    // I crediti dal titolo: si aprono, mostrano i nomi, Esc li chiude.
+    await page.click('#title .open-credits');
+    assert.match(await page.textContent('#credits'), /Ringraziamenti\s*Al Lele/, 'la dedica al Lele viene per prima');
+    assert.match(await page.textContent('#credits'), /Baldoria \(Yuri Baldi\)/);
+    assert.match(await page.textContent('#credits'), /Francesco Bacci/);
+    // I nomi col ritratto: si tocca il nome, compare il volto; un altro tocco lo chiude.
+    await page.click('#credits .credit-face >> text=Mariano');
+    assert.ok(await page.isVisible('#face img'));
+    await page.waitForFunction(() => document.querySelector('#face img').naturalWidth > 0, null, { timeout: 5000 });
+    await page.screenshot({ path: `${OUT}/01d-ritratto.png` });
+    await page.click('#face');
+    assert.ok(await page.isHidden('#face'));
+    // Il carosello: tutte le immagini (due giri), scorre da solo, si ferma sotto il mouse, le frecce lo spingono di una
+    // foto, un tocco su una foto la mostra grande col nome del posto.
+    {
+        const track = page.locator('#credits-reel .track');
+        assert.equal(await track.locator('img').count(), reelPictures(story).length * 2, 'ogni sfondo e ogni ritratto, due giri');
+        await page.mouse.move(5, 5);
+        const x0 = await track.evaluate(t => t.scrollLeft);
+        await page.waitForTimeout(600);
+        const x1 = await track.evaluate(t => t.scrollLeft);
+        assert.ok(x1 > x0, `il carosello scorre da solo (${x0} → ${x1})`);
+        await track.hover({ position: { x: 20, y: 20 } });
+        const x2 = await track.evaluate(t => t.scrollLeft);
+        await page.waitForTimeout(500);
+        assert.equal(await track.evaluate(t => t.scrollLeft), x2, 'sotto il mouse si ferma');
+        await page.click('#credits-reel .arrow.next');
+        await page.waitForTimeout(800);
+        const x3 = await track.evaluate(t => t.scrollLeft);
+        assert.ok(x3 - x2 > 150, `la freccia spinge di una foto (${x2} → ${x3})`);
+        const third = track.locator('img').nth(2);
+        const name = await third.getAttribute('alt');
+        await third.click();
+        assert.ok(await page.isVisible('#face img.scene'), 'la foto si vede grande');
+        assert.equal(await page.textContent('#face figcaption'), name);
+        await page.waitForFunction(() => document.querySelector('#face img').naturalWidth > 0, null, { timeout: 5000 });
+        await page.screenshot({ path: `${OUT}/01e-carosello-zoom.png` });
+        await page.keyboard.press('Escape');
+        assert.ok(await page.isHidden('#face'), 'Esc chiude la foto grande, non i crediti');
+        assert.ok(await page.isVisible('#credits'));
+    }
+    const onTop = await page.evaluate(() => { const r = document.getElementById('close-credits').getBoundingClientRect();
+        return document.elementFromPoint(r.x + r.width / 2, r.y + r.height / 2)?.id === 'close-credits'; });
+    assert.ok(onTop, 'i crediti stanno sopra il titolo, non dietro');
+    await page.screenshot({ path: `${OUT}/01c-crediti.png` });
+    // L'elenco può scorrere; la dedica e il pulsante Chiudi devono restare dentro lo schermo.
+    const fitsCredits = await page.evaluate(() => { const c = document.getElementById('credits').getBoundingClientRect(), b = document.getElementById('close-credits').getBoundingClientRect(); return b.bottom <= c.bottom && b.top >= c.top; });
+    assert.ok(fitsCredits, 'il pulsante Chiudi dei crediti è in vista');
+    await page.keyboard.press('Escape');
+    assert.ok(await page.isHidden('#credits'), 'Esc chiude i crediti');
+    await page.click('#new-game');
+    // Il rione: quattro scelte; la Pieve cambia la riga dell'introduzione e resta nella partita.
+    await page.waitForSelector('#rione:not([hidden])');
+    assert.equal(await page.locator('#rione-buttons button').count(), 4);
+    await page.screenshot({ path: `${OUT}/01a-rione.png` });
+    assert.equal(await page.locator('#rione-buttons button:disabled').count(), 3, 'per ora gli altri tre rioni sono chiusi');
+    await page.click('#rione [data-rione="campomigliaio"]');
+    // L'introduzione: una riga per clic, poi comincia la partita.
+    await page.waitForSelector('#intro:not([hidden])');
+    for (let i = 0; i < 2; i++) await page.click('#intro', { position: { x: 40, y: 40 } });
+    assert.match(await page.textContent('#intro-text'), /Campomigliaio, i blu/, 'la riga del rione scelto');
+    await page.screenshot({ path: `${OUT}/01b-intro.png` });
+    for (let i = 0; i < 10 && await page.isVisible('#intro'); i++) await page.click('#intro', { position: { x: 40, y: 40 } });
+    assert.ok(await page.isHidden('#intro'), 'l\'introduzione non finisce');
+    await page.waitForFunction(() => game.speech);
+    // La prima battuta ha la sua voce, e sotto la voce la musica si abbassa.
+    await page.waitForFunction(() => voices.playing, null, { timeout: 5000 });
+    assert.match(await page.evaluate(() => voices.audio.src), /assets\/voices\/andrea-[0-9a-f]+\.mp3\?v=\d+\.\d+\.\d+$/);
+    await page.waitForFunction(() => music.duck === 0.45, null, { timeout: 2000 });
+    await page.screenshot({ path: `${OUT}/02-inizio.png` });
+    assert.ok(await page.evaluate(() => game.state.flags['rione:campomigliaio']), 'il rione resta nella partita');
+    const fits = async p => p.evaluate(() => document.querySelector('#panel').getBoundingClientRect().bottom <= innerHeight);
+    assert.ok(await fits(page), 'verbi e inventario fuori dallo schermo');
+    await settle(page);
+
+    // Doppio clic su un punto della scena: Andrea ci va di corsa.
+    const r = await page.locator('#scene').boundingBox();
+    await page.mouse.dblclick(r.x + 300 / 640 * r.width, r.y + 330 / 360 * r.height);
+    assert.ok(await page.evaluate(() => game.hurry), 'il doppio clic fa correre');
+    await settle(page);
+    // «?» mostra per qualche secondo cosa si può toccare.
+    await page.click('#spots-button');
+    await page.screenshot({ path: `${OUT}/02c-punti.png` });
+    // Inventario pieno (16 oggetti di prova): resta alto quanto i verbi, dentro lo schermo, si scorre e mostra l'ultimo preso.
+    await page.evaluate(() => {
+        const items = game.story.items, kinds = ['chiave_oratorio', 'libro', 'squama'];
+        for (let i = 1; i <= 16; i++) { items['prova' + i] = { name: 'prova ' + i, icon: items[kinds[i % 3]].icon }; game.state.inventory.push('prova' + i); }
+    });
+    await page.waitForTimeout(150);
+    const inv = await page.evaluate(() => { const e = document.getElementById('inventory'), r = e.getBoundingClientRect(), last = e.lastElementChild.getBoundingClientRect();
+        return { inside: r.bottom <= innerHeight, scrolls: e.scrollHeight > e.clientHeight, lastVisible: last.bottom <= r.bottom + 1 && last.top >= r.top - 1 }; });
+    assert.deepEqual(inv, { inside: true, scrolls: true, lastVisible: true }, 'inventario pieno');
+    await page.screenshot({ path: `${OUT}/02d-inventario-pieno.png` });
+    await page.evaluate(() => { game.state.inventory = game.state.inventory.filter(i => !i.startsWith('prova')); for (let i = 1; i <= 16; i++) delete game.story.items['prova' + i]; });
+    // Il gioco prende la finestra: a 1280×860 la scena non si ferma più ai 1084 px di una riserva fissa di 250 px sotto,
+    // la pagina non scorre e i verbi stanno interi nei pulsanti (la finestra di Andrea, 1040×590, è provata più sotto).
+    const stage0 = await page.locator('#stage').boundingBox();
+    assert.ok(stage0.width >= 1200, `a 1280×860 la scena è larga ${stage0.width} px`);
+    assert.ok(await page.evaluate(() => document.documentElement.scrollHeight <= innerHeight), 'la pagina scorre in verticale a 1280×860');
+    assert.ok(await page.evaluate(() => [...document.querySelectorAll('#verbs button')].every(b => b.scrollWidth <= b.clientWidth + 1 && b.scrollHeight <= b.clientHeight + 1)), 'verbi tagliati a 1280×860');
+    // Pausa: Esc o il pulsante fermano il gioco; Riprendi torna dov'eri; il titolo offre «Continua».
+    await page.keyboard.press('Escape');
+    await page.waitForSelector('#pause:not([hidden])');
+    await page.screenshot({ path: `${OUT}/02b-pausa.png` });
+    assert.equal(await page.evaluate(() => document.getElementById('fullscreen').hidden), await page.evaluate(() => !document.fullscreenEnabled), 'il pulsante Schermo intero c\'è se il browser lo permette');
+    // Salva su file: si scarica la partita; dal titolo «Carica» la riapre anche senza il salvataggio del browser.
+    const [download] = await Promise.all([page.waitForEvent('download'), page.click('#save-file')]);
+    assert.match(download.suggestedFilename(), /^regolo-\d{4}-\d\d-\d\d-\d{4}\.json$/);
+    const savedFile = `${OUT}/partita.json`;
+    await download.saveAs(savedFile);
+    const before = await page.evaluate(() => game.snapshot());
+    await page.click('#to-title');
+    await page.evaluate(() => localStorage.removeItem('leggenda-regolo-save'));
+    await page.setInputFiles('#load-file', { name: 'altro.json', mimeType: 'application/json', buffer: Buffer.from('{"ciao":1}') });
+    await page.waitForSelector('#load-error:not([hidden])');
+    assert.ok(await page.isVisible('#title'), 'un file sbagliato lascia il titolo dov\'è');
+    // Una scena che non esiste: rifiutato, e il salvataggio del browser resta com'era.
+    await page.evaluate(() => localStorage.setItem('leggenda-regolo-save', '{"scene":"piazza","resta":true}'));
+    const lost = JSON.parse(readFileSync(savedFile, 'utf8'));
+    lost.state.scene = 'luna';
+    await page.setInputFiles('#load-file', { name: 'luna.json', mimeType: 'application/json', buffer: Buffer.from(JSON.stringify(lost)) });
+    await page.waitForFunction(() => /non torna/.test(document.getElementById('load-error').textContent));
+    assert.ok(await page.isVisible('#title'));
+    assert.equal(await page.evaluate(() => JSON.parse(localStorage.getItem('leggenda-regolo-save')).resta), true, 'il salvataggio del browser non è toccato');
+    await page.evaluate(() => localStorage.removeItem('leggenda-regolo-save'));
+    await page.setInputFiles('#load-file', savedFile);
+    await page.waitForSelector('#title', { state: 'hidden' });
+    assert.deepEqual(await page.evaluate(() => game.snapshot()), before, 'la partita caricata è quella salvata');
+    assert.ok(await page.evaluate(() => !!localStorage.getItem('leggenda-regolo-save')), 'e diventa quella di «Continua»');
+    await page.keyboard.press('Escape');
+    await page.waitForSelector('#pause:not([hidden])');
+    await page.click('#resume');
+    assert.ok(await page.isHidden('#pause'));
+    await page.click('#pause-button');
+    await page.click('#to-title');
+    await page.waitForSelector('#continue:not([hidden])');
+    await page.click('#continue');
+    await settle(page);
+    // Musica: dopo il primo clic suona il brano del paese; muto e volume si ricordano.
+    // Il brano cambia al fotogramma dopo «Continua»: si aspetta quello, senza indovinare i tempi.
+    const playing = await page.waitForFunction(() => music.current?.src.endsWith('paese.mp3'), null, { timeout: 3000 }).then(() => true, () => false);
+    assert.ok(playing, 'musica del paese: ' + await page.evaluate(() => music.current?.src));
+    await page.click('#mute');
+    await page.locator('#volume').fill('30');
+    await page.locator('#voice-volume').fill('70');
+    assert.deepEqual(await page.evaluate(() => JSON.parse(localStorage.getItem('leggenda-regolo-audio'))), { volume: 0.3, muted: false, voices: 0.7, effects: 0.45 });
+    assert.equal(await page.evaluate(() => voices.volume), 0.7);
+    // Sul telefono si passa a un'altra app: la pagina diventa nascosta, la musica si ferma subito e la partita va in
+    // pausa; tornando la musica riparte solo con Riprendi (la pausa la tiene ferma).
+    const hide = hidden => page.evaluate(h => { Object.defineProperty(document, 'hidden', { value: h, configurable: true }); document.dispatchEvent(new Event('visibilitychange')); }, hidden);
+    await hide(true);
+    assert.equal(await page.evaluate(() => ambience.nodes.size), 0, 'nascosta la pagina, gli effetti si fermano subito');
+    assert.ok(await page.evaluate(() => music.current.audio.paused), 'nascosta la pagina, la musica è ferma');
+    assert.ok(await page.isVisible('#pause'), 'e la partita è in pausa');
+    await hide(false);
+    await page.click('#resume');
+    await page.waitForFunction(() => !music.current.audio.paused, null, { timeout: 5000 });
+
+    for (const [verb, target, item] of solution) {
+        if (verb === 'choose') {
+            await page.locator('#choices li', { hasText: target }).click();
+        } else {
+            const smart = await page.evaluate(([v, t]) => game.defaultVerb(t) === v, [verb, target]);
+            if (item) {
+                await page.click(`#verbs [data-verb="${verb}"]`);
+                await page.click(`#inventory [data-item="${item}"]`);
+            } else if (!smart) await page.click(`#verbs [data-verb="${verb}"]`);
+            // Un oggetto dell'inventario su un altro (cedrata col ghiacciolo) si clicca nell'inventario, non nella scena.
+            if (await page.evaluate(t => !!game.story.items[t], target)) await page.click(`#inventory [data-item="${target}"]`);
+            else await clickScene(page, await hotspotCenter(page, target));
+        }
+        await page.waitForTimeout(80);
+        if (verb === 'talk') await page.screenshot({ path: `${OUT}/03-dialogo.png` });
+        // La torcia nella fessura: il palio illuminato e i due occhi gialli, prima che spariscano.
+        if (target === 'fessura' && item) {
+            await page.waitForFunction(() => game.closeup?.id === 'fessura', null, { timeout: 30000 });
+            for (let i = 0; i < 3; i++) {
+                const at = await page.evaluate(i => game.story.closeups.fessura.targets[i].at, i);
+                const box = await page.locator('#scene').boundingBox();
+                await page.mouse.move(box.x + at[0] / 640 * box.width, box.y + at[1] / 360 * box.height);
+                await page.waitForFunction(() => game.closeup?.step === 'reveal');
+                await page.screenshot({ path: `${OUT}/05b-fessura-${i}.png` });
+                for (const fine = Date.now() + 30000; Date.now() < fine;) { // con la macchina carica la rivelazione dura di più
+                    if (await page.evaluate(i => game.closeup.found > i, i)) break;
+                    if (await page.evaluate(() => !!game.speech)) await page.keyboard.press('Space');
+                    await page.waitForTimeout(30);
+                }
+                assert.equal(await page.evaluate(() => game.closeup.found), i + 1);
+            }
+            await page.click('#closeup-close');
+        }
+        await settle(page);
+        if (target === 'cosa_luccicante') await page.screenshot({ path: `${OUT}/04-squama.png` });
+        if (target === 'su_fortezza') await page.screenshot({ path: `${OUT}/05-fortezza.png` });
+    }
+    await page.waitForSelector('#ending:not([hidden])');
+    await page.screenshot({ path: `${OUT}/06-fine.png` });
+    await page.click('#ending .open-credits');
+    assert.ok(await page.isVisible('#credits'), 'crediti anche dalla fine');
+    assert.ok(await page.evaluate(() => { const r = document.getElementById('close-credits').getBoundingClientRect();
+        return document.elementFromPoint(r.x + r.width / 2, r.y + r.height / 2)?.id === 'close-credits'; }), 'i crediti stanno sopra la fine');
+    await page.click('#close-credits');
+    assert.ok(await page.isHidden('#credits'));
+    const saved = await page.evaluate(() => JSON.parse(localStorage.getItem('leggenda-regolo-save')));
+    assert.ok(saved.ended && saved.inventory.includes('squama'), 'salvataggio finale');
+
+    // Una partita a metà riprende da dove era rimasta.
+    await page.click('#restart');
+    await settle(page);
+    for (const [, exit] of route('piazza', 'trebbio')) {
+        await clickScene(page, await hotspotCenter(page, exit));
+        await settle(page);
+    }
+    await page.click('#verbs [data-verb="talk"]');
+    await clickScene(page, await hotspotCenter(page, 'torre'));
+    await page.locator('#choices li', { hasText: 'bloccato' }).click();
+    await page.waitForFunction(() => game.speech?.who === 'castello');
+    await page.waitForTimeout(100);
+    await page.screenshot({ path: `${OUT}/07-trebbio.png` });
+    await settle(page);
+    await page.locator('#choices li', { hasText: 'pace' }).click();
+    await settle(page);
+    await page.reload();
+    await page.waitForSelector('#continue:not([hidden])');
+    await page.click('#continue');
+    assert.equal(await page.evaluate(() => game.state.scene), 'trebbio');
+    await settle(page);
+    // Il taccuino (N): la tappa di adesso in evidenza, Esc lo chiude.
+    await page.keyboard.press('n');
+    assert.ok(await page.isVisible('#notebook'));
+    assert.ok((await page.textContent('#notebook-list li.now')).length > 10, 'c\'è l\'obiettivo di adesso');
+    await page.screenshot({ path: `${OUT}/07a-taccuino.png` });
+    await page.keyboard.press('Escape');
+    assert.ok(await page.isHidden('#notebook'));
+    // La mappa: dal Trebbio alla Piazza con due clic; i posti mai visti (la Pieve) non ci sono.
+    await page.click('#map-button');
+    assert.equal(await page.locator('#map-board button[data-scene="pieve"]').count(), 0, 'la Pieve non è ancora vista');
+    assert.ok(await page.isVisible('#map-board button.here[data-scene="trebbio"]'));
+    await page.screenshot({ path: `${OUT}/07b-mappa.png` });
+    // La ricerca: scrivendo restano solo i posti giusti; una «p» nella casella non chiude la mappa; Invio ci va.
+    await page.fill('#map-search', 'xyz');
+    assert.ok(await page.isVisible('#map-none'), 'nessun posto: lo dice');
+    await page.fill('#map-search', '');
+    await page.click('#map-search');
+    await page.keyboard.type('piazza col'); // «piaz» da solo trova anche la Piazzetta Cambray Digny
+    assert.ok(await page.isVisible('#map'), 'scrivere «p» nella ricerca non chiude la mappa');
+    assert.ok(await page.isHidden('#map-none'));
+    const shown = await page.locator('#map-board button:visible').evaluateAll(bs => bs.map(b => b.dataset.scene));
+    assert.deepEqual(shown, ['piazza']);
+    await page.screenshot({ path: `${OUT}/07c-mappa-ricerca.png` });
+    await page.keyboard.press('Enter');
+    assert.ok(await page.isHidden('#map'));
+    assert.equal(await page.evaluate(() => game.state.scene), 'piazza');
+    // Con tutti i posti visti e la finestra piccola la mappa si scorre: filtrando da in fondo, i posti trovati si vedono
+    // (prima la mappa restava lunga quanto quella intera, scorsa su un fondo vuoto).
+    await page.setViewportSize({ width: 560, height: 340 });
+    await page.evaluate(() => { for (const id of Object.keys(game.story.scenes)) game.state.flags['visto:' + id] = true; });
+    await page.click('#map-button');
+    assert.ok(await page.evaluate(() => { const s = document.getElementById('map-scroll'); s.scrollTop = s.scrollHeight; return s.scrollTop > 0; }), 'la mappa piena si scorre');
+    await page.fill('#map-search', 'campo');
+    const found = await page.evaluate(() => {
+        const s = document.getElementById('map-scroll'), r = s.getBoundingClientRect();
+        const c = [...document.querySelectorAll('#map-board button')].find(b => !b.hidden && !b.parentElement.hidden).getBoundingClientRect();
+        return { inside: c.top >= r.top && c.bottom <= r.bottom, scrollTop: s.scrollTop, h: s.scrollHeight, ch: s.clientHeight, top: c.top - r.top, q: document.getElementById('map-search').value };
+    });
+    assert.ok(found.inside, `filtrando, il primo posto trovato non si vede: ${JSON.stringify(found)}`);
+    await page.screenshot({ path: `${OUT}/07d-mappa-ricerca-piccola.png` });
+    await page.click('#close-map');
+    await page.setViewportSize({ width: 1280, height: 860 });
 
     assert.deepEqual(errors, [], 'errori nella console');
-    console.log(`Browser OK: soluzione completa, ripresa del salvataggio, telefono. Schermate in ${OUT}`);
+    console.log(`Browser OK: soluzione completa, ripresa del salvataggio. Schermate in ${OUT}`);
     }
     assert.deepEqual(errors, [], 'errori nella console');
 } finally {

tests/multimedia.browser.mjs

@@ -84,7 +84,7 @@ export async function checkMultimedia(browser, port, out, errors) {
             else await page.mouse.move(...await at(target));
             await page.waitForFunction(() => game.closeup?.step === 'reveal');
             await page.screenshot({ path: `${out}/media-torcia-${mobile ? 'telefono' : 'desktop'}-${i}.png` });
-            for (let n = 0; n < 200; n++) {
+            for (const fine = Date.now() + 30000; Date.now() < fine;) { // con la macchina carica la rivelazione dura di più
                 if (await page.evaluate(i => game.closeup.found > i, i)) break;
                 if (await page.evaluate(() => !!game.speech)) await page.keyboard.press('Space');
                 await page.waitForTimeout(25);

tests/verify.test.mjs

@@ -0,0 +1,73 @@
+// Le prove nel browser a sezioni (scripts/verify.mjs): ogni file del gioco finisce negli ingressi delle prove giuste,
+// e l'impronta cambia solo se cambia un ingresso.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readdirSync } from 'node:fs';
+import { SUITES, ENGINE, inputsOf, ignored, fingerprint, plan } from '../scripts/verify.mjs';
+
+const FILES = ['index.html', 'style.css', 'src/main.js', 'src/version.js', 'package.json', 'package-lock.json', 'Makefile', 'README.md',
+    'src/engine/game.js', 'src/engine/render.js', 'src/engine/ambient.js', 'src/engine/bocce.js', 'src/engine/nuovo.js',
+    'src/engine/briscola.js', 'src/engine/briscola-render.js', 'src/engine/flipper.js', 'src/engine/corsa.js', 'src/story/piloti.js',
+    'src/story/story.js', 'src/story/solution.js', 'assets/scenes/piazza.png', 'assets/closeups/micro-parcheggio.png',
+    'assets/closeups/gp/boccino.png', 'assets/muro/index.html', 'assets/video/briscola.mp4', 'docs/BRISCOLA.md', 'docs/STATO.md',
+    'tests/helpers.mjs', 'tests/browser.mjs', 'tests/briscola.browser.mjs', 'tests/briscola.test.mjs', 'tests/story.test.mjs',
+    'scripts/verify.mjs', 'scripts/bump.sh', 'tools/slice_sprites.py', '.verify-ok.json'];
+const suitesWith = path => Object.keys(SUITES).filter(n => inputsOf(n, FILES).includes(path));
+const islands = Object.keys(SUITES).filter(n => !SUITES[n].core), cores = Object.keys(SUITES).filter(n => SUITES[n].core);
+
+test('ogni prova nel browser di tests/ ha la sua voce, e una sola', () => {
+    const runs = Object.values(SUITES).map(s => s.run[0]);
+    for (const f of readdirSync('tests').filter(f => f.endsWith('.browser.mjs'))) {
+        if (f === 'multimedia.browser.mjs') continue; // la chiama la parte «telefoni» di browser.mjs
+        const n = runs.filter(r => r === `tests/${f}`).length;
+        assert.equal(n, f === 'browser.mjs' ? 3 : 1, `tests/${f} è in ${n} prove`);
+    }
+});
+
+test('la briscola si riprova solo se cambia la briscola o il motore', () => {
+    assert.deepEqual(suitesWith('src/engine/briscola.js'), ['briscola']);
+    assert.deepEqual(suitesWith('src/engine/briscola-render.js'), ['briscola']);
+    assert.deepEqual(suitesWith('assets/video/briscola.mp4'), ['briscola']);
+    assert.deepEqual(suitesWith('tests/briscola.browser.mjs'), ['briscola']);
+    assert.deepEqual(suitesWith('docs/BRISCOLA.md'), [], 'i documenti non fanno rifare niente');
+    assert.ok(!inputsOf('briscola', FILES).includes('src/story/story.js'), 'la storia non fa riprovare la briscola');
+    assert.deepEqual(suitesWith('src/engine/corsa.js'), ['gara']);
+    assert.deepEqual(suitesWith('src/story/piloti.js'), ['gara']);
+    assert.deepEqual(suitesWith('assets/closeups/gp/boccino.png'), ['gara']);
+    assert.deepEqual(suitesWith('assets/muro/index.html'), ['telefono']);
+    assert.deepEqual(suitesWith('assets/closeups/micro-parcheggio.png'), ['micro']);
+});
+
+test('la storia, le scene, i minigiochi dentro la partita e un modulo nuovo fanno rifare la partita intera, non i minigiochi a sé', () => {
+    assert.deepEqual(suitesWith('tests/browser.mjs'), ['principale', 'minigiochi', 'telefoni'], 'il file di una prova conta solo per lei');
+    for (const path of ['src/story/story.js', 'src/story/solution.js', 'assets/scenes/piazza.png', 'src/engine/bocce.js', 'src/engine/ambient.js', 'src/engine/nuovo.js']) {
+        assert.deepEqual(suitesWith(path), cores, path);
+    }
+});
+
+test('il motore comune fa rifare tutto', () => {
+    for (const path of ENGINE) assert.deepEqual(suitesWith(path), Object.keys(SUITES), path);
+    assert.ok(islands.length >= 10 && cores.length >= 3);
+});
+
+test('versione, package.json, Makefile, documenti, strumenti e test unitari non fanno rifare niente', () => {
+    for (const path of ['src/version.js', 'package.json', 'Makefile', 'README.md', 'docs/STATO.md', 'scripts/bump.sh', 'scripts/verify.mjs', 'tools/slice_sprites.py', 'tests/briscola.test.mjs', 'tests/story.test.mjs', '.verify-ok.json']) {
+        assert.ok(ignored(path), `${path} dovrebbe essere ignorato`);
+        assert.deepEqual(suitesWith(path), [], path);
+    }
+});
+
+test("l'impronta cambia solo se cambia un ingresso, e il piano dice quali", () => {
+    const hashes = new Map(FILES.map(p => [p, 'h-' + p]));
+    const before = plan(hashes, {});
+    assert.ok(before.every(p => !p.green), 'mai provate: tutte da rifare');
+    const ok = Object.fromEntries(before.map(p => [p.name, { fingerprint: p.fp, hashes: Object.fromEntries(p.inputs.map(f => [f, hashes.get(f)])) }]));
+    assert.ok(plan(hashes, ok).every(p => p.green), 'niente cambiato: tutte verdi');
+    hashes.set('docs/STATO.md', 'altro');
+    assert.ok(plan(hashes, ok).every(p => p.green), 'un documento non cambia niente');
+    hashes.set('src/engine/briscola.js', 'altro');
+    const after = plan(hashes, ok);
+    assert.deepEqual(after.filter(p => !p.green).map(p => p.name), ['briscola']);
+    assert.deepEqual(after.find(p => p.name === 'briscola').changed, ['src/engine/briscola.js']);
+    assert.notEqual(fingerprint(['a'], () => '1'), fingerprint(['a'], () => '2'));
+});

tools/gitea-runner/config.yaml

@@ -0,0 +1,13 @@
+# Configurazione di act_runner (vedi docker-compose.yml accanto).
+log:
+  level: info
+runner:
+  file: .runner
+  capacity: 2
+  timeout: 30m
+container:
+  network: ""
+  privileged: false
+  options: "--memory=4g"
+  valid_volumes: []
+  force_pull: false

tools/gitea-runner/docker-compose.yml

@@ -0,0 +1,19 @@
+# Runner delle Gitea Actions di git.manzolo.it, sul PC di Andrea (dal 2026-11-01). Si crea e si avvia con
+# `make runner` (scripts/runner.sh): registra il runner sul repo se manca e lo lascia acceso (riparte con Docker).
+# I job girano in container fratelli tramite il socket Docker del PC; le credenziali del runner stanno fuori dal repo.
+name: gitea-runner
+services:
+  runner:
+    image: gitea/act_runner:0.6.1
+    container_name: gitea-runner
+    restart: unless-stopped
+    environment:
+      CONFIG_FILE: /config.yaml
+      GITEA_INSTANCE_URL: https://git.manzolo.it
+      GITEA_RUNNER_REGISTRATION_TOKEN: ${GITEA_RUNNER_REGISTRATION_TOKEN:-}
+      GITEA_RUNNER_NAME: ${GITEA_RUNNER_NAME:-pc-andrea}
+      GITEA_RUNNER_LABELS: ubuntu-latest:docker://node:22-bookworm
+    volumes:
+      - ./config.yaml:/config.yaml:ro
+      - ${RUNNER_DATA:?}:/data
+      - /var/run/docker.sock:/var/run/docker.sock