refactor: rimuove terminal controller CLI

- Multi-stage build: builder (npm ci + vite build) + runtime minimale
- Immagine runtime senza devDependencies e senza sorgenti frontend
- docker-compose: porta singola 3000, volume .segnapunti per persistenza stato
- Aggiunge .dockerignore per escludere node_modules, test, dist dal contesto

.dockerignore

@@ -0,0 +1,11 @@
+node_modules
+dist
+dev-dist
+.segnapunti
+tests
+playwright-report
+test-results
+*.md
+.git
+.gitignore
+.vscode

.gitignore

@@ -13,6 +13,8 @@ currentCommit.txt
 node_modules
 dist
 dist-ssr
+dev-dist
+.segnapunti
 *.local
 
 # Editor directories and files
@@ -25,3 +27,13 @@ dist-ssr
 *.njsproj
 *.sln
 *.sw?
+
+# Playwright
+/test-results/
+/playwright-report/
+/blob-report/
+/playwright/.cache/
+/playwright/.auth/
+
+# Vitest
+coverage/

CHANGELOG.md

@@ -7,6 +7,35 @@ e questo progetto aderisce al [Versionamento Semantico](https://semver.org/lang/
 
 ---
 
+## [2.0.0] - 2026-05-12
+
+### Aggiunto
+- Architettura client-server con WebSocket: server Express (`server.js`) + handler (`src/websocket-handler.js`) come unica fonte di verità; display e controller sono client separati sincronizzati in tempo reale
+- Interfaccia display (`/display`) e controller (`/controller`) su porta singola `:3000`
+- Robustezza connessione WebSocket: reconnect automatico con backoff esponenziale, indicatore stato connessione sul display
+- Supporto query parameter `?wsHost=` per scenari WSL2 / development remoto
+- Validazione cambi giocatori già in formazione lato client
+- Sintesi vocale inoltrata dal controller al display via WebSocket
+- Dialog set vinto sul controller al raggiungimento dei 25 punti: mostra il vincitore, permette di annullare l'ultimo punto (INDIETRO) o avanzare al set successivo con reset automatico formazioni
+- Struttura striscia ottimizzata: array di set `[{ serv, r[] }]` che registra la sequenza dei punti e preserva la storia di tutti i set; elimina `storicoServizio`
+- Persistenza stato su `.segnapunti/state.json`: salvato ad ogni azione, ricaricato all'avvio del server
+- Suite di test completa: unit (Vitest), integration, component (Vue Test Utils + Happy-DOM), stress (50+ client), E2E (Playwright su Chromium, Firefox, Mobile Chrome)
+- Dockerfile multi-stage (builder + runtime minimale) e docker-compose con volume per persistenza stato; immagine pubblicata su registro Gitea
+
+### Modificato
+- `applyAction` usa `structuredClone` al posto di `JSON.parse/stringify`
+- Calcolo cambio palla deduplicato in `applyAction`
+- Undo punto (`decPunt`) ricostruisce il servizio precedente dalla storia `r[]`
+- `nuovoSet` come azione dedicata per la progressione regolare tra set
+
+### Rimosso
+- Terminal controller CLI (`cli.js`)
+- Dipendenze inutilizzate: `wave-ui`, `vue-router`, `concurrently`
+- Script npm ridondanti: `preview`, `start`, `cli`, `cli:dev`
+- Asset template Vite: `vite.svg`, `vue.svg`, `serve.png`
+
+---
+
 ## [1.0.0] - 2026-02-10
 
 Rilascio iniziale di **Segnapunti Anto**, un'applicazione web Progressive Web App (PWA) professionale per il tracciamento in tempo reale dei punteggi durante partite di pallavolo.

CLAUDE.md

@@ -0,0 +1,62 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Purpose
+
+**Segnapunti Anto** is a real-time volleyball scoreboard PWA. An Express/WebSocket server hosts the game state; two separate web interfaces — a **display** (public scoreboard) and a **controller** (operator panel) — stay in sync via WebSocket.
+
+## Commands
+
+```bash
+npm run dev          # Vite dev server — display: :5173/display, controller: :5173/controller
+npm run serve        # Build + run production — display: :3000/display, controller: :3000/controller
+
+npm run test         # Vitest watch mode
+npm run test:all     # All Vitest suites once (unit, integration, component, stress)
+npm run test:unit    # Unit + integration only
+npm run test:component  # Vue component tests
+npm run test:stress  # Load tests (50+ concurrent clients)
+npm run test:e2e     # Playwright E2E (requires servers to be running via npm run serve)
+npm run test:e2e:ui  # Playwright with interactive UI
+```
+
+## Architecture
+
+```
+Controller (Vue)  ──WebSocket──┐
+Display (Vue)     ──WebSocket──┤── websocket-handler.js ── gameState.js
+                               │         │
+                               │         └── persist.js ── .segnapunti/state.json
+```
+
+All game logic lives in `src/gameState.js` as three pure functions:
+- `createInitialState()` — returns the initial state
+- `applyAction(state, action)` — immutable reducer (deep-clones via `structuredClone`)
+- `checkVittoria(state)` — volleyball win conditions (25-point sets with 2-point margin, 15-point final set)
+
+`src/websocket-handler.js` receives actions, validates that the sender is a registered controller (not just a display), calls `applyAction`, broadcasts the new state to all clients, then calls `onStateChange` to persist state to disk.
+
+`server.js` (Express) serves both interfaces on port 3000: `/display` → `dist/index.html`, `/controller` → `dist/controller.html`. Single WebSocket endpoint at `/ws`.
+
+In development, `vite-plugin-websocket.js` embeds the WebSocket server inside the Vite dev server with URL rewrite middleware for `/display` and `/controller`.
+
+## Key Design Constraints
+
+- **All game rules on the server** — clients are pure UI; the server is the source of truth.
+- **Role-based WebSocket** — clients register as `display` or `controller`; only controllers may send actions.
+- **Immutable state** — `applyAction` never mutates; always returns a new state object.
+- **Single-controller intent** — the design targets one active controller and one display; no conflict resolution exists for simultaneous controllers.
+- **Persistent state** — `src/persist.js` saves state to `.segnapunti/state.json` after every action and loads it on server startup.
+
+## Test Layout
+
+| Suite | Path | Runner |
+|-------|------|--------|
+| Unit | `tests/unit/` | Vitest + Node |
+| Integration | `tests/integration/` | Vitest + Node |
+| Component | `tests/component/` | Vitest + Happy-DOM |
+| Stress | `tests/stress/` | Vitest + Node |
+| E2E | `tests/e2e/` | Playwright (Chromium, Firefox, Mobile Chrome) |
+
+E2E tests run serially (`workers: 1`) to avoid WebSocket state races. Run `npm run serve` before `npm run test:e2e`.

Dockerfile

@@ -0,0 +1,22 @@
+# Stage 1: build frontend
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+# Stage 2: runtime
+FROM node:20-alpine
+WORKDIR /app
+ENV NODE_ENV=production PORT=3000
+
+COPY package*.json ./
+RUN npm ci --omit=dev
+
+COPY server.js ./
+COPY src/gameState.js src/websocket-handler.js src/server-utils.js src/persist.js ./src/
+COPY --from=builder /app/dist ./dist
+
+EXPOSE 3000
+CMD ["node", "server.js"]

README.md

@@ -1,255 +1,215 @@
-# Segnapunti Anto
+# Segnapunti
 
-Applicazione web **Progressive Web App (PWA)** per tracciare i punteggi di partite di pallavolo in tempo reale.
+![Version](https://img.shields.io/badge/versione-2.0.0-blue)
+![Node](https://img.shields.io/badge/node-%3E%3D18-green)
+![Docker](https://img.shields.io/badge/docker-ready-2496ED?logo=docker&logoColor=white)
+![License](https://img.shields.io/badge/licenza-privata-lightgrey)
+
+Segnapunti digitale in tempo reale per partite di pallavolo. Un server centrale gestisce lo stato della partita; un **display** mostra il tabellone pubblico e un **controller** (smartphone o tablet) permette all'operatore di gestire punti, formazioni e cambi.
 
 ---
 
-## Panoramica
+## Indice
 
-**Segnapunti Anto** è un'applicazione digitale per il tracciamento dei punteggi durante partite di pallavolo, ottimizzata per l'uso su tablet e smartphone. Sviluppata per il team Antoniana, l'app fornisce un'interfaccia fullscreen touch-friendly con supporto offline e controlli da tastiera.
-
-### Funzionalità Principali
-
-- **Gestione Completa Partite**
-  - Tracciamento punti in tempo reale per entrambe le squadre
-  - Conteggio automatico dei set (modalità 2/3 o 3/5)
-  - Indicatore visivo del servizio
-  - Blocco incremento punti a set concluso
-  - Cronologia punti con striscia visiva
-
-- **Formazioni Squadra**
-  - Visualizzazione interattiva dei 6 giocatori in campo
-  - Rotazione automatica regolamentare al cambio palla
-  - Configurazione manuale dei numeri di maglia
-  - Dialog cambi con uno o due cambi (IN → OUT) e validazioni
-  - Supporto logica pallavolo ufficiale (25 punti + 2 di vantaggio, tie-break a 15 nel set decisivo)
-
-- **Controlli Multimodali**
-  - Scorciatoie da tastiera complete (vedi sezione [Shortcuts](#shortcuts))
-  - Sintesi vocale per annunci punteggio in italiano (Web Speech API)
-
-- **Personalizzazione**
-  - Configurazione dinamica nomi squadre
-  - Selettore modalità partita: al meglio di 3 o al meglio di 5
-  - Toggle layout orizzontale (inverti home/guest)
-  - Modalità visualizzazione: punteggio semplice o formazioni complete
-  - Nascondi/mostra controlli e cronologia
+- [Architettura](#architettura)
+- [Guida utente](#guida-utente)
+- [Funzionalità](#funzionalità)
+- [Shortcuts tastiera](#shortcuts-tastiera)
+- [Deploy con Docker](#deploy-con-docker)
+- [Sviluppo](#sviluppo)
+- [Test](#test)
 
 ---
 
-## Requisiti
+## Architettura
 
-### Requisiti di Sistema
+```
+Controller (smartphone)  ──WebSocket──┐
+                                      ├── Server Node.js ── gameState.js
+Display (schermo)        ──WebSocket──┘         │
+                                                └── .segnapunti/state.json
+```
 
-#### Per Sviluppo
-- **Sistema Operativo**: Linux, macOS, Windows (WSL2 consigliato)
-- **Node.js**: v20.2.0 o superiore (LTS consigliato)
-- **npm**: v9.0.0 o superiore (incluso con Node.js)
-- **RAM**: Minimo 2GB, consigliato 4GB
-- **Spazio Disco**: ~500MB per dipendenze e build
+Il server è l'unica fonte di verità. Ogni azione del controller viene elaborata e trasmessa in broadcast a tutti i client connessi. Lo stato viene salvato su disco ad ogni azione e ricaricato all'avvio, sopravvivendo ai riavvii del server.
 
-#### Per Deployment
-- **Server Web**: Qualsiasi server statico (nginx, Apache, Vercel, Netlify)
-- **HTTPS**: Obbligatorio per Service Worker e PWA (eccetto localhost)
-- **Connessione Internet**: Solo per primo caricamento (poi funziona offline)
-
-### Requisiti Browser (Utente Finale)
-
-| Requisito | Dettaglio | Necessità |
-|-----------|-----------|-----------|
-| **JavaScript ES6+** | Supporto moduli, arrow functions, async/await | Obbligatorio |
-| **Service Worker API** | Per funzionalità offline PWA | Obbligatorio |
-| **Fullscreen API** | Per modalità schermo intero | Consigliato |
-| **Web Speech API** | Per sintesi vocale punteggi | Opzionale |
-| **Local Storage** | Per persistenza configurazioni | Consigliato |
-
-### Browser Testati e Supportati
-
-| Browser | Versione Minima | Supporto | Note |
-|---------|-----------------|----------|------|
-| Chrome/Chromium | 90+ | ✅ Completo | Consigliato per tutte le features |
-| Firefox | 88+ | ✅ Completo | Supporto completo PWA e Speech API |
+| Percorso | Ruolo |
+|---|---|
+| `http://<host>:3000/display` | Tabellone pubblico — sola lettura |
+| `http://<host>:3000/controller` | Pannello operatore — gestione partita |
+| `ws://<host>:3000/ws` | WebSocket endpoint |
 
 ---
 
-## Installazione e Setup
+## Guida utente
 
-### Prerequisiti
+### Scenario tipico: schermo fisso + smartphone operatore
 
-- **Node.js** v20.2.0 (consigliato)
-- **npm** o **yarn**
-
-### Installazione con NVM (consigliato)
+#### 1. Avvia il server
 
 ```bash
-# Installa la versione corretta di Node.js
-nvm install v20.2.0
-nvm use v20.2.0
+docker compose up -d
+```
 
-# Clona il repository
-git clone <repository-url>
-cd segnapunti
+All'avvio il terminale mostra gli URL locali e di rete.
 
-# Installa le dipendenze
-npm install
+#### 2. Apri il display
+
+Collega il PC/server allo schermo via HDMI e apri il browser a schermo intero:
+
+```
+http://localhost:3000/display
+```
+
+Se il display è su un dispositivo separato nella stessa rete:
+
+```
+http://<IP-del-server>:3000/display
+```
+
+> **Trovare l'IP:** il server lo stampa all'avvio. In alternativa usa `ip a` su Linux.
+
+#### 3. Apri il controller sullo smartphone
+
+Connetti il telefono alla stessa rete Wi-Fi e apri:
+
+```
+http://<IP-del-server>:3000/controller
+```
+
+> **Installazione come app:** nel browser tocca *"Aggiungi a schermata Home"* per avere il controller come icona dedicata.
+
+---
+
+## Funzionalità
+
+### Display
+
+- Nomi squadre con indicatore di servizio
+- Punteggio del set corrente (grande, leggibile da lontano)
+- Contatore set vinti
+- Striscia storica punti del set in corso, scorrevole verso destra
+- Modalità formazioni: posizioni dei 6 giocatori in campo
+- Indicatore connessione WebSocket (scompare quando connesso, rosso lampeggiante se disconnesso)
+
+### Controller
+
+- **Punti** — `+1` per casa e ospite, con annullamento dell'ultimo punto
+- **Dialog set vinto** — appare automaticamente al raggiungimento dei 25 punti (o 15 nel tie-break); permette di confermare il set o annullare l'ultimo punto
+- **Formazioni** — configura i numeri di maglia; la rotazione avviene automaticamente al cambio palla
+- **Cambi** — dialog `IN → OUT` con validazione
+- **Servizio** — cambio manuale (disponibile solo a 0-0)
+- **Visualizzazione** — alterna tra punteggio grande e formazioni in campo
+- **Striscia** — mostra/nasconde lo storico punti sul display
+- **Reset** — azzera la partita (richiede conferma)
+
+### Regole pallavolo integrate
+
+| Set | Condizione di vittoria |
+|---|---|
+| Set 1–4 (modalità 3/5) o 1–2 (modalità 2/3) | Primo a **25** con almeno 2 punti di scarto |
+| Set decisivo (tie-break) | Primo a **15** con almeno 2 punti di scarto |
+
+---
+
+## Shortcuts tastiera
+
+> Valide sul controller da browser desktop.
+
+| Tasto | Azione |
+|---|---|
+| `Ctrl + ↑` | Punto casa |
+| `Ctrl + ↓` | Annulla ultimo punto |
+| `Shift + ↑` | Punto ospite |
+| `Ctrl + ←` | Cambia servizio (solo a 0-0) |
+| `Ctrl + M` | Apri configurazione |
+| `Ctrl + C` | Cambi squadra casa |
+| `Shift + C` | Cambi squadra ospite |
+| `Ctrl + Z` | Toggle punteggio / formazioni |
+| `Ctrl + S` | Annuncio vocale punteggio |
+| `Ctrl + B` | Mostra/nascondi barra pulsanti |
+| `Ctrl + F` | Fullscreen |
+
+---
+
+## Deploy con Docker
+
+### Prima installazione
+
+```bash
+docker compose up -d
+```
+
+Lo stato viene salvato nel volume Docker `segnapunti-state` e sopravvive ai riavvii del container.
+
+### Aggiornamento a nuova versione
+
+```bash
+docker compose pull && docker compose up -d
+```
+
+### Build e pubblicazione immagine
+
+```bash
+docker build \
+  -t santantonio.sytes.net/attilio/segnapunti:2.0.0 \
+  -t santantonio.sytes.net/attilio/segnapunti:latest .
+
+docker push santantonio.sytes.net/attilio/segnapunti:2.0.0
+docker push santantonio.sytes.net/attilio/segnapunti:latest
 ```
 
 ---
 
-## Comandi per Sviluppo
+## Sviluppo
 
-### Dev Server
+### Requisiti
 
-Avvia il server di sviluppo con hot-reload:
+| Strumento | Versione minima |
+|---|---|
+| Node.js | >= 18 |
+| npm | >= 9 |
+
+### Avvio
 
 ```bash
+npm install
 npm run dev
 ```
 
-L'applicazione sarà disponibile su [http://localhost:5173](http://localhost:5173)
+| URL | Interfaccia |
+|---|---|
+| `http://localhost:5173/display` | Display |
+| `http://localhost:5173/controller` | Controller |
 
-### Modalità Sviluppo
-- Hot Module Replacement (HMR) attivo
-- Source maps per debugging
-- Vue DevTools supportato
-- Errori e warnings in console
+Lo stato viene salvato in `.segnapunti/state.json` anche in modalità dev.
+
+### Comandi disponibili
+
+| Comando | Descrizione |
+|---|---|
+| `npm run dev` | Dev server con hot reload |
+| `npm run build` | Build di produzione in `dist/` |
+| `npm run serve` | Build + avvio server produzione |
 
 ---
 
-## Comandi per Build
+## Test
 
-### Build Produzione
+| Comando | Descrizione |
+|---|---|
+| `npm run test:unit` | Unit + integration (Vitest) |
+| `npm run test:component` | Componenti Vue (Happy-DOM) |
+| `npm run test:stress` | Load test WebSocket (50+ client) |
+| `npm run test:all` | Tutti i test tranne E2E |
+| `npm run test:e2e` | Playwright — Chromium, Firefox, Mobile Chrome |
 
-Genera i file ottimizzati per il deployment:
-
-```bash
-npm run build
-```
-
-**Output:**
-- Cartella `/dist` con file statici ottimizzati
-- Service Worker generato automaticamente
-- PWA manifest configurato
-- Assets minificati e con hash per cache busting
-- Base path: `/segnap` (modificabile in `vite.config.js`)
-
-### Preview Build
-
-Anteprima locale della build di produzione:
-
-```bash
-npm run preview
-```
-
-Serve i file dalla cartella `/dist` per testare la build prima del deploy.
+> I test E2E richiedono il server in esecuzione (`npm run serve`) e i browser Playwright installati:
+> ```bash
+> npx playwright install chromium firefox
+> ```
 
 ---
 
-## Shortcuts
+## Changelog
 
-### Controlli Tastiera Squadra Home
-
-| Scorciatoia | Azione |
-|-------------|--------|
-| `Ctrl + ↑` | Incrementa punti |
-| `Ctrl + ↓` | Decrementa punti |
-| `Ctrl + →` | Incrementa set |
-| `Ctrl + C` | Apri dialog cambi |
-
-### Controlli Tastiera Squadra Guest
-
-| Scorciatoia | Azione |
-|-------------|--------|
-| `Shift + ↑` | Incrementa punti |
-| `Shift + ↓` | Decrementa punti |
-| `Shift + →` | Incrementa set |
-| `Shift + C` | Apri dialog cambi |
-
-### Comandi Globali
-
-| Scorciatoia | Azione |
-|-------------|--------|
-| `Ctrl + ←` | Cambio palla (servizio) - **solo a 0-0** |
-| `Ctrl + M` | Apri configurazione nomi squadre e formazioni |
-| `Ctrl + B` | Toggle visibilità barra pulsanti |
-| `Ctrl + F` | Attiva/disattiva fullscreen |
-| `Ctrl + S` | Annuncio vocale punteggio corrente |
-| `Ctrl + Z` | Switch tra visualizzazione formazioni e punteggio |
-
----
-
-## Configurazione PWA
-
-L'applicazione è configurata come **Progressive Web App** nel file [vite.config.js](vite.config.js):
-
-```javascript
-VitePWA({
-  registerType: 'autoUpdate',
-  manifest: {
-    name: "app_segnap",
-    short_name: "segnap",
-    description: "Segnapunti standalone.",
-    background_color: "#eee",
-    theme_color: '#ffffff',
-    display: "fullscreen",
-    orientation: "landscape",
-    icons: [
-      { src: 'segnap-192x192.png', sizes: '192x192', type: 'image/png' },
-      { src: 'segnap-512x512.png', sizes: '512x512', type: 'image/png' }
-    ]
-  }
-})
-```
-
-### Caratteristiche PWA
-
-- **Display**: Fullscreen per massimizzare lo spazio visivo
-- **Orientamento**: Landscape (orizzontale) ottimizzato per tablet
-- **Auto-update**: Service Worker con aggiornamento automatico
-- **Offline**: Funzionamento completo senza connessione internet
-- **Installabile**: Aggiungibile alla home screen come app nativa
-
-### Installazione PWA
-
-**Android/Desktop (Chrome):**
-- Menu → "Installa app" o icona (⊕) nella barra degli indirizzi
-
-**iOS (Safari):**
-- Share (□↑) → "Aggiungi a Home"
-
----
-
-## Logica Regolamentare Pallavolo
-
-### Vittoria Set
-
-- **Set regolari (1-4)**: Primo a 25 punti con almeno 2 di vantaggio
-- **Set decisivo**:
-  - Modalità 2/3: 3° set a 15 punti con almeno 2 di vantaggio
-  - Modalità 3/5: 5° set a 15 punti con almeno 2 di vantaggio
-- **Blocco automatico**: Non consente assegnare punti oltre la vittoria
-
-### Rotazione Formazione
-
-La rotazione avviene **automaticamente** quando:
-1. La squadra **conquista il servizio** (cambio palla)
-2. Il punteggio è diverso da 0-0
-
-**Limitazione cambio palla manuale:**
-- Il cambio manuale del servizio (`Ctrl + ←`) è consentito **solo a 0-0**
-- Questa limitazione previene errori nella rotazione delle formazioni
-
-### Formazione in Campo
-
-Visualizzazione a 6 posizioni standard:
-
-```
-        Rete
-┌─────┬─────┬─────┐
-│  4  │  3  │  2  │  ← Fila anteriore
-├─────┼─────┼─────┤
-│  5  │  6  │  1  │  ← Fila posteriore
-└─────┴─────┴─────┘
-```
-
-La rotazione avviene in senso orario: 1→6→5→4→3→2→1
+Vedere [CHANGELOG.md](CHANGELOG.md) per la storia delle versioni.

controller.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/png" href="/segnap-192x192.png" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Segnapunti - Controller</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/controller-main.js"></script>
+  </body>
+</html>

docker-compose.yml

@@ -0,0 +1,12 @@
+services:
+  segnapunti:
+    image: santantonio.sytes.net/attilio/segnapunti:1.0.0
+    container_name: segnapunti
+    ports:
+      - "3000:3000"
+    volumes:
+      - segnapunti-state:/app/.segnapunti
+    restart: unless-stopped
+
+volumes:
+  segnapunti-state:

index.html

@@ -2,7 +2,7 @@
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <link rel="icon" type="image/png" href="/segnap-192x192.png" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Segnapunti - Anto</title>
   </head>

package.json

@@ -1,21 +1,41 @@
 {
   "name": "segnapuntianto",
   "private": true,
-  "version": "0.0.0",
+  "version": "2.0.0",
   "type": "module",
   "scripts": {
     "dev": "vite",
     "build": "vite build",
-    "preview": "vite preview"
+    "serve": "vite build && node server.js",
+    "test": "vitest",
+    "test:unit": "vitest run tests/unit tests/integration",
+    "test:component": "vitest run tests/component",
+    "test:stress": "vitest run tests/stress",
+    "test:all": "vitest run",
+    "test:ui": "vitest --ui",
+    "test:e2e": "playwright test --config=playwright.config.cjs",
+    "test:e2e:ui": "playwright test --config=playwright.config.cjs --ui",
+    "test:e2e:codegen": "playwright codegen --config=playwright.config.cjs"
   },
   "dependencies": {
-    "nosleep.js": "^0.12.0",
+    "express": "^5.2.1",
     "vue": "^3.2.47",
-    "wave-ui": "^3.3.0"
+    "ws": "^8.19.0"
+  },
+  "overrides": {
+    "serialize-javascript": "^7.0.5"
   },
   "devDependencies": {
-    "@vitejs/plugin-vue": "^4.1.0",
-    "vite": "^4.3.9",
-    "vite-plugin-pwa": "^0.16.0"
+    "@axe-core/playwright": "^4.11.1",
+    "@playwright/test": "^1.58.2",
+    "@types/node": "^25.2.3",
+    "@vitejs/plugin-vue": "^6.0.5",
+    "@vitest/ui": "^4.0.18",
+    "@vue/test-utils": "^2.4.6",
+    "happy-dom": "^20.6.1",
+    "jsdom": "^28.0.0",
+    "vite": "^7.3.1",
+    "vite-plugin-pwa": "^1.2.0",
+    "vitest": "^4.0.18"
   }
 }

playwright.config.cjs

@@ -0,0 +1,38 @@
+const { defineConfig, devices } = require('@playwright/test');
+
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+module.exports = defineConfig({
+  testDir: './tests/e2e',
+  fullyParallel: false,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: 1,
+  reporter: 'html',
+  use: {
+    trace: 'on-first-retry',
+  },
+
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+    {
+      name: 'firefox',
+      use: { ...devices['Desktop Firefox'] },
+    },
+    {
+      name: 'Mobile Chrome',
+      use: { ...devices['Pixel 5'] },
+    },
+  ],
+
+  webServer: {
+    command: 'npm run serve',
+    url: 'http://localhost:3000',
+    reuseExistingServer: !process.env.CI,
+    timeout: 120 * 1000,
+  },
+});

public/vite.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>

server.js

@@ -0,0 +1,45 @@
+import { createServer } from 'http'
+import express from 'express'
+import { WebSocketServer } from 'ws'
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
+import { setupWebSocketHandler } from './src/websocket-handler.js'
+import { printServerInfo } from './src/server-utils.js'
+import { loadState, saveState } from './src/persist.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const PORT = process.env.PORT || 3000
+const distDir = join(__dirname, 'dist')
+
+const app = express()
+
+app.use(express.static(distDir, { index: false }))
+
+app.get(['/', '/display', '/display/*splat'], (_req, res) => {
+    res.sendFile(join(distDir, 'index.html'))
+})
+
+app.get(['/controller', '/controller/*splat'], (_req, res) => {
+    res.sendFile(join(distDir, 'controller.html'))
+})
+
+const server = createServer(app)
+const wss = new WebSocketServer({ noServer: true })
+setupWebSocketHandler(wss, { initialState: loadState(), onStateChange: saveState })
+
+server.on('upgrade', (request, socket, head) => {
+    const pathname = new URL(request.url, `http://${request.headers.host}`).pathname
+    if (pathname === '/ws') {
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            wss.emit('connection', ws, request)
+        })
+    } else {
+        socket.destroy()
+    }
+})
+
+server.listen(PORT, '0.0.0.0', () => {
+    printServerInfo(PORT)
+})

src/App.vue

@@ -1,7 +1,3 @@
-<script setup>
-import HomePage from './components/HomePage/index.vue'
-</script>
-
 <template>
-  <HomePage />
+  <router-view />
 </template>

src/assets/vue.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="37.07" height="36" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 198"><path fill="#41B883" d="M204.8 0H256L128 220.8L0 0h97.92L128 51.2L157.44 0h47.36Z"></path><path fill="#41B883" d="m0 0l128 220.8L256 0h-51.2L128 132.48L50.56 0H0Z"></path><path fill="#35495E" d="M50.56 0L128 133.12L204.8 0h-47.36L128 51.2L97.92 0H50.56Z"></path></svg>

src/components/ControllerPage.vue

@@ -0,0 +1,969 @@
+<template>
+  <section class="controller-page">
+    <!-- Barra di stato connessione -->
+    <div class="conn-bar" :class="{ connected: wsConnected }">
+      <span class="dot"></span>
+      {{ wsConnected ? 'Connesso' : 'Connessione...' }}
+    </div>
+
+    <!-- Anteprima punteggio -->
+    <div class="score-preview">
+      <div class="team-score home-bg" @click="sendAction({ type: 'incPunt', team: 'home' })">
+        <div class="team-name">{{ state.sp.nomi.home }}</div>
+        <div class="team-pts">{{ state.sp.punt.home }}</div>
+        <div class="team-set">SET {{ state.sp.set.home }}</div>
+        <img v-show="state.sp.servHome" src="/serv.png" class="serv-icon" alt="Servizio" />
+      </div>
+      <div class="team-score guest-bg" @click="sendAction({ type: 'incPunt', team: 'guest' })">
+        <div class="team-name">{{ state.sp.nomi.guest }}</div>
+        <div class="team-pts">{{ state.sp.punt.guest }}</div>
+        <div class="team-set">SET {{ state.sp.set.guest }}</div>
+        <img v-show="!state.sp.servHome" src="/serv.png" class="serv-icon" alt="Servizio" />
+      </div>
+    </div>
+
+    <!-- Riga annulla punto -->
+    <div class="undo-row">
+      <button class="btn btn-undo" @click="sendAction({ type: 'decPunt' })">
+        ANNULLA PUNTO
+      </button>
+    </div>
+
+    <!-- Pulsanti set -->
+    <div class="action-row">
+      <button class="btn btn-set home-bg" @click="sendAction({ type: 'incSet', team: 'home' })">
+        SET {{ state.sp.nomi.home }}
+      </button>
+      <button class="btn btn-set guest-bg" @click="sendAction({ type: 'incSet', team: 'guest' })">
+        SET {{ state.sp.nomi.guest }}
+      </button>
+    </div>
+
+    <!-- Controlli principali -->
+    <div class="controls">
+      <button class="btn btn-ctrl" @click="sendAction({ type: 'cambiaPalla' })" :disabled="!isPunteggioZeroZero">
+        Cambio Palla
+      </button>
+      <button class="btn btn-ctrl" @click="sendAction({ type: 'toggleFormazione' })">
+        {{ state.visuForm ? 'Punteggio' : 'Formazioni' }}
+      </button>
+      <button class="btn btn-ctrl" @click="sendAction({ type: 'toggleStriscia' })">
+        Striscia
+      </button>
+      <button class="btn btn-ctrl" @click="sendAction({ type: 'toggleOrder' })">
+        Inverti
+      </button>
+      <button class="btn btn-ctrl" @click="speak()">
+        Voce
+      </button>
+      <button class="btn btn-ctrl" @click="openConfig()">
+        Config
+      </button>
+      <button class="btn btn-ctrl" @click="openCambiTeam()">
+        Cambi
+      </button>
+      <button class="btn btn-danger" @click="confirmReset = true">
+        Reset
+      </button>
+    </div>
+
+    <!-- Finestra conferma reset -->
+    <div class="overlay" v-if="confirmReset" @click.self="confirmReset = false">
+      <div class="dialog">
+        <div class="dialog-title">Azzero punteggio?</div>
+        <div class="dialog-buttons">
+          <button class="btn btn-cancel" @click="confirmReset = false">NO</button>
+          <button class="btn btn-confirm" @click="doReset()">SI</button>
+        </div>
+      </div>
+    </div>
+
+    <!-- Finestra set vinto -->
+    <div class="overlay" v-if="showSetVinto">
+      <div class="dialog">
+        <div class="dialog-title">SET VINTO</div>
+        <div class="dialog-winner">{{ state.sp.nomi[setVintoTeam] }}</div>
+        <div class="dialog-subtitle">Configura le formazioni per il prossimo set</div>
+        <div class="dialog-buttons">
+          <button class="btn btn-cancel" @click="undoUltimoPoint()">INDIETRO</button>
+          <button class="btn btn-confirm" @click="doNuovoSet()">VAI AL SET SUCCESSIVO</button>
+        </div>
+      </div>
+    </div>
+
+    <!-- Finestra configurazione -->
+    <div class="overlay" v-if="showConfig" @click.self="showConfig = false">
+      <div class="dialog dialog-config">
+        <div class="dialog-title">Configurazione</div>
+
+        <div class="form-group">
+          <label>Nome Home</label>
+          <input type="text" v-model="configData.nomeHome" class="input-field" />
+        </div>
+        <div class="form-group">
+          <label>Nome Guest</label>
+          <input type="text" v-model="configData.nomeGuest" class="input-field" />
+        </div>
+
+        <div class="form-group">
+          <label>Modalità partita</label>
+          <div class="mode-buttons">
+            <button :class="['btn', 'btn-mode', configData.modalita === '2/3' ? 'active' : '']"
+              @click="configData.modalita = '2/3'">2/3</button>
+            <button :class="['btn', 'btn-mode', configData.modalita === '3/5' ? 'active' : '']"
+              @click="configData.modalita = '3/5'">3/5</button>
+          </div>
+        </div>
+
+        <div class="form-group">
+          <label>Formazione Home</label>
+          <div class="form-grid">
+            <div class="form-row">
+              <input type="text" v-model="configData.formHome[3]" class="input-num" />
+              <input type="text" v-model="configData.formHome[2]" class="input-num" />
+              <input type="text" v-model="configData.formHome[1]" class="input-num" />
+            </div>
+            <div class="form-line"></div>
+            <div class="form-row">
+              <input type="text" v-model="configData.formHome[4]" class="input-num" />
+              <input type="text" v-model="configData.formHome[5]" class="input-num" />
+              <input type="text" v-model="configData.formHome[0]" class="input-num" />
+            </div>
+          </div>
+        </div>
+
+        <div class="form-group">
+          <label>Formazione Guest</label>
+          <div class="form-grid">
+            <div class="form-row">
+              <input type="text" v-model="configData.formGuest[3]" class="input-num" />
+              <input type="text" v-model="configData.formGuest[2]" class="input-num" />
+              <input type="text" v-model="configData.formGuest[1]" class="input-num" />
+            </div>
+            <div class="form-line"></div>
+            <div class="form-row">
+              <input type="text" v-model="configData.formGuest[4]" class="input-num" />
+              <input type="text" v-model="configData.formGuest[5]" class="input-num" />
+              <input type="text" v-model="configData.formGuest[0]" class="input-num" />
+            </div>
+          </div>
+        </div>
+
+        <div class="dialog-buttons">
+          <button class="btn btn-cancel" @click="showConfig = false">Annulla</button>
+          <button class="btn btn-confirm" @click="saveConfig()">OK</button>
+        </div>
+      </div>
+    </div>
+
+    <!-- Selezione squadra per cambi -->
+    <div class="overlay" v-if="showCambiTeam" @click.self="showCambiTeam = false">
+      <div class="dialog">
+        <div class="dialog-title">Scegli squadra</div>
+        <div class="dialog-buttons">
+          <button class="btn btn-set home-bg" @click="openCambi('home')">{{ state.sp.nomi.home }}</button>
+          <button class="btn btn-set guest-bg" @click="openCambi('guest')">{{ state.sp.nomi.guest }}</button>
+        </div>
+      </div>
+    </div>
+
+    <!-- Finestra gestione cambi -->
+    <div class="overlay" v-if="showCambi" @click.self="closeCambi()">
+      <div class="dialog">
+        <div class="dialog-title">{{ state.sp.nomi[cambiTeam] }}: CAMBIO</div>
+        <div class="cambi-container">
+          <div class="cambio-row" v-for="(c, i) in cambiData" :key="i">
+            <input type="text" v-model="c.in" placeholder="IN" class="input-num cambi-in-field" />
+            <span class="cambio-arrow">→</span>
+            <input type="text" v-model="c.out" placeholder="OUT" class="input-num cambi-out-field" />
+          </div>
+        </div>
+        <div v-if="cambiError" class="cambi-error">{{ cambiError }}</div>
+        <div class="dialog-buttons">
+          <button class="btn btn-cancel" @click="closeCambi()">Annulla</button>
+          <button class="btn btn-confirm" :disabled="!cambiValid" @click="confermaCambi()">CONFERMA</button>
+        </div>
+      </div>
+    </div>
+  </section>
+</template>
+
+<script>
+export default {
+  name: "ControllerPage",
+  data() {
+    return {
+      ws: null,
+      wsConnected: false,
+      isConnecting: false,
+      reconnectTimeout: null,
+      reconnectAttempts: 0,
+      maxReconnectDelay: 30000,
+      confirmReset: false,
+      showSetVinto: false,
+      setVintoTeam: null,
+      showConfig: false,
+      showCambiTeam: false,
+      showCambi: false,
+      cambiTeam: "home",
+      cambiData: [
+        { in: "", out: "" },
+        { in: "", out: "" },
+      ],
+      cambiError: "",
+      configData: {
+        nomeHome: "",
+        nomeGuest: "",
+        modalita: "3/5",
+        formHome: ["1", "2", "3", "4", "5", "6"],
+        formGuest: ["1", "2", "3", "4", "5", "6"],
+      },
+      state: {
+        order: true,
+        visuForm: false,
+        visuStriscia: true,
+        modalitaPartita: "3/5",
+        sp: {
+          striscia: [{ serv: 'home', r: [] }],
+          servHome: true,
+          punt: { home: 0, guest: 0 },
+          set: { home: 0, guest: 0 },
+          nomi: { home: "Antoniana", guest: "Guest" },
+          form: {
+            home: ["1", "2", "3", "4", "5", "6"],
+            guest: ["1", "2", "3", "4", "5", "6"],
+          },
+        },
+      },
+    }
+  },
+  computed: {
+    isPunteggioZeroZero() {
+      return this.state.sp.punt.home === 0 && this.state.sp.punt.guest === 0
+    },
+    squadraVincente() {
+      const { home, guest } = this.state.sp.punt
+      const totSet = this.state.sp.set.home + this.state.sp.set.guest
+      const isSetDecisivo = this.state.modalitaPartita === '2/3' ? totSet >= 2 : totSet >= 4
+      const soglia = isSetDecisivo ? 15 : 25
+      if (home >= soglia && home - guest >= 2) return 'home'
+      if (guest >= soglia && guest - home >= 2) return 'guest'
+      return null
+    },
+    cambiValid() {
+      let hasComplete = false
+      let allValid = true
+      this.cambiData.forEach((c) => {
+        const cin = (c.in || "").trim()
+        const cout = (c.out || "").trim()
+        if (!cin && !cout) return
+        if (!cin || !cout) { allValid = false; return }
+        hasComplete = true
+      })
+      return allValid && hasComplete
+    }
+  },
+  watch: {
+    squadraVincente(val) {
+      if (val && !this.showSetVinto) {
+        this.setVintoTeam = val
+        this.showSetVinto = true
+      }
+    },
+  },
+  mounted() {
+    this.connectWebSocket()
+
+    // Gestisce l'HMR di Vite evitando riconnessioni durante la ricarica a caldo.
+    if (import.meta.hot) {
+      import.meta.hot.on('vite:beforeUpdate', () => {
+        // Annulla eventuali tentativi di riconnessione pianificati.
+        if (this.reconnectTimeout) {
+          clearTimeout(this.reconnectTimeout)
+          this.reconnectTimeout = null
+        }
+      })
+    }
+  },
+  beforeUnmount() {
+    // Pulisce il timeout di riconnessione.
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout)
+      this.reconnectTimeout = null
+    }
+
+    // Chiude il WebSocket con il codice di chiusura appropriato.
+    if (this.ws) {
+      this.ws.onclose = null // Rimuove il listener per evitare nuove riconnessioni pianificate.
+      this.ws.onerror = null
+      this.ws.onmessage = null
+      this.ws.onopen = null
+
+      // Usa il codice 1000 (chiusura normale) se la connessione e aperta.
+      try {
+        if (this.ws.readyState === WebSocket.OPEN) {
+          this.ws.close(1000, 'Component unmounting')
+        } else if (this.ws.readyState === WebSocket.CONNECTING) {
+          // Se la connessione e ancora in fase di apertura, chiude direttamente.
+          this.ws.close()
+        }
+      } catch (err) {
+        console.error('[Controller] Error closing WebSocket:', err)
+      }
+      this.ws = null
+    }
+  },
+  methods: {
+    connectWebSocket() {
+      // Evita connessioni simultanee multiple.
+      if (this.isConnecting) {
+        console.log('[Controller] Already connecting, skipping...')
+        return
+      }
+
+      // Chiude la connessione precedente, se presente.
+      if (this.ws) {
+        this.ws.onclose = null
+        this.ws.onerror = null
+        this.ws.onmessage = null
+        this.ws.onopen = null
+        try {
+          if (this.ws.readyState === WebSocket.OPEN) {
+            this.ws.close(1000, 'Reconnecting')
+          } else if (this.ws.readyState === WebSocket.CONNECTING) {
+            this.ws.close()
+          }
+        } catch (err) {
+          console.error('[Controller] Error closing previous WebSocket:', err)
+        }
+        this.ws = null
+      }
+
+      this.isConnecting = true
+      const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:'
+
+      // Permette di specificare un host WebSocket alternativo via query parameter
+      // Utile per scenari WSL2 o development remoto: ?wsHost=192.168.1.100:3001
+      const params = new URLSearchParams(location.search)
+      const defaultHost = (
+        location.hostname === 'localhost' || location.hostname === '::1'
+      )
+        ? `127.0.0.1${location.port ? `:${location.port}` : ''}`
+        : location.host
+      const wsHost = params.get('wsHost') || defaultHost
+      const wsUrl = `${protocol}//${wsHost}/ws`
+
+      console.log('[Controller] Connecting to WebSocket:', wsUrl)
+
+      try {
+        this.ws = new WebSocket(wsUrl)
+      } catch (err) {
+        console.error('[Controller] Failed to create WebSocket:', err)
+        this.isConnecting = false
+        this.scheduleReconnect()
+        return
+      }
+
+      this.ws.onopen = () => {
+        this.isConnecting = false
+        this.wsConnected = true
+        this.reconnectAttempts = 0
+        console.log('[Controller] Connected to server')
+
+        // Invia la registrazione solo se la connessione e realmente aperta.
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+          try {
+            this.ws.send(JSON.stringify({ type: 'register', role: 'controller' }))
+          } catch (err) {
+            console.error('[Controller] Failed to register:', err)
+          }
+        }
+      }
+
+      this.ws.onmessage = (event) => {
+        try {
+          const msg = JSON.parse(event.data)
+
+          if (msg.type === 'state') {
+            this.state = msg.state
+          } else if (msg.type === 'error') {
+            console.error('[Controller] Server error:', msg.message)
+            // Fornisce feedback di errore all'utente.
+            this.showErrorFeedback(msg.message)
+          }
+        } catch (e) {
+          console.error('[Controller] Parse error:', e)
+        }
+      }
+
+      this.ws.onclose = (event) => {
+        this.isConnecting = false
+        this.wsConnected = false
+        console.log('[Controller] Disconnected from server', event.code, event.reason)
+
+        // Non riconnette durante HMR (codice 1001, "going away")
+        // ne in caso di chiusura pulita (codice 1000).
+        if (event.code === 1000 || event.code === 1001) {
+          console.log('[Controller] Clean close, not reconnecting')
+          return
+        }
+
+        this.scheduleReconnect()
+      }
+
+      this.ws.onerror = (err) => {
+        console.error('[Controller] WebSocket error:', err)
+        this.isConnecting = false
+        this.wsConnected = false
+      }
+    },
+
+    scheduleReconnect() {
+      // Evita pianificazioni multiple della riconnessione.
+      if (this.reconnectTimeout) {
+        return
+      }
+
+      // Applica backoff esponenziale: 1s, 2s, 4s, 8s, 16s, fino a 30s.
+      const delay = Math.min(
+        1000 * Math.pow(2, this.reconnectAttempts),
+        this.maxReconnectDelay
+      )
+      this.reconnectAttempts++
+
+      console.log(`[Controller] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`)
+
+      this.reconnectTimeout = setTimeout(() => {
+        this.reconnectTimeout = null
+        this.connectWebSocket()
+      }, delay)
+    },
+
+    sendAction(action) {
+      if (!this.wsConnected || !this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        console.warn('[Controller] Cannot send action: not connected')
+        this.showErrorFeedback('Non connesso al server')
+        return
+      }
+
+      // Valida l'azione prima dell'invio.
+      if (!action || !action.type) {
+        console.error('[Controller] Invalid action format:', action)
+        return
+      }
+
+      try {
+        this.ws.send(JSON.stringify({ type: 'action', action }))
+      } catch (err) {
+        console.error('[Controller] Failed to send action:', err)
+        this.showErrorFeedback('Errore invio comando')
+      }
+    },
+
+    showErrorFeedback(message) {
+      // Feedback visivo degli errori: attualmente solo log su console.
+      // In futuro puo essere esteso con notifiche a comparsa (toast).
+      console.error('[Controller] Error:', message)
+    },
+
+    doReset() {
+      this.sendAction({ type: 'resetta' })
+      this.confirmReset = false
+    },
+
+    undoUltimoPoint() {
+      this.sendAction({ type: 'decPunt' })
+      this.showSetVinto = false
+    },
+
+    doNuovoSet() {
+      this.sendAction({ type: 'nuovoSet', team: this.setVintoTeam })
+      this.showSetVinto = false
+      this.configData.nomeHome = this.state.sp.nomi.home
+      this.configData.nomeGuest = this.state.sp.nomi.guest
+      this.configData.modalita = this.state.modalitaPartita
+      this.configData.formHome = ["1", "2", "3", "4", "5", "6"]
+      this.configData.formGuest = ["1", "2", "3", "4", "5", "6"]
+      this.showConfig = true
+    },
+
+    openConfig() {
+      this.configData.nomeHome = this.state.sp.nomi.home
+      this.configData.nomeGuest = this.state.sp.nomi.guest
+      this.configData.modalita = this.state.modalitaPartita
+      this.configData.formHome = [...this.state.sp.form.home]
+      this.configData.formGuest = [...this.state.sp.form.guest]
+      this.showConfig = true
+    },
+
+    saveConfig() {
+      this.sendAction({ type: 'setNomi', home: this.configData.nomeHome, guest: this.configData.nomeGuest })
+      this.sendAction({ type: 'setModalita', modalita: this.configData.modalita })
+      this.sendAction({ type: 'setFormazione', team: 'home', form: this.configData.formHome })
+      this.sendAction({ type: 'setFormazione', team: 'guest', form: this.configData.formGuest })
+      this.showConfig = false
+    },
+
+    openCambiTeam() {
+      this.showCambiTeam = true
+    },
+
+    openCambi(team) {
+      this.showCambiTeam = false
+      this.cambiTeam = team
+      this.cambiData = [{ in: "", out: "" }, { in: "", out: "" }]
+      this.cambiError = ""
+      this.showCambi = true
+    },
+
+    closeCambi() {
+      this.showCambi = false
+      this.cambiData = [{ in: "", out: "" }, { in: "", out: "" }]
+      this.cambiError = ""
+    },
+
+    confermaCambi() {
+      if (!this.cambiValid) return
+      this.cambiError = ""
+
+      const cambi = this.cambiData
+        .filter(c => (c.in || "").trim() && (c.out || "").trim())
+        .map(c => ({ in: c.in.trim(), out: c.out.trim() }))
+
+      // Simula i cambi in sequenza per validare
+      const formCorrente = this.state.sp.form[this.cambiTeam].map(v => String(v).trim())
+      const formSimulata = [...formCorrente]
+
+      for (const cambio of cambi) {
+        if (!/^\d+$/.test(cambio.in) || !/^\d+$/.test(cambio.out)) {
+          this.cambiError = "I numeri dei giocatori devono essere cifre"
+          return
+        }
+        if (cambio.in === cambio.out) {
+          this.cambiError = `Il giocatore ${cambio.in} non può sostituire sé stesso`
+          return
+        }
+        if (formSimulata.includes(cambio.in)) {
+          this.cambiError = `Il giocatore ${cambio.in} è già in formazione`
+          return
+        }
+        if (!formSimulata.includes(cambio.out)) {
+          this.cambiError = `Il giocatore ${cambio.out} non è in formazione`
+          return
+        }
+        const idx = formSimulata.indexOf(cambio.out)
+        formSimulata.splice(idx, 1, cambio.in)
+      }
+
+      this.sendAction({ type: 'confermaCambi', team: this.cambiTeam, cambi })
+      this.closeCambi()
+    },
+
+    speak() {
+      let text = ''
+      if (this.state.sp.punt.home + this.state.sp.punt.guest === 0) {
+        text = "zero a zero"
+      } else if (this.state.sp.punt.home === this.state.sp.punt.guest) {
+        text = this.state.sp.punt.home + " pari"
+      } else {
+        if (this.state.sp.servHome) {
+          text = this.state.sp.punt.home + " a " + this.state.sp.punt.guest
+        } else {
+          text = this.state.sp.punt.guest + " a " + this.state.sp.punt.home
+        }
+      }
+      if (!this.wsConnected || !this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        this.showErrorFeedback('Non connesso al server')
+        return
+      }
+
+      try {
+        this.ws.send(JSON.stringify({ type: 'speak', text }))
+      } catch (err) {
+        console.error('[Controller] Failed to send speak command:', err)
+        this.showErrorFeedback('Errore invio comando voce')
+      }
+    }
+  }
+}
+</script>
+
+<style scoped>
+.controller-page {
+  min-height: 100vh;
+  background: #111;
+  color: #fff;
+  padding: 8px;
+  padding-top: 36px;
+  font-family: 'Inter', system-ui, sans-serif;
+  -webkit-user-select: none;
+  user-select: none;
+}
+
+/* Barra stato connessione */
+.conn-bar {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  height: 28px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  font-size: 12px;
+  font-weight: 600;
+  background: #c62828;
+  color: white;
+  z-index: 200;
+  transition: background 0.3s;
+}
+.conn-bar.connected {
+  background: #2e7d32;
+}
+.dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background: white;
+}
+
+/* Anteprima punteggio */
+.score-preview {
+  display: flex;
+  gap: 8px;
+  margin-bottom: 8px;
+}
+.team-score {
+  flex: 1;
+  border-radius: 16px;
+  padding: 16px 12px;
+  text-align: center;
+  cursor: pointer;
+  position: relative;
+  transition: transform 0.1s;
+  min-height: 120px;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+}
+.team-score:active {
+  transform: scale(0.97);
+}
+.home-bg {
+  background: linear-gradient(145deg, #1a1a1a, #333);
+  border: 2px solid #fdd835;
+  color: #fdd835;
+}
+.guest-bg {
+  background: linear-gradient(145deg, #0d47a1, #1565c0);
+  border: 2px solid #64b5f6;
+  color: #fff;
+}
+.team-name {
+  font-size: 14px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 1px;
+  margin-bottom: 4px;
+}
+.team-pts {
+  font-size: 56px;
+  font-weight: 900;
+  line-height: 1;
+}
+.team-set {
+  font-size: 13px;
+  font-weight: 600;
+  opacity: 0.75;
+  margin-top: 4px;
+}
+.serv-icon {
+  position: absolute;
+  top: 8px;
+  right: 8px;
+  width: 20px;
+  height: 20px;
+}
+
+/* Riga annulla punto */
+.undo-row {
+  margin-bottom: 8px;
+}
+.btn-undo {
+  width: 100%;
+  background: rgba(255,255,255,0.08);
+  border: 1px solid rgba(255,255,255,0.2);
+  color: #ffab91;
+  padding: 10px;
+  font-size: 14px;
+  font-weight: 700;
+  border-radius: 12px;
+  cursor: pointer;
+}
+.btn-undo:active {
+  background: rgba(255,100,50,0.2);
+}
+
+/* Pulsanti set */
+.action-row {
+  display: flex;
+  gap: 8px;
+  margin-bottom: 8px;
+}
+.btn-set {
+  flex: 1;
+  padding: 12px;
+  font-size: 13px;
+  font-weight: 700;
+  border-radius: 12px;
+  cursor: pointer;
+  border: none;
+  text-transform: uppercase;
+}
+.btn-set:active {
+  transform: scale(0.97);
+}
+
+/* Griglia controlli */
+.controls {
+  display: grid;
+  grid-template-columns: repeat(2, 1fr);
+  gap: 8px;
+}
+
+.btn {
+  border: none;
+  font-family: inherit;
+  cursor: pointer;
+  -webkit-tap-highlight-color: transparent;
+}
+
+.btn-ctrl {
+  background: rgba(255,255,255,0.08);
+  border: 1px solid rgba(255,255,255,0.15);
+  color: #e0e0e0;
+  padding: 14px 8px;
+  font-size: 14px;
+  font-weight: 600;
+  border-radius: 12px;
+  transition: background 0.15s;
+}
+.btn-ctrl:active {
+  background: rgba(255,255,255,0.18);
+}
+.btn-ctrl:disabled {
+  opacity: 0.35;
+}
+
+.btn-danger {
+  background: rgba(198, 40, 40, 0.25);
+  border: 1px solid rgba(239, 83, 80, 0.4);
+  color: #ff8a80;
+  padding: 14px 8px;
+  font-size: 14px;
+  font-weight: 600;
+  border-radius: 12px;
+}
+.btn-danger:active {
+  background: rgba(198, 40, 40, 0.45);
+}
+
+/* Overlay e finestre modali */
+.overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(0,0,0,0.75);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 300;
+  padding: 16px;
+}
+
+.dialog {
+  background: #1e1e1e;
+  border-radius: 20px;
+  padding: 24px;
+  width: 100%;
+  max-width: 400px;
+  border: 1px solid rgba(255,255,255,0.12);
+}
+
+.dialog-winner {
+  font-size: 28px;
+  font-weight: 900;
+  text-align: center;
+  margin-bottom: 8px;
+}
+
+.dialog-subtitle {
+  font-size: 13px;
+  color: #aaa;
+  text-align: center;
+  margin-bottom: 4px;
+}
+
+.dialog-config {
+  max-height: 85vh;
+  overflow-y: auto;
+}
+
+.dialog-title {
+  font-size: 18px;
+  font-weight: 800;
+  text-align: center;
+  margin-bottom: 20px;
+  padding-bottom: 12px;
+  border-bottom: 1px solid rgba(255,255,255,0.12);
+}
+
+.dialog-buttons {
+  display: flex;
+  gap: 12px;
+  margin-top: 20px;
+}
+
+.btn-cancel {
+  flex: 1;
+  background: rgba(255,255,255,0.08);
+  color: #aaa;
+  padding: 12px;
+  border-radius: 12px;
+  font-size: 15px;
+  font-weight: 600;
+}
+
+.btn-confirm {
+  flex: 1;
+  background: #2e7d32;
+  color: white;
+  padding: 12px;
+  border-radius: 12px;
+  font-size: 15px;
+  font-weight: 700;
+}
+.btn-confirm:disabled {
+  opacity: 0.4;
+}
+
+/* Gruppi form */
+.form-group {
+  margin-bottom: 16px;
+}
+.form-group label {
+  display: block;
+  font-size: 13px;
+  font-weight: 600;
+  color: #aaa;
+  margin-bottom: 6px;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+}
+.input-field {
+  width: 100%;
+  background: rgba(255,255,255,0.08);
+  border: 1px solid rgba(255,255,255,0.2);
+  color: white;
+  padding: 10px 14px;
+  border-radius: 10px;
+  font-size: 16px;
+  box-sizing: border-box;
+}
+.input-field:focus {
+  outline: none;
+  border-color: #64b5f6;
+}
+
+.input-num {
+  width: 52px;
+  background: rgba(255,255,255,0.08);
+  border: 1px solid rgba(255,255,255,0.2);
+  color: white;
+  padding: 8px;
+  border-radius: 8px;
+  font-size: 18px;
+  text-align: center;
+  box-sizing: border-box;
+}
+.input-num:focus {
+  outline: none;
+  border-color: #64b5f6;
+}
+
+/* Griglia formazione */
+.form-grid {
+  background: rgba(205, 133, 63, 0.15);
+  border: 2px solid rgba(255,255,255,0.15);
+  border-radius: 12px;
+  padding: 12px;
+}
+.form-row {
+  display: flex;
+  justify-content: center;
+  gap: 10px;
+  padding: 8px 0;
+}
+.form-line {
+  border-top: 1px dashed rgba(255,255,255,0.3);
+  margin: 4px 0;
+}
+
+/* Pulsanti modalita */
+.mode-buttons {
+  display: flex;
+  gap: 8px;
+}
+.btn-mode {
+  flex: 1;
+  padding: 10px;
+  background: rgba(255,255,255,0.08);
+  color: #aaa;
+  border-radius: 10px;
+  font-size: 16px;
+  font-weight: 700;
+  transition: all 0.15s;
+}
+.btn-mode.active {
+  background: #2e7d32;
+  color: white;
+}
+
+/* Sezione cambi */
+.cambi-container {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+  padding: 8px 0;
+}
+.cambio-row {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 12px;
+}
+.cambio-arrow {
+  font-size: 20px;
+  font-weight: 700;
+  color: #aaa;
+}
+.cambi-in-field {
+  background: rgba(120, 200, 120, 0.2) !important;
+  border-color: rgba(120, 200, 120, 0.4) !important;
+}
+.cambi-out-field {
+  background: rgba(200, 120, 120, 0.2) !important;
+  border-color: rgba(200, 120, 120, 0.4) !important;
+}
+.cambi-error {
+  color: #ff6b6b;
+  font-size: 14px;
+  text-align: center;
+  padding: 8px 0;
+  font-weight: 600;
+}
+</style>

src/components/DisplayPage.vue

@@ -0,0 +1,444 @@
+<template>
+  <section class="display-page">
+    <div class="campo">
+      <span v-if="state.order">
+        <!-- Ordine visualizzazione: home / guest -->
+        <div class="hea home">
+          <span :style="{ 'float': 'left' }">
+            {{ state.sp.nomi.home }}
+            <span class="serv-slot">
+              <img v-show="state.sp.servHome" src="/serv.png" width="25" alt="Servizio" />
+            </span>
+            <span v-if="state.visuForm" class="score-inline">{{ state.sp.punt.home }}</span>
+          </span>
+          <span class="mr3" :style="{ 'float': 'right' }">set {{ state.sp.set.home }}</span>
+        </div>
+
+        <div class="hea guest">
+          <span :style="{ 'float': 'right' }">
+            <span v-if="state.visuForm" class="score-inline">{{ state.sp.punt.guest }}</span>
+            <span class="serv-slot">
+              <img v-show="!state.sp.servHome" src="/serv.png" width="25" alt="Servizio" />
+            </span>
+            {{ state.sp.nomi.guest }}
+          </span>
+          <span class="ml3" :style="{ 'float': 'left' }">set {{ state.sp.set.guest }}</span>
+        </div>
+
+        <span v-if="state.visuForm">
+          <div class="col form home">
+            <div class="formdiv" v-for="x in [3, 2, 1, 4, 5, 0]" :key="'hf'+x">
+              {{ state.sp.form.home[x] }}
+            </div>
+          </div>
+          <div class="col form guest">
+            <div class="formdiv" v-for="x in [3, 2, 1, 4, 5, 0]" :key="'gf'+x">
+              {{ state.sp.form.guest[x] }}
+            </div>
+          </div>
+        </span>
+        <span v-else>
+          <div class="punteggio-container">
+            <div class="col punt home">{{ state.sp.punt.home }}</div>
+            <div class="col punt guest">{{ state.sp.punt.guest }}</div>
+          </div>
+        </span>
+      </span>
+
+      <span v-else>
+        <!-- Ordine visualizzazione: guest / home -->
+        <div class="hea guest">
+          <span :style="{ 'float': 'left' }">
+            {{ state.sp.nomi.guest }}
+            <span class="serv-slot">
+              <img v-show="!state.sp.servHome" src="/serv.png" width="25" alt="Servizio" />
+            </span>
+            <span v-if="state.visuForm" class="score-inline">{{ state.sp.punt.guest }}</span>
+          </span>
+          <span class="mr3" :style="{ 'float': 'right' }">set {{ state.sp.set.guest }}</span>
+        </div>
+
+        <div class="hea home">
+          <span :style="{ 'float': 'right' }">
+            <span v-if="state.visuForm" class="score-inline">{{ state.sp.punt.home }}</span>
+            <span class="serv-slot">
+              <img v-show="state.sp.servHome" src="/serv.png" width="25" alt="Servizio" />
+            </span>
+            {{ state.sp.nomi.home }}
+          </span>
+          <span class="ml3" :style="{ 'float': 'left' }">set {{ state.sp.set.home }}</span>
+        </div>
+
+        <span v-if="state.visuForm">
+          <div class="col form guest">
+            <div class="formdiv" v-for="x in [3, 2, 1, 4, 5, 0]" :key="'gf2'+x">
+              {{ state.sp.form.guest[x] }}
+            </div>
+          </div>
+          <div class="col form home">
+            <div class="formdiv" v-for="x in [3, 2, 1, 4, 5, 0]" :key="'hf2'+x">
+              {{ state.sp.form.home[x] }}
+            </div>
+          </div>
+        </span>
+        <span v-else>
+          <div class="punteggio-container">
+            <div class="col punt guest">{{ state.sp.punt.guest }}</div>
+            <div class="col punt home">{{ state.sp.punt.home }}</div>
+          </div>
+        </span>
+      </span>
+
+      <div class="striscia" v-if="state.visuStriscia">
+        <span class="striscia-nome text-bold">{{ state.sp.nomi.home }}</span>
+        <div class="striscia-items" ref="homeItems">
+          <div v-for="(h, i) in stricciaStrip.home" :key="'sh'+i"
+               class="item" :class="{ 'item-vuoto': h === ' ' }">
+            {{ h }}
+          </div>
+        </div>
+        <span class="striscia-nome text-bold guest-striscia">{{ state.sp.nomi.guest }}</span>
+        <div class="striscia-items guest-striscia" ref="guestItems">
+          <div v-for="(h, i) in stricciaStrip.guest" :key="'sg'+i"
+               class="item" :class="{ 'item-vuoto': h === ' ' }">
+            {{ h }}
+          </div>
+        </div>
+      </div>
+
+      <!-- Indicatore stato connessione -->
+      <div class="connection-status" :class="{ connected: wsConnected, disconnected: !wsConnected }">
+        <span class="dot"></span>
+        {{ wsConnected ? '' : 'Disconnesso' }}
+      </div>
+    </div>
+  </section>
+</template>
+
+<script>
+export default {
+  name: "DisplayPage",
+  data() {
+    return {
+      ws: null,
+      wsConnected: false,
+      isConnecting: false,
+      reconnectTimeout: null,
+      reconnectAttempts: 0,
+      maxReconnectDelay: 30000, // Ritardo massimo di riconnessione: 30 secondi
+      state: {
+        order: true,
+        visuForm: false,
+        visuStriscia: true,
+        modalitaPartita: "3/5",
+        sp: {
+          striscia: [{ serv: 'home', r: [] }],
+          servHome: true,
+          punt: { home: 0, guest: 0 },
+          set: { home: 0, guest: 0 },
+          nomi: { home: "Antoniana", guest: "Guest" },
+          form: {
+            home: ["1", "2", "3", "4", "5", "6"],
+            guest: ["1", "2", "3", "4", "5", "6"],
+          },
+        },
+      },
+    }
+  },
+  mounted() {
+    this.connectWebSocket()
+    // Attiva la modalita fullscreen su dispositivi mobili.
+    if (this.isMobile()) {
+      try { document.documentElement.requestFullscreen() } catch (e) {}
+    }
+
+    // Gestisce l'HMR di Vite evitando riconnessioni durante la ricarica a caldo.
+    if (import.meta.hot) {
+      import.meta.hot.on('vite:beforeUpdate', () => {
+        // Annulla eventuali tentativi di riconnessione pianificati.
+        if (this.reconnectTimeout) {
+          clearTimeout(this.reconnectTimeout)
+          this.reconnectTimeout = null
+        }
+      })
+    }
+  },
+  beforeUnmount() {
+    // Pulisce il timeout di riconnessione.
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout)
+      this.reconnectTimeout = null
+    }
+
+    // Chiude il WebSocket con il codice di chiusura appropriato.
+    if (this.ws) {
+      this.ws.onclose = null // Rimuove il listener per evitare nuove riconnessioni pianificate.
+      this.ws.onerror = null
+      this.ws.onmessage = null
+      this.ws.onopen = null
+
+      // Usa il codice 1000 (chiusura normale) se la connessione e aperta.
+      try {
+        if (this.ws.readyState === WebSocket.OPEN) {
+          this.ws.close(1000, 'Component unmounting')
+        } else if (this.ws.readyState === WebSocket.CONNECTING) {
+          // Se la connessione e ancora in fase di apertura, chiude direttamente.
+          this.ws.close()
+        }
+      } catch (err) {
+        console.error('[Display] Error closing WebSocket:', err)
+      }
+      this.ws = null
+    }
+  },
+  computed: {
+    stricciaStrip() {
+      const currentSet = this.state.sp.striscia.at(-1)
+      if (!currentSet) return { home: [], guest: [] }
+      let h = 0, g = 0
+      const home = [], guest = []
+      for (const scorer of currentSet.r) {
+        if (scorer === 'home') { h++; home.push(h); guest.push(' ') }
+        else               { g++; guest.push(g); home.push(' ') }
+      }
+      return { home, guest }
+    },
+  },
+  watch: {
+    'state.sp.striscia': {
+      deep: true,
+      handler() {
+        this.$nextTick(() => {
+          if (this.$refs.homeItems)  this.$refs.homeItems.scrollLeft  = this.$refs.homeItems.scrollWidth
+          if (this.$refs.guestItems) this.$refs.guestItems.scrollLeft = this.$refs.guestItems.scrollWidth
+        })
+      }
+    },
+  },
+  methods: {
+    isMobile() {
+      return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)
+    },
+    connectWebSocket() {
+      // Evita connessioni simultanee multiple.
+      if (this.isConnecting) {
+        console.log('[Display] Already connecting, skipping...')
+        return
+      }
+
+      // Chiude la connessione precedente, se presente.
+      if (this.ws) {
+        this.ws.onclose = null
+        this.ws.onerror = null
+        this.ws.onmessage = null
+        this.ws.onopen = null
+        try {
+          if (this.ws.readyState === WebSocket.OPEN) {
+            this.ws.close(1000, 'Reconnecting')
+          } else if (this.ws.readyState === WebSocket.CONNECTING) {
+            this.ws.close()
+          }
+        } catch (err) {
+          console.error('[Display] Error closing previous WebSocket:', err)
+        }
+        this.ws = null
+      }
+
+      this.isConnecting = true
+      const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:'
+
+      // Permette di specificare un host WebSocket alternativo via query parameter
+      // Utile per scenari WSL2 o development remoto: ?wsHost=192.168.1.100:5173
+      const params = new URLSearchParams(location.search)
+      const defaultHost = (
+        location.hostname === 'localhost' || location.hostname === '::1'
+      )
+        ? `127.0.0.1${location.port ? `:${location.port}` : ''}`
+        : location.host
+      const wsHost = params.get('wsHost') || defaultHost
+      const wsUrl = `${protocol}//${wsHost}/ws`
+
+      console.log('[Display] Connecting to WebSocket:', wsUrl)
+
+      try {
+        this.ws = new WebSocket(wsUrl)
+      } catch (err) {
+        console.error('[Display] Failed to create WebSocket:', err)
+        this.isConnecting = false
+        this.scheduleReconnect()
+        return
+      }
+
+      this.ws.onopen = () => {
+        this.isConnecting = false
+        this.wsConnected = true
+        this.reconnectAttempts = 0
+        console.log('[Display] Connected to server')
+
+        // Registra il client come display solo con connessione effettivamente aperta.
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+          try {
+            this.ws.send(JSON.stringify({ type: 'register', role: 'display' }))
+          } catch (err) {
+            console.error('[Display] Failed to register:', err)
+          }
+        }
+      }
+
+      this.ws.onmessage = (event) => {
+        try {
+          const msg = JSON.parse(event.data)
+
+          if (msg.type === 'state') {
+            this.state = msg.state
+          } else if (msg.type === 'speak') {
+            this.speakOnDisplay(msg.text)
+          } else if (msg.type === 'error') {
+            console.error('[Display] Server error:', msg.message)
+          }
+        } catch (e) {
+          console.error('[Display] Error parsing message:', e)
+        }
+      }
+
+      this.ws.onclose = (event) => {
+        this.isConnecting = false
+        this.wsConnected = false
+        console.log('[Display] Disconnected from server', event.code, event.reason)
+
+        // Non riconnette durante HMR (codice 1001, "going away")
+        // ne in caso di chiusura pulita (codice 1000).
+        if (event.code === 1000 || event.code === 1001) {
+          console.log('[Display] Clean close, not reconnecting')
+          return
+        }
+
+        this.scheduleReconnect()
+      }
+
+      this.ws.onerror = (err) => {
+        console.error('[Display] WebSocket error:', err)
+        this.isConnecting = false
+        this.wsConnected = false
+      }
+    },
+    scheduleReconnect() {
+      // Evita pianificazioni multiple della riconnessione.
+      if (this.reconnectTimeout) {
+        return
+      }
+
+      // Applica backoff esponenziale: 1s, 2s, 4s, 8s, 16s, fino a 30s.
+      const delay = Math.min(
+        1000 * Math.pow(2, this.reconnectAttempts),
+        this.maxReconnectDelay
+      )
+      this.reconnectAttempts++
+
+      console.log(`[Display] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`)
+
+      this.reconnectTimeout = setTimeout(() => {
+        this.reconnectTimeout = null
+        this.connectWebSocket()
+      }, delay)
+    },
+    speakOnDisplay(text) {
+      if (typeof text !== 'string' || !text.trim()) {
+        return
+      }
+      if (!('speechSynthesis' in window)) {
+        console.warn('[Display] speechSynthesis not supported')
+        return
+      }
+
+      const utterance = new SpeechSynthesisUtterance(text.trim())
+      const voices = window.speechSynthesis.getVoices()
+      const preferredVoice = voices.find((v) => v.name === 'Google italiano')
+        || voices.find((v) => v.lang && v.lang.toLowerCase().startsWith('it'))
+      if (preferredVoice) {
+        utterance.voice = preferredVoice
+      }
+      utterance.lang = 'it-IT'
+
+      window.speechSynthesis.cancel()
+      window.speechSynthesis.speak(utterance)
+    }
+  }
+}
+</script>
+
+<style scoped>
+.display-page {
+  width: 100%;
+  height: 100vh;
+  background: #000;
+  overflow: hidden;
+}
+
+.connection-status {
+  position: fixed;
+  top: 8px;
+  right: 8px;
+  font-size: 12px;
+  padding: 4px 10px;
+  border-radius: 12px;
+  display: flex;
+  align-items: center;
+  gap: 5px;
+  z-index: 100;
+  transition: opacity 0.5s;
+}
+
+.connection-status.connected {
+  opacity: 0;
+}
+
+.connection-status.disconnected {
+  background: rgba(255, 50, 50, 0.8);
+  color: white;
+  opacity: 1;
+}
+
+.dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  display: inline-block;
+}
+
+.connected .dot {
+  background: #4caf50;
+}
+
+.disconnected .dot {
+  background: #f44336;
+  animation: blink 1s infinite;
+}
+
+@keyframes blink {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.3; }
+}
+
+.guest-striscia {
+  color: white;
+}
+
+.punteggio-container {
+  width: 100%;
+  display: flex;
+}
+
+.punt {
+  font-size: 60vh;
+  flex: 1;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  min-height: 50vh;
+  min-width: 50vw;
+  max-width: 50vw;
+  overflow: hidden;
+  box-sizing: border-box;
+}
+</style>

src/components/HomePage.vue

@@ -1,220 +0,0 @@
-<script>
-import NoSleep from "nosleep.js";
-export default {
-  name: "HomePage",
-  components: {},
-  data() {
-    return {
-      voices: null,
-      diaNomi: {
-        show: false,
-        home: "",
-        guest: "",
-      },
-      visuForm: false,
-      visuButt: true,
-      sp: {
-        servHome: true,
-        punt: { home: 0, guest: 0 },
-        set: { home: 0, guest: 0 },
-        nomi: { home: "Antoniana", guest: "Guest" },
-        form: {
-          home: ["1", "2", "3", "4", "5", "6"],
-          guest: ["1", "2", "3", "4", "5", "6"],
-        },
-      },
-    }
-  },
-  mounted() {
-    this.voices = window.speechSynthesis.getVoices();
-    if (this.isMobile()) {
-      this.speak();
-      var noSleep = new NoSleep();
-      noSleep.enable();
-      document.documentElement.requestFullscreen();
-    }
-    this.abilitaTastiSpeciali();
-  },
-  methods: {
-    closeApp() {
-      var win = window.open("", "_self");
-      win.close();
-    },
-    fullScreen() {
-      document.documentElement.requestFullscreen();
-    },
-    isMobile() {
-      if (
-        /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
-          navigator.userAgent
-        )
-      ) {
-        return true;
-      } else {
-        return false;
-      }
-    },
-    resetta() {
-      this.$waveui.notify("Punteggio<br />RESETTATO", "success");
-      this.visuForm = false;
-      this.sp.punt.home = 0;
-      this.sp.punt.guest = 0;
-      this.sp.form = {
-        home: ["1", "2", "3", "4", "5", "6"],
-        guest: ["1", "2", "3", "4", "5", "6"],
-      }
-    },
-    incSet(team) {
-      if (this.sp.set[team] == 2) {
-        this.sp.set[team] = 0;
-      } else {
-        this.sp.set[team]++;
-      }
-    },
-    incPunt(team) {
-      this.sp.punt[team]++;
-      this.sp.servHome = (team == "home");
-      this.sp.form[team].push(this.sp.form[team].shift());
-    },
-    decPunt(team) {
-      // decrementa il punteggio se è > 0.
-      if (this.sp.punt[team] > 0) {
-        this.sp.punt[team]--;
-        this.sp.form[team].unshift(this.sp.form[team].pop());
-      }
-    },
-    speak() {
-      const msg = new SpeechSynthesisUtterance();
-      if (this.sp.punt.home + this.sp.punt.guest == 0) {
-        msg.text = "zero a zero";
-      } else if (this.sp.punt.home == this.sp.punt.guest) {
-        msg.text = this.sp.punt.home + " pari";
-      } else {
-        if (this.sp.servHome) {
-          msg.text = this.sp.punt.home + " a " + this.sp.punt.guest;
-        } else {
-          msg.text = this.sp.punt.guest + " a " + this.sp.punt.home;
-        }
-      }
-      // msg.volume = 1.0; // speech volume (default: 1.0)
-      // msg.pitch = 1.0; // speech pitch (default: 1.0)
-      // msg.rate = 1.0; // speech rate (default: 1.0)
-      msg.lang = 'it_IT'; // speech language (default: 'en-US')
-      const voices = window.speechSynthesis.getVoices();
-      msg.voice = voices.find(voice => voice.name === 'Google italiano'); // voice URI (default: platform-dependent)
-      // msg.onboundary = function (event) {
-      //   console.log('Speech reached a boundary:', event.name);
-      // };
-      // msg.onpause = function (event) {
-      //   console.log('Speech paused:', event.utterance.text.substring(event.charIndex));
-      // };
-      window.speechSynthesis.speak(msg);
-    },
-    apriDialogConfig() {
-      this.disabilitaTastiSpeciali();
-      this.diaNomi.show = true;
-    },
-    disabilitaTastiSpeciali() {
-      window.removeEventListener("keydown", this.funzioneTastiSpeciali);
-    },
-    abilitaTastiSpeciali() {
-      window.addEventListener("keydown", this.funzioneTastiSpeciali);
-    },
-    funzioneTastiSpeciali(e) {
-      e.preventDefault();
-      if (e.ctrlKey && e.key == "m") {
-        this.diaNomi.show = true
-      } else if (e.ctrlKey && e.key == "b") {
-        this.visuButt = !this.visuButt
-      } else if (e.ctrlKey && e.key == "f") {
-        document.documentElement.requestFullscreen();
-      } else if (e.ctrlKey && e.key == "s") {
-        this.speak();
-      } else if (e.ctrlKey && e.key == "z") {
-        this.visuForm = !this.visuForm
-      } else if (e.ctrlKey && e.key == "ArrowUp") {
-        this.incPunt("home")
-      } else if (e.ctrlKey && e.key == "ArrowDown") {
-        this.decPunt("home")
-      } else if (e.ctrlKey && e.key == "ArrowRight") {
-        this.incSet("home")
-      } else if (e.shiftKey && e.key == "ArrowUp") {
-        this.incPunt("guest")
-      } else if (e.shiftKey && e.key == "ArrowDown") {
-        this.decPunt("guest")
-      } else if (e.shiftKey && e.key == "ArrowRight") {
-        this.incSet("guest")
-      } else if (e.ctrlKey && e.key == "ArrowLeft") {
-        this.sp.servHome = !this.sp.servHome
-      } else { return false }
-    }
-  }
-};
-</script>
-
-<template>
-  <w-dialog v-model="diaNomi.show" :width="500" @close="abilitaTastiSpeciali()">
-    <w-input v-model="sp.nomi.home" type="text" class="pa3">Home</w-input>
-    <w-input v-model="sp.nomi.guest" type="text" class="pa3">Guest</w-input>
-    <w-button bg-color="success" @click="diaNomi.show = false">
-      Ok
-    </w-button>
-  </w-dialog>
-  <div class="campo">
-    <div class="hea home">
-      <span @click="decPunt('home')" :style="{ 'float': 'left' }">
-        {{ sp.nomi.home }} <img v-if="sp.servHome" src="/serv.png" width="25" />
-        <span v-if="visuForm">{{ sp.punt.home }}</span>
-      </span>
-      <span @click="incSet('home')" class="mr3" :style="{ 'float': 'right' }">set {{ sp.set.home }}</span>
-    </div>
-    <div class="hea guest">
-      <span @click="decPunt('guest')" :style="{ 'float': 'right' }">
-        <img v-if="!sp.servHome" src="/serv.png" width="25" /> {{ sp.nomi.guest }}
-        <span v-if="visuForm">{{ sp.punt.guest }}</span>
-      </span>
-      <span @click="incSet('guest')" class="ml3" :style="{ 'float': 'left' }">set {{ sp.set.guest }}</span>
-
-    </div>
-    <span v-if="visuForm">
-      <div class="col form home" @click="incPunt('home')">
-        <div class="formdiv" v-for="x in [3, 2, 1, 4, 5, 0]">
-          {{ sp.form.home[x] }}
-        </div>
-      </div>
-      <div class="col form guest" @click="incPunt('guest')">
-        <div class="formdiv" v-for="x in [3, 2, 1, 4, 5, 0]">
-          {{ sp.form.guest[x] }}
-        </div>
-      </div>
-    </span>
-    <span v-else>
-      <div class="col punt home" @click="incPunt('home')">{{ sp.punt.home }}</div>
-      <div class="col punt guest" @click="incPunt('guest')">{{ sp.punt.guest }}</div>
-    </span>
-
-    <div class="bot" v-if="visuButt">
-      <w-flex justify-space-between class="pa2">
-        <w-confirm right align-bottom v-if="isMobile()" question="CHIUDO ?" cancel="NO" confirm="SI" @confirm="closeApp">
-          <img src="/exit.png" width="25" />
-        </w-confirm>
-        <w-button @click="apriDialogConfig()">
-          <img src="/gear.png" width="25" />
-        </w-button>
-        <w-button @click="sp.servHome = !sp.servHome">
-          <img src="/serv.png" width="25" />
-        </w-button>
-        <w-confirm top left question="Azzero punteggio ?" cancel="NO" confirm="SI" @confirm="resetta">
-          RESET
-        </w-confirm>
-        <w-button @click="visuForm = !visuForm">
-          <span v-if="visuForm">PUNTEGGIO</span>
-          <span v-if="!visuForm">FORMAZIONI</span>
-        </w-button>
-        <w-button @click="speak">
-          <img src="/speaker.png" width="25" />
-        </w-button>
-      </w-flex>
-    </div>
-  </div>
-</template>

src/components/HomePage/HomePage.html

@@ -1,240 +0,0 @@
-<section class="homepage">
-    <w-dialog v-model="diaNomi.show" :width="600" @close="chiudiDialogConfig()">
-      <w-input v-model="sp.nomi.home" type="text" class="pa3" tabindex="1">Nome Home</w-input>
-      <w-input v-model="sp.nomi.guest" type="text" class="pa3" tabindex="2">Nome Guest</w-input>
-
-      <w-flex justify-center align-center class="pa3">
-        <span class="mr3">Modalità partita:</span>
-        <w-button
-          @click="modalitaPartita = '2/3'"
-          :bg-color="modalitaPartita === '2/3' ? 'success' : 'grey-light4'"
-          :dark="modalitaPartita === '2/3'"
-          class="ma1"
-          tabindex="-1">
-          2/3
-        </w-button>
-        <w-button
-          @click="modalitaPartita = '3/5'"
-          :bg-color="modalitaPartita === '3/5' ? 'success' : 'grey-light4'"
-          :dark="modalitaPartita === '3/5'"
-          class="ma1"
-          tabindex="-1">
-          3/5
-        </w-button>
-      </w-flex>
-
-      <w-flex justify-space-around class="pa3">
-        <div class="campo-config">
-          <div class="text-bold mb3 text-center">Formazione Home</div>
-          <div class="campo-pallavolo">
-            <!-- Fila anteriore - index [3, 2, 1] - VICINO ALLA RETE (prima fila visualizzata) -->
-            <w-flex justify-center class="fila-anteriore">
-              <w-input v-model="sp.form.home[3]" type="text" style="width: 50px; text-align: center;" class="ma1" tabindex="6"></w-input>
-              <w-input v-model="sp.form.home[2]" type="text" style="width: 50px; text-align: center;" class="ma1" tabindex="5"></w-input>
-              <w-input v-model="sp.form.home[1]" type="text" style="width: 50px; text-align: center;" class="ma1" tabindex="4"></w-input>
-            </w-flex>
-            <!-- Linea dei 3 metri -->
-            <div class="linea-tre-metri"></div>
-            <!-- Fila posteriore - index [4, 5, 0] - ZONA DIFESA (seconda fila visualizzata) -->
-            <w-flex justify-center class="fila-posteriore">
-              <w-input v-model="sp.form.home[4]" type="text" style="width: 50px; text-align: center;" class="ma1" tabindex="7"></w-input>
-              <w-input v-model="sp.form.home[5]" type="text" style="width: 50px; text-align: center;" class="ma1" tabindex="8"></w-input>
-              <w-input v-model="sp.form.home[0]" type="text" style="width: 50px; text-align: center;" class="ma1" tabindex="3"></w-input>
-            </w-flex>
-          </div>
-        </div>
-
-        <div class="campo-config">
-          <div class="text-bold mb3 text-center">Formazione Guest</div>
-          <div class="campo-pallavolo">
-            <!-- Fila anteriore - index [3, 2, 1] - VICINO ALLA RETE (prima fila visualizzata) -->
-            <w-flex justify-center class="fila-anteriore">
-              <w-input v-model="sp.form.guest[3]" type="text" style="width: 50px; text-align: center;" class="ma1" tabindex="12"></w-input>
-              <w-input v-model="sp.form.guest[2]" type="text" style="width: 50px; text-align: center;" class="ma1" tabindex="11"></w-input>
-              <w-input v-model="sp.form.guest[1]" type="text" style="width: 50px; text-align: center;" class="ma1" tabindex="10"></w-input>
-            </w-flex>
-            <!-- Linea dei 3 metri -->
-            <div class="linea-tre-metri"></div>
-            <!-- Fila posteriore - index [4, 5, 0] - ZONA DIFESA (seconda fila visualizzata) -->
-            <w-flex justify-center class="fila-posteriore">
-              <w-input v-model="sp.form.guest[4]" type="text" style="width: 50px; text-align: center;" class="ma1" tabindex="13"></w-input>
-              <w-input v-model="sp.form.guest[5]" type="text" style="width: 50px; text-align: center;" class="ma1" tabindex="14"></w-input>
-              <w-input v-model="sp.form.guest[0]" type="text" style="width: 50px; text-align: center;" class="ma1" tabindex="9"></w-input>
-            </w-flex>
-          </div>
-        </div>
-      </w-flex>
-
-      <w-button @click="order = !order" class="ma2" tabindex="-1">Inverti ordine</w-button>
-      <w-button bg-color="success" @click="diaNomi.show = false" class="ma2" tabindex="-1">
-        Ok
-      </w-button>
-    </w-dialog>
-    <w-dialog v-model="diaCambiTeam.show" :width="420" @close="abilitaTastiSpeciali()">
-      <div class="text-bold text-center mb2">Scegli squadra</div>
-      <w-flex justify-center class="pa3">
-        <w-button class="ma2" @click="selezionaTeamCambi('home')">{{ sp.nomi.home }}</w-button>
-        <w-button class="ma2" @click="selezionaTeamCambi('guest')">{{ sp.nomi.guest }}</w-button>
-      </w-flex>
-    </w-dialog>
-    <w-dialog v-model="diaCambi.show" :width="360" @close="chiudiDialogCambi">
-      <div class="cambi-dialog">
-        <div class="cambi-title">{{ sp.nomi[diaCambi.team] }}: CAMBIO</div>
-        <div class="cambi-rows">
-          <div class="cambi-row">
-            <w-input v-model="diaCambi[diaCambi.team].cambi[0].in" type="text" class="cambi-input cambi-in"></w-input>
-            <span class="cambi-arrow">→</span>
-            <w-input v-model="diaCambi[diaCambi.team].cambi[0].out" type="text" class="cambi-input cambi-out"></w-input>
-          </div>
-          <div class="cambi-row">
-            <w-input v-model="diaCambi[diaCambi.team].cambi[1].in" type="text" class="cambi-input cambi-in"></w-input>
-            <span class="cambi-arrow">→</span>
-            <w-input v-model="diaCambi[diaCambi.team].cambi[1].out" type="text" class="cambi-input cambi-out"></w-input>
-          </div>
-        </div>
-      </div>
-      <w-flex justify-end class="pa3">
-        <w-button bg-color="success" :disabled="!cambiConfermabili" @click="confermaCambi">
-          CONFERMA
-        </w-button>
-      </w-flex>
-    </w-dialog>
-    <div class="campo">
-
-      <span v-if="order">
-<!-- home guest -->
-      <div class="hea home">
-        <span @click="decPunt('home')" :style="{ 'float': 'left' }">
-          {{ sp.nomi.home }}
-          <span class="serv-slot">
-            <img v-show="sp.servHome" src="/serv.png" width="25" />
-          </span>
-          <span v-if="visuForm" class="score-inline">{{ sp.punt.home }}</span>
-        </span>
-        <span @click="incSet('home')" class="mr3" :style="{ 'float': 'right' }">set {{ sp.set.home }}</span>
-      </div>
-
-      <div class="hea guest">
-        <span @click="decPunt('guest')" :style="{ 'float': 'right' }">
-          <span v-if="visuForm" class="score-inline">{{ sp.punt.guest }}</span>
-          <span class="serv-slot">
-            <img v-show="!sp.servHome" src="/serv.png" width="25" />
-          </span>
-          {{ sp.nomi.guest }}
-        </span>
-        <span @click="incSet('guest')" class="ml3" :style="{ 'float': 'left' }">set {{ sp.set.guest }}</span>
-      </div>
-
-      <span v-if="visuForm">
-        <div class="col form home" @click="incPunt('home')">
-          <div class="formdiv" v-for="x in [3, 2, 1, 4, 5, 0]">
-            {{ sp.form.home[x] }}
-          </div>
-        </div>
-        <div class="col form guest" @click="incPunt('guest')">
-          <div class="formdiv" v-for="x in [3, 2, 1, 4, 5, 0]">
-            {{ sp.form.guest[x] }}
-          </div>
-        </div>
-      </span>
-      <span v-else>
-        <w-flex class="punteggio-container">
-          <w-flex justify-center align-center class="col punt home" @click="incPunt('home')">{{ sp.punt.home }}</w-flex>
-          <w-flex justify-center align-center class="col punt guest" @click="incPunt('guest')">{{ sp.punt.guest }}</w-flex>
-        </w-flex>
-      </span>
-  
-      </span>
-      <span v-else>
-<!-- guest home -->        
-
-      <div class="hea guest">
-        <span @click="decPunt('guest')" :style="{ 'float': 'left' }">
-          {{ sp.nomi.guest }}
-          <span class="serv-slot">
-            <img v-show="!sp.servHome" src="/serv.png" width="25" />
-          </span>
-          <span v-if="visuForm" class="score-inline">{{ sp.punt.guest }}</span>
-        </span>
-        <span @click="incSet('guest')" class="mr3" :style="{ 'float': 'right' }">set {{ sp.set.guest }}</span>
-      </div>
-
-      <div class="hea home">
-        <span @click="decPunt('home')" :style="{ 'float': 'right' }">
-          <span v-if="visuForm" class="score-inline">{{ sp.punt.home }}</span>
-          <span class="serv-slot">
-            <img v-show="sp.servHome" src="/serv.png" width="25" />
-          </span>
-          {{ sp.nomi.home }}
-        </span>
-        <span @click="incSet('home')" class="ml3" :style="{ 'float': 'left' }">set {{ sp.set.home }}</span>
-      </div>
-
-      <span v-if="visuForm">
-        <div class="col form guest" @click="incPunt('guest')">
-          <div class="formdiv" v-for="x in [3, 2, 1, 4, 5, 0]">
-            {{ sp.form.guest[x] }}
-          </div>
-        </div>
-        <div class="col form home" @click="incPunt('home')">
-          <div class="formdiv" v-for="x in [3, 2, 1, 4, 5, 0]">
-            {{ sp.form.home[x] }}
-          </div>
-        </div>
-      </span>
-      <span v-else>
-        <w-flex class="punteggio-container">
-          <w-flex justify-center align-center class="col punt guest" @click="incPunt('guest')">{{ sp.punt.guest }}</w-flex>
-          <w-flex justify-center align-center class="col punt home" @click="incPunt('home')">{{ sp.punt.home }}</w-flex>
-        </w-flex>
-      </span>
-
-      </span>
-      
-      <div class="striscia" v-if="visuStriscia">
-      <div>
-        <span class="text-bold mr1">{{ sp.nomi.home }}</span>
-        <div v-for="h in sp.striscia.home" class="item">
-          {{String(h)}}
-        </div>
-      </div>
-      <div class="guest">
-        <span class="text-bold mr1">{{ sp.nomi.guest }}</span>
-        <div v-for="h in sp.striscia.guest" class="item">
-          {{String(h)}}
-        </div>
-      </div>
-      </div>
-
-      <div class="bot" v-if="visuButt">
-        <w-flex justify-space-between class="pa2">
-          <w-confirm right align-bottom v-if="isMobile()" question="CHIUDO ?" cancel="NO" confirm="SI" @confirm="closeApp">
-            <img src="/exit.png" width="25" />
-          </w-confirm>
-          <w-button @click="apriDialogConfig()">
-            <img src="/gear.png" width="25" />
-          </w-button>
-          <w-button @click="cambiaPalla" :disabled="!isPunteggioZeroZero">
-            <img src="/serv.png" width="25" />
-          </w-button>
-          <w-confirm top left question="Azzero punteggio ?" cancel="NO" confirm="SI" @confirm="resetta">
-            RESET
-          </w-confirm>
-          <w-button @click="visuForm = !visuForm">
-            <span v-if="visuForm">PUNTEGGIO</span>
-            <span v-if="!visuForm">FORMAZIONI</span>
-          </w-button>
-          <w-button @click="apriDialogCambi">
-            CAMBI
-          </w-button>
-          <w-button @click="visuStriscia = !visuStriscia">
-            STRISCIA
-          </w-button>
-          <w-button @click="speak">
-            <img src="/speaker.png" width="25" />
-          </w-button>
-        </w-flex>
-      </div>
-    </div>
-</section>
-  

src/components/HomePage/HomePage.js

@@ -1,479 +0,0 @@
-import NoSleep from "nosleep.js";
-export default {
-  name: "HomePage",
-  components: {},
-  data() {
-    return {
-      order: true,
-      voices: null,
-      diaNomi: {
-        show: false,
-        home: "",
-        guest: "",
-      },
-      diaCambi: {
-        show: false,
-        team: "home",
-        guest: { cambi: [{ in: "", out: "" }, { in: "", out: "" }] },
-        home: { cambi: [{ in: "", out: "" }, { in: "", out: "" }] },
-      },
-      diaCambiTeam: {
-        show: false,
-      },
-      visuForm: false,
-      visuButt: true,
-      visuStriscia: true,
-      modalitaPartita: "3/5", // "2/3" o "3/5"
-      sp: {
-        striscia: { home: [0], guest: [0] },
-        servHome: true,
-        punt: { home: 0, guest: 0 },
-        set: { home: 0, guest: 0 },
-        nomi: { home: "Antoniana", guest: "Guest" },
-        form: {
-          home: ["1", "2", "3", "4", "5", "6"],
-          guest: ["1", "2", "3", "4", "5", "6"],
-        },
-        storicoServizio: [], // Stack per tracciare lo stato del servizio prima di ogni punto
-      },
-    }
-  },
-  mounted() {
-    this.voices = window.speechSynthesis.getVoices();
-    if (this.isMobile()) {
-      this.speak();
-      var noSleep = new NoSleep();
-      noSleep.enable();
-      document.documentElement.requestFullscreen();
-    }
-    this.abilitaTastiSpeciali();
-  },
-  computed: {
-    isPunteggioZeroZero() {
-      return this.sp.punt.home === 0 && this.sp.punt.guest === 0;
-    },
-    cambiConfermabili() {
-      const team = this.diaCambi.team;
-      const cambi = this.diaCambi[team].cambi || [];
-      let hasComplete = false;
-      let allValid = true;
-
-      cambi.forEach((cambio) => {
-        const teamIn = (cambio.in || "").trim();
-        const teamOut = (cambio.out || "").trim();
-
-        if (!teamIn && !teamOut) {
-          return;
-        }
-        if (!teamIn || !teamOut) {
-          allValid = false;
-          return;
-        }
-        hasComplete = true;
-      });
-
-      return allValid && hasComplete;
-    }
-  },
-  methods: {
-    closeApp() {
-      var win = window.open("", "_self");
-      win.close();
-    },
-    fullScreen() {
-      document.documentElement.requestFullscreen();
-    },
-    isMobile() {
-      if (
-        /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
-          navigator.userAgent
-        )
-      ) {
-        return true;
-      } else {
-        return false;
-      }
-    },
-    resetta() {
-      this.$waveui.notify("Punteggio<br />RESETTATO", "success");
-      this.visuForm = false;
-      this.sp.punt.home = 0;
-      this.sp.punt.guest = 0;
-      this.sp.form = {
-        home: ["1", "2", "3", "4", "5", "6"],
-        guest: ["1", "2", "3", "4", "5", "6"],
-      }
-      this.sp.striscia = { home: [0], guest: [0] }
-      this.sp.storicoServizio = []
-    },
-    cambiaPalla() {
-      if (!this.isPunteggioZeroZero) {
-        this.$waveui.notify("Cambio palla consentito solo a inizio set (0-0)", "warning");
-        return;
-      }
-      this.sp.servHome = !this.sp.servHome;
-    },
-    incSet(team) {
-      if (this.sp.set[team] == 2) {
-        this.sp.set[team] = 0;
-      } else {
-        this.sp.set[team]++;
-      }
-    },
-    incPunt(team) {
-      // Se il set è già terminato, evita ulteriori incrementi
-      if (this.checkVittoria()) {
-        return;
-      }
-
-      // Salva lo stato del servizio PRIMA di modificarlo
-      this.sp.storicoServizio.push({
-        servHome: this.sp.servHome,
-        cambioPalla: (team == "home" && !this.sp.servHome) || (team == "guest" && this.sp.servHome)
-      });
-
-      this.sp.punt[team]++;
-      if (team == 'home') {
-        this.sp.striscia.home.push(this.sp.punt.home)
-        this.sp.striscia.guest.push(' ')
-      } else {
-        this.sp.striscia.guest.push(this.sp.punt.guest)
-        this.sp.striscia.home.push(' ')
-      }
-
-      // Ruota la formazione solo se c'è cambio palla (conquista del servizio)
-      const cambioPalla = (team == "home" && !this.sp.servHome) || (team == "guest" && this.sp.servHome);
-
-      if (cambioPalla) {
-        this.sp.form[team].push(this.sp.form[team].shift());
-      }
-
-      this.sp.servHome = (team == "home");
-    },
-    checkVittoria() {
-      const puntHome = this.sp.punt.home;
-      const puntGuest = this.sp.punt.guest;
-      const setHome = this.sp.set.home;
-      const setGuest = this.sp.set.guest;
-      const totSet = setHome + setGuest;
-
-      // Determina se siamo nel set decisivo in base alla modalità partita
-      let isSetDecisivo = false;
-      if (this.modalitaPartita === "2/3") {
-        // Tie-break al 3° set (quando totSet >= 2)
-        isSetDecisivo = totSet >= 2;
-      } else {
-        // Tie-break al 5° set (quando totSet >= 4)
-        isSetDecisivo = totSet >= 4;
-      }
-
-      const punteggioVittoria = isSetDecisivo ? 15 : 25;
-
-      // Vittoria con punteggio >= 25 (o 15 per set decisivo) e almeno 2 punti di vantaggio
-      if (puntHome >= punteggioVittoria && puntHome - puntGuest >= 2) {
-        return true; // Home ha vinto
-      }
-      if (puntGuest >= punteggioVittoria && puntGuest - puntHome >= 2) {
-        return true; // Guest ha vinto
-      }
-
-      return false;
-    },
-    decPunt() {
-      if (this.sp.striscia.home.length > 1 && this.sp.storicoServizio.length > 0) {
-        var tmpHome = this.sp.striscia.home.pop()
-        var tmpGuest = this.sp.striscia.guest.pop()
-        var statoServizio = this.sp.storicoServizio.pop() // Recupera lo stato completo del servizio
-
-        if (tmpHome == ' ') {
-          this.sp.punt.guest--
-          // Ruota indietro solo se c'era stato un cambio palla
-          if (statoServizio.cambioPalla) {
-            this.sp.form.guest.unshift(this.sp.form.guest.pop());
-          }
-        } else {
-          this.sp.punt.home--
-          // Ruota indietro solo se c'era stato un cambio palla
-          if (statoServizio.cambioPalla) {
-            this.sp.form.home.unshift(this.sp.form.home.pop());
-          }
-        }
-
-        // Ripristina il servizio allo stato precedente
-        this.sp.servHome = statoServizio.servHome;
-
-      }
-    },
-    // decPunt(team) {
-    //   // decrementa il punteggio se è > 0.
-    //   if (this.sp.punt[team] > 0) {
-    //     this.sp.punt[team]--;
-    //     this.sp.striscia.home.pop()
-    //     this.sp.striscia.guest.pop()
-    //     this.sp.form[team].unshift(this.sp.form[team].pop());
-    //   }
-    // },
-    speak() {
-      const msg = new SpeechSynthesisUtterance();
-      if (this.sp.punt.home + this.sp.punt.guest == 0) {
-        msg.text = "zero a zero";
-      } else if (this.sp.punt.home == this.sp.punt.guest) {
-        msg.text = this.sp.punt.home + " pari";
-      } else {
-        if (this.sp.servHome) {
-          msg.text = this.sp.punt.home + " a " + this.sp.punt.guest;
-        } else {
-          msg.text = this.sp.punt.guest + " a " + this.sp.punt.home;
-        }
-      }
-      // msg.volume = 1.0; // speech volume (default: 1.0)
-      // msg.pitch = 1.0; // speech pitch (default: 1.0)
-      // msg.rate = 1.0; // speech rate (default: 1.0)
-      // msg.lang = 'it_IT'; // speech language (default: 'en-US')
-      const voices = window.speechSynthesis.getVoices();
-      msg.voice = voices.find(voice => voice.name === 'Google italiano');
-      // voice URI (default: platform-dependent)
-      // msg.onboundary = function (event) {
-      //   console.log('Speech reached a boundary:', event.name);
-      // };
-      // msg.onpause = function (event) {
-      //   console.log('Speech paused:', event.utterance.text.substring(event.charIndex));
-      // };
-      window.speechSynthesis.speak(msg);
-    },
-    apriDialogConfig() {
-      this.disabilitaTastiSpeciali();
-      this.diaNomi.show = true;
-
-      // Aggiungi gestore Tab per il dialog
-      this.dialogConfigTabHandler = (e) => {
-        if (e.key === 'Tab' && this.diaNomi.show) {
-          e.preventDefault();
-          e.stopPropagation();
-
-          const dialog = document.querySelector('.w-dialog');
-          if (!dialog) return;
-
-          const allInputs = Array.from(dialog.querySelectorAll('input[type="text"]'))
-            .sort((a, b) => {
-              const tabA = parseInt(a.closest('[tabindex]')?.getAttribute('tabindex') || '0');
-              const tabB = parseInt(b.closest('[tabindex]')?.getAttribute('tabindex') || '0');
-              return tabA - tabB;
-            });
-
-          if (allInputs.length === 0) return;
-
-          // Verifica se il focus è già dentro il dialog
-          const focusInDialog = dialog.contains(document.activeElement);
-
-          // Se non è nel dialog o non è in un input, vai al primo
-          if (!focusInDialog || !allInputs.includes(document.activeElement)) {
-            allInputs[0].focus();
-            return;
-          }
-
-          // Navigazione normale tra i campi
-          const currentIndex = allInputs.indexOf(document.activeElement);
-          let nextIndex;
-
-          if (e.shiftKey) {
-            nextIndex = currentIndex <= 0 ? allInputs.length - 1 : currentIndex - 1;
-          } else {
-            nextIndex = currentIndex >= allInputs.length - 1 ? 0 : currentIndex + 1;
-          }
-
-          if (allInputs[nextIndex]) {
-            allInputs[nextIndex].focus();
-          }
-        }
-      };
-      window.addEventListener('keydown', this.dialogConfigTabHandler, true);
-
-      // Focus immediato + retry con timeout
-      this.$nextTick(() => {
-        const focusFirst = () => {
-          const dialog = document.querySelector('.w-dialog');
-          if (dialog) {
-            const firstInput = dialog.querySelector('input[type="text"]');
-            if (firstInput) {
-              firstInput.focus();
-              firstInput.select();
-              return true;
-            }
-          }
-          return false;
-        };
-
-        // Prova immediatamente
-        if (!focusFirst()) {
-          // Se fallisce, riprova dopo un breve delay
-          setTimeout(focusFirst, 100);
-        }
-      });
-    },
-    chiudiDialogConfig() {
-      if (this.dialogConfigTabHandler) {
-        window.removeEventListener('keydown', this.dialogConfigTabHandler, true);
-        this.dialogConfigTabHandler = null;
-      }
-      this.abilitaTastiSpeciali();
-    },
-    resettaCambi(team) {
-      const teams = team ? [team] : ["home", "guest"];
-      teams.forEach((t) => {
-        this.diaCambi[t].cambi.forEach((cambio) => {
-          cambio.in = "";
-          cambio.out = "";
-        });
-      });
-    },
-    apriDialogCambi() {
-      this.disabilitaTastiSpeciali();
-      this.diaCambiTeam.show = true;
-    },
-    apriDialogCambiTeam(team) {
-      this.disabilitaTastiSpeciali();
-      this.diaCambi.team = team;
-      this.resettaCambi(team);
-      this.diaCambi.show = true;
-    },
-    selezionaTeamCambi(team) {
-      this.diaCambiTeam.show = false;
-      this.apriDialogCambiTeam(team);
-    },
-    chiudiDialogCambi() {
-      this.diaCambi.show = false;
-      this.resettaCambi(this.diaCambi.team);
-      this.abilitaTastiSpeciali();
-    },
-    confermaCambi() {
-      if (!this.cambiConfermabili) {
-        return;
-      }
-
-      const team = this.diaCambi.team;
-      const cambi = (this.diaCambi[team].cambi || [])
-        .map((cambio) => ({
-          team,
-          in: (cambio.in || "").trim(),
-          out: (cambio.out || "").trim(),
-        }))
-        .filter((cambio) => cambio.in || cambio.out);
-
-      const form = this.sp.form[team].map((val) => String(val).trim());
-      const formAggiornata = [...form];
-
-      for (const cambio of cambi) {
-        if (!/^\d+$/.test(cambio.in) || !/^\d+$/.test(cambio.out)) {
-          this.$waveui.notify("Inserisci solo numeri nei campi", "warning");
-          return;
-        }
-        if (cambio.in === cambio.out) {
-          this.$waveui.notify(`Numero IN e OUT uguali per ${cambio.team}`, "warning");
-          return;
-        }
-        if (formAggiornata.includes(cambio.in)) {
-          this.$waveui.notify(`Numero ${cambio.in} già presente in formazione ${cambio.team}`, "warning");
-          return;
-        }
-        if (!formAggiornata.includes(cambio.out)) {
-          this.$waveui.notify(`Numero ${cambio.out} non presente in formazione ${cambio.team}`, "warning");
-          return;
-        }
-
-        const idx = formAggiornata.findIndex((val) => String(val).trim() === cambio.out);
-        if (idx !== -1) {
-          formAggiornata.splice(idx, 1, cambio.in);
-        }
-      }
-
-      this.sp.form[team] = formAggiornata;
-
-      this.chiudiDialogCambi();
-    },
-    disabilitaTastiSpeciali() {
-      window.removeEventListener("keydown", this.funzioneTastiSpeciali);
-    },
-    abilitaTastiSpeciali() {
-      window.addEventListener("keydown", this.funzioneTastiSpeciali);
-    },
-    funzioneTastiSpeciali(e) {
-      if (this.diaNomi.show || this.diaCambi.show || this.diaCambiTeam.show) {
-        return;
-      }
-
-      const target = e.target;
-      const path = typeof e.composedPath === "function" ? e.composedPath() : [];
-      const elements = [target, ...path].filter(Boolean);
-      const isTypingField = elements.some((el) => {
-        if (!el || !el.tagName) {
-          return false;
-        }
-        const tag = String(el.tagName).toLowerCase();
-        if (tag === "input" || tag === "textarea") {
-          return true;
-        }
-        if (el.isContentEditable) {
-          return true;
-        }
-        if (el.classList && (el.classList.contains("w-input") || el.classList.contains("w-textarea"))) {
-          return true;
-        }
-        const contentEditable = el.getAttribute && el.getAttribute("contenteditable");
-        return contentEditable === "true";
-      });
-      if (isTypingField) {
-        return;
-      }
-
-      let handled = false;
-      if (e.ctrlKey && e.key == "m") {
-        this.diaNomi.show = true
-        handled = true;
-      } else if (e.ctrlKey && e.key == "b") {
-        this.visuButt = !this.visuButt
-        handled = true;
-      } else if (e.ctrlKey && e.key == "f") {
-        document.documentElement.requestFullscreen();
-        handled = true;
-      } else if (e.ctrlKey && e.key == "s") {
-        this.speak();
-        handled = true;
-      } else if (e.ctrlKey && e.key == "z") {
-        this.visuForm = !this.visuForm
-        handled = true;
-      } else if (e.ctrlKey && e.key == "ArrowUp") {
-        this.incPunt("home")
-        handled = true;
-      } else if (e.ctrlKey && e.key == "ArrowDown") {
-        this.decPunt("home")
-        handled = true;
-      } else if (e.ctrlKey && e.key == "ArrowRight") {
-        this.incSet("home")
-        handled = true;
-      } else if (e.shiftKey && e.key == "ArrowUp") {
-        this.incPunt("guest")
-        handled = true;
-      } else if (e.shiftKey && e.key == "ArrowDown") {
-        this.decPunt("guest")
-        handled = true;
-      } else if (e.shiftKey && e.key == "ArrowRight") {
-        this.incSet("guest")
-        handled = true;
-      } else if (e.ctrlKey && e.key == "ArrowLeft") {
-        this.cambiaPalla()
-        handled = true;
-      } else if (e.ctrlKey && (e.key == "c" || e.key == "C")) {
-        this.apriDialogCambiTeam("home")
-        handled = true;
-      } else if (e.shiftKey && (e.key == "c" || e.key == "C")) {
-        this.apriDialogCambiTeam("guest")
-        handled = true;
-      } else { return false }
-
-      if (handled) {
-        e.preventDefault();
-      }
-    }
-  }
-}

src/components/HomePage/HomePage.scss

@@ -1,112 +0,0 @@
-.homepage {
-    :root {
-        font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;
-        touch-action: pan-x pan-y;
-        height: 100% 
-    }
-
-    body {
-        overscroll-behavior-y: contain;
-        margin: 0;
-        place-items: center;
-        min-width: 320px;
-        width: 100%;
-        min-height: 100vh;
-        background-color: #000;
-    }
-
-    button {
-        margin-left: 10px;
-        margin-right: 10px;
-        border-radius: 8px;
-        border: 1px solid #fff;
-        padding: 0.6em 1.2em;
-        font-size: 0.8em;
-        font-weight: 500;
-        font-family: inherit;
-        color: #fff;
-        background-color: #000;
-        cursor: pointer;
-        transition: border-color 0.25s;
-    }
-    button:hover {
-        border-color: #646cff;
-        background-color: #333;
-    }
-    button:focus, button:focus-visible {
-        outline: 4px auto -webkit-focus-ring-color;
-    }
-
-    #app {
-        margin: 0 auto;
-        text-align: center;
-    }
-    .campo {
-        user-select: none;
-        width: 100%;
-        display: table;
-        color: #fff;
-    }
-    .hea {
-        float: left;
-        width: 50%;
-        font-size: xx-large;
-    }
-    .hea span {
-        /* border: 1px solid #f3fb00; */
-        padding-left: 10px;
-        padding-right: 10px;
-        border-radius: 5px;
-    }
-    .tal {
-        text-align: left;
-    }
-    .tar {
-        text-align: right;
-    }
-    .bot {
-        position: fixed;
-        left: 0;
-        bottom: 0;
-        width: 100%;
-        margin-top: 10px;
-        margin-bottom: 1px;
-        background-color: #111;
-    }
-    .col {
-        margin-left: auto;
-        margin-right: auto;
-        text-align: center;
-        float: left;
-        width: 50%;
-    }
-    .punt {
-        font-size: 60vh;
-    }
-    .form {
-        font-size: 5vh;
-        border-top: #fff dashed 25px;
-        padding-top: 50px;
-    }
-    .formtit {
-        font-size: 5vh;
-        margin-top: 30px;
-        margin-bottom: 20px;
-    }
-    .formdiv {
-        font-size: 20vh;
-        float: left;
-        width: 32%;
-    }
-    .home {
-        background-color: black;
-        color: yellow;
-    }
-    .guest {
-        background-color: blue;
-        color: white
-    }
-    .item-stri {
-        background-color: #fff;
-    }
-}

src/components/HomePage/index.vue

@@ -1,3 +0,0 @@
-<template src="./HomePage.html"></template>
-<script src="./HomePage.js"></script>
-

src/controller-main.js

@@ -0,0 +1,6 @@
+import { createApp } from 'vue'
+import './style.css'
+import ControllerPage from './components/ControllerPage.vue'
+
+const app = createApp(ControllerPage)
+app.mount('#app')

src/gameState.js

@@ -0,0 +1,190 @@
+export function createInitialState() {
+    return {
+        order: true,
+        visuForm: false,
+        visuStriscia: true,
+        modalitaPartita: "3/5",
+        sp: {
+            striscia: [{ serv: 'home', r: [] }],
+            servHome: true,
+            punt: { home: 0, guest: 0 },
+            set: { home: 0, guest: 0 },
+            nomi: { home: "Antoniana", guest: "Guest" },
+            form: {
+                home: ["1", "2", "3", "4", "5", "6"],
+                guest: ["1", "2", "3", "4", "5", "6"],
+            },
+        },
+    }
+}
+
+export function checkVittoria(state) {
+    const puntHome = state.sp.punt.home
+    const puntGuest = state.sp.punt.guest
+    const setHome = state.sp.set.home
+    const setGuest = state.sp.set.guest
+    const totSet = setHome + setGuest
+
+    const isSetDecisivo = state.modalitaPartita === "2/3" ? totSet >= 2 : totSet >= 4
+    const punteggioVittoria = isSetDecisivo ? 15 : 25
+
+    if (puntHome >= punteggioVittoria && puntHome - puntGuest >= 2) return true
+    if (puntGuest >= punteggioVittoria && puntGuest - puntHome >= 2) return true
+    return false
+}
+
+export function applyAction(state, action) {
+    const s = structuredClone(state)
+
+    switch (action.type) {
+        case "incPunt": {
+            const team = action.team
+            if (checkVittoria(s)) break
+
+            const cambioPalla = (team === "home") !== s.sp.servHome
+            s.sp.punt[team]++
+            s.sp.striscia.at(-1).r.push(team)
+
+            if (cambioPalla) {
+                s.sp.form[team].push(s.sp.form[team].shift())
+            }
+
+            s.sp.servHome = team === "home"
+            break
+        }
+
+        case "decPunt": {
+            const currentSet = s.sp.striscia.at(-1)
+            if (currentSet.r.length === 0) break
+
+            const lastScorer = currentSet.r[currentSet.r.length - 1]
+            const prevServer = currentSet.r.length >= 2
+                ? currentSet.r[currentSet.r.length - 2]
+                : currentSet.serv
+
+            const wasCambioPalla = lastScorer !== prevServer
+
+            currentSet.r.pop()
+            s.sp.punt[lastScorer]--
+            s.sp.servHome = prevServer === 'home'
+
+            if (wasCambioPalla) {
+                s.sp.form[lastScorer].unshift(s.sp.form[lastScorer].pop())
+            }
+            break
+        }
+
+        case "incSet": {
+            const team = action.team
+            if (s.sp.set[team] === 2) {
+                s.sp.set[team] = 0
+            } else {
+                s.sp.set[team]++
+            }
+            break
+        }
+
+        case "nuovoSet": {
+            const team = action.team
+            if (team !== 'home' && team !== 'guest') break
+            s.sp.set[team]++
+            s.sp.punt.home = 0
+            s.sp.punt.guest = 0
+            s.sp.servHome = team === 'home'
+            s.sp.striscia.push({ serv: team, r: [] })
+            s.sp.form = {
+                home: ["1", "2", "3", "4", "5", "6"],
+                guest: ["1", "2", "3", "4", "5", "6"],
+            }
+            break
+        }
+
+        case "cambiaPalla": {
+            if (s.sp.punt.home === 0 && s.sp.punt.guest === 0) {
+                s.sp.servHome = !s.sp.servHome
+                s.sp.striscia.at(-1).serv = s.sp.servHome ? 'home' : 'guest'
+            }
+            break
+        }
+
+        case "resetta": {
+            s.visuForm = false
+            s.sp.punt.home = 0
+            s.sp.punt.guest = 0
+            s.sp.set.home = 0
+            s.sp.set.guest = 0
+            s.sp.form = {
+                home: ["1", "2", "3", "4", "5", "6"],
+                guest: ["1", "2", "3", "4", "5", "6"],
+            }
+            s.sp.striscia = [{ serv: s.sp.servHome ? 'home' : 'guest', r: [] }]
+            break
+        }
+
+        case "toggleFormazione": {
+            s.visuForm = !s.visuForm
+            break
+        }
+
+        case "toggleStriscia": {
+            s.visuStriscia = !s.visuStriscia
+            break
+        }
+
+        case "toggleOrder": {
+            s.order = !s.order
+            break
+        }
+
+        case "setNomi": {
+            if (action.home !== undefined) s.sp.nomi.home = action.home
+            if (action.guest !== undefined) s.sp.nomi.guest = action.guest
+            break
+        }
+
+        case "setModalita": {
+            s.modalitaPartita = action.modalita
+            break
+        }
+
+        case "setFormazione": {
+            if (action.team && action.form) {
+                s.sp.form[action.team] = [...action.form]
+            }
+            break
+        }
+
+        case "confermaCambi": {
+            const team = action.team
+            const cambi = action.cambi || []
+            const form = s.sp.form[team].map((val) => String(val).trim())
+            const formAggiornata = [...form]
+
+            let valid = true
+            for (const cambio of cambi) {
+                const cin = (cambio.in || "").trim()
+                const cout = (cambio.out || "").trim()
+                if (!cin || !cout) continue
+                if (!/^\d+$/.test(cin) || !/^\d+$/.test(cout)) { valid = false; break }
+                if (cin === cout) { valid = false; break }
+                if (formAggiornata.includes(cin)) { valid = false; break }
+                if (!formAggiornata.includes(cout)) { valid = false; break }
+
+                const idx = formAggiornata.findIndex((val) => String(val).trim() === cout)
+                if (idx !== -1) {
+                    formAggiornata.splice(idx, 1, cin)
+                }
+            }
+
+            if (valid) {
+                s.sp.form[team] = formAggiornata
+            }
+            break
+        }
+
+        default:
+            break
+    }
+
+    return s
+}

src/main.js

@@ -1,10 +1,6 @@
 import { createApp } from 'vue'
 import './style.css'
-import App from './App.vue'
-import WaveUI from 'wave-ui'
-import 'wave-ui/dist/wave-ui.css'
+import DisplayPage from './components/DisplayPage.vue'
 
-const app = createApp(App)
-
-app.use(WaveUI)
+const app = createApp(DisplayPage)
 app.mount('#app')

src/persist.js

@@ -0,0 +1,26 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { createInitialState } from './gameState.js'
+
+const STATE_PATH = join(dirname(fileURLToPath(import.meta.url)), '..', '.segnapunti', 'state.json')
+
+export function loadState() {
+    try {
+        if (existsSync(STATE_PATH)) {
+            return JSON.parse(readFileSync(STATE_PATH, 'utf8'))
+        }
+    } catch (err) {
+        console.warn('[Persist] Stato non leggibile, si riparte da zero:', err.message)
+    }
+    return createInitialState()
+}
+
+export function saveState(state) {
+    try {
+        mkdirSync(dirname(STATE_PATH), { recursive: true })
+        writeFileSync(STATE_PATH, JSON.stringify(state), 'utf8')
+    } catch (err) {
+        console.error('[Persist] Salvataggio fallito:', err.message)
+    }
+}

src/server-utils.js

@@ -0,0 +1,36 @@
+import { networkInterfaces } from 'os'
+
+export function getNetworkIPs() {
+  const nets = networkInterfaces()
+  const networkIPs = []
+
+  for (const name of Object.keys(nets)) {
+    for (const net of nets[name]) {
+      if (net.family === 'IPv4' &&
+        !net.internal &&
+        !net.address.startsWith('172.17.') &&
+        !net.address.startsWith('172.18.')) {
+        networkIPs.push(net.address)
+      }
+    }
+  }
+
+  return networkIPs
+}
+
+export function printServerInfo(port = 3000) {
+  const networkIPs = getNetworkIPs()
+
+  console.log(`\nSegnapunti Server`)
+  console.log(`   Display:    http://127.0.0.1:${port}/display`)
+  console.log(`   Controller: http://127.0.0.1:${port}/controller`)
+
+  if (networkIPs.length > 0) {
+    console.log(`\n   Controller da dispositivi remoti:`)
+    networkIPs.forEach(ip => {
+      console.log(`   http://${ip}:${port}/controller`)
+    })
+  }
+
+  console.log()
+}

src/style.css

@@ -53,7 +53,7 @@ button:focus-visible {
   font-size: xx-large;
 }
 .hea span {
-/* border: 1px solid #f3fb00; */
+/* Bordo di debug: border: 1px solid #f3fb00; */
   padding-left: 10px;
   padding-right: 10px;
   border-radius: 5px;
@@ -135,20 +135,35 @@ button:focus-visible {
   color: white
 }
 .striscia {
-  position:fixed;
-  text-align: right;
+  position: fixed;
   bottom: 50px;
+  left: 10px;
   right: 10px;
-  margin-left: -10000px;
+  display: grid;
+  grid-template-columns: max-content 1fr;
+  row-gap: 2px;
+  align-items: center;
+}
+.striscia-nome {
+  white-space: nowrap;
+  padding-right: 6px;
+}
+.striscia-items {
+  display: flex;
+  flex-wrap: nowrap;
+  overflow: hidden;
 }
 .striscia .item {
   width: 25px;
+  min-width: 25px;
   text-align: center;
   font-weight: bold;
-  display: inline-block;
+  flex-shrink: 0;
+  border-radius: 5px;
+}
+.striscia .item:not(.item-vuoto) {
   background-color: rgb(206, 247, 3);
   color: blue;
-  border-radius: 5px;
 }
 
 .campo-config {
@@ -233,9 +248,7 @@ button:focus-visible {
   max-width: 64px;
 }
 
-.cambi-input input,
-.cambi-input .w-input__input,
-.cambi-input .w-input__field {
+.cambi-input input {
   border: 2px solid rgba(255, 255, 255, 0.35);
   border-radius: 8px;
   padding: 6px 10px;
@@ -244,21 +257,15 @@ button:focus-visible {
   box-sizing: border-box;
 }
 
-.cambi-in input,
-.cambi-in .w-input__input,
-.cambi-in .w-input__field {
+.cambi-in input {
   background: rgba(120, 200, 120, 0.4);
 }
 
-.cambi-out input,
-.cambi-out .w-input__input,
-.cambi-out .w-input__field {
+.cambi-out input {
   background: rgba(200, 120, 120, 0.4);
 }
 
-.cambi-input input:focus,
-.cambi-input .w-input__input:focus,
-.cambi-input .w-input__field:focus {
+.cambi-input input:focus {
   border-color: rgba(255, 255, 255, 0.7);
   outline: none;
 }

src/websocket-handler.js

@@ -0,0 +1,200 @@
+import { createInitialState, applyAction } from './gameState.js'
+
+/**
+ * Crea e configura il server WebSocket per la gestione dello stato di gioco.
+ * @param {WebSocketServer} wss - Istanza del server WebSocket.
+ * @returns {Object} Oggetto con metodi di gestione dello stato.
+ */
+export function setupWebSocketHandler(wss, options = {}) {
+  // Stato globale della partita.
+  let gameState = options.initialState ?? createInitialState()
+
+  // Mappa dei ruoli associati ai client connessi.
+  const clients = new Map() // ws -> { role: 'display' | 'controller' }
+
+  /**
+   * Gestisce i messaggi in arrivo dal client
+   */
+  function handleMessage(ws, data) {
+    try {
+      // Converte il payload in stringa in modo sicuro, anche se arriva come Buffer.
+      const dataStr = typeof data === 'string' ? data : data.toString('utf8')
+      const msg = JSON.parse(dataStr)
+
+      if (msg.type === 'register') {
+        return handleRegister(ws, msg)
+      }
+
+      if (msg.type === 'action') {
+        return handleAction(ws, msg)
+      }
+
+      if (msg.type === 'speak') {
+        return handleSpeak(ws, msg)
+      }
+    } catch (err) {
+      console.error('Error processing message:', err, 'data:', data)
+      // Invia l'errore solo se la connessione e ancora aperta.
+      if (ws.readyState === 1) { // Stato WebSocket.OPEN
+        try {
+          sendError(ws, 'Invalid message format')
+        } catch (sendErr) {
+          console.error('Error sending error message:', sendErr)
+        }
+      }
+    }
+  }
+
+  /**
+   * Gestisce la registrazione di un client (display o controller)
+   */
+  function handleRegister(ws, msg) {
+    const role = msg.role || 'display'
+
+    // Valida il ruolo dichiarato dal client.
+    if (!['display', 'controller'].includes(role)) {
+      sendError(ws, 'Invalid role')
+      return
+    }
+
+    clients.set(ws, { role })
+    console.log(`[WebSocket] Client registered as: ${role} (total clients: ${clients.size})`)
+
+    // Invia subito lo stato corrente, se la connessione e aperta.
+    if (ws.readyState === 1) { // Stato WebSocket.OPEN
+      try {
+        ws.send(JSON.stringify({ type: 'state', state: gameState }))
+      } catch (err) {
+        console.error('Error sending initial state:', err)
+      }
+    }
+  }
+
+  /**
+   * Gestisce un'azione di gioco dal controller
+   */
+  function handleAction(ws, msg) {
+    // Solo i client controller possono inviare azioni.
+    const client = clients.get(ws)
+    if (!client || client.role !== 'controller') {
+      sendError(ws, 'Only controllers can send actions')
+      return
+    }
+
+    // Verifica il formato dell'azione ricevuta.
+    if (!msg.action || !msg.action.type) {
+      sendError(ws, 'Invalid action format')
+      return
+    }
+
+    // Applica l'azione allo stato della partita.
+    const previousState = gameState
+    try {
+      gameState = applyAction(gameState, msg.action)
+    } catch (err) {
+      console.error('Error applying action:', err)
+      sendError(ws, 'Failed to apply action')
+      gameState = previousState
+      return
+    }
+
+    // Propaga il nuovo stato a tutti i client connessi.
+    broadcastState()
+    options.onStateChange?.(gameState)
+  }
+
+  /**
+   * Gestisce una richiesta di sintesi vocale proveniente dal controller.
+   * Il messaggio viene inoltrato solo ai client registrati come display.
+   */
+  function handleSpeak(ws, msg) {
+    const client = clients.get(ws)
+    if (!client || client.role !== 'controller') {
+      sendError(ws, 'Only controllers can request speech')
+      return
+    }
+
+    if (typeof msg.text !== 'string' || msg.text.trim() === '') {
+      sendError(ws, 'Invalid speak payload')
+      return
+    }
+
+    const speakMsg = JSON.stringify({ type: 'speak', text: msg.text.trim() })
+    clients.forEach((meta, clientWs) => {
+      if (meta.role === 'display' && clientWs.readyState === 1) {
+        clientWs.send(speakMsg)
+      }
+    })
+  }
+
+  /**
+   * Invia un messaggio di errore al client
+   */
+  function sendError(ws, message) {
+    if (ws.readyState === 1) { // Stato WebSocket.OPEN
+      try {
+        ws.send(JSON.stringify({ type: 'error', message }))
+      } catch (err) {
+        console.error('Failed to send error message:', err)
+      }
+    }
+  }
+
+  /**
+   * Invia lo stato corrente a tutti i client connessi.
+   */
+  function broadcastState() {
+    const stateMsg = JSON.stringify({ type: 'state', state: gameState })
+    wss.clients.forEach((client) => {
+      if (client.readyState === 1) { // Stato WebSocket.OPEN
+        client.send(stateMsg)
+      }
+    })
+  }
+
+  /**
+   * Gestisce la chiusura della connessione
+   */
+  function handleClose(ws) {
+    const client = clients.get(ws)
+    const role = client?.role || 'unknown'
+    console.log(`[WebSocket] Client disconnected (role: ${role})`)
+    clients.delete(ws)
+  }
+
+  /**
+   * Gestisce gli errori WebSocket
+   */
+  function handleError(err, ws) {
+    console.error('WebSocket error:', err)
+
+    // In caso di frame non validi, chiude forzatamente la connessione.
+    if (err.code === 'WS_ERR_INVALID_CLOSE_CODE' || err.code === 'WS_ERR_INVALID_UTF8') {
+      try {
+        if (ws && ws.readyState === 1) { // Stato WebSocket.OPEN
+          ws.terminate() // Chiusura forzata senza handshake di chiusura.
+        }
+      } catch (closeErr) {
+        console.error('Error closing connection:', closeErr)
+      }
+    }
+  }
+
+  // Registra gli handler per ogni nuova connessione.
+  wss.on('connection', (ws) => {
+    // Imposta il tipo binario per ridurre i problemi di codifica.
+    ws.binaryType = 'arraybuffer'
+
+    ws.on('message', (data) => handleMessage(ws, data))
+    ws.on('close', () => handleClose(ws))
+    ws.on('error', (err) => handleError(err, ws))
+  })
+
+  // Espone un'API pubblica per controllo esterno, se necessario.
+  return {
+    getState: () => gameState,
+    setState: (newState) => { gameState = newState },
+    broadcastState,
+    getClients: () => clients,
+  }
+}

tests/README.md

@@ -0,0 +1,281 @@
+# Guida ai Test
+
+Obiettivo della guida:
+- capire che tipi di test esistono nel progetto
+- capire a cosa servono davvero
+- sapere come lanciarli senza errori
+- sapere come leggere i risultati
+- sapere cosa fare quando qualcosa fallisce
+
+## 0) Perche facciamo i test?
+
+Un test è un controllo automatico.
+
+In pratica:
+- tu cambi il codice
+- lanci i test
+- i test ti dicono se hai rotto qualcosa
+
+Se i test sono verdi, hai una buona probabilita che il progetto sia ancora stabile.
+Se i test sono rossi, c'e un problema da capire e sistemare.
+
+## 1) Struttura delle cartelle test
+
+```text
+tests/
+├── unit/          # Test della logica pura (molto veloci)
+├── integration/   # Test di moduli che comunicano tra loro
+├── component/     # Test dei componenti Vue in isolamento
+├── stress/        # Test sotto carico (molti client/azioni)
+├── e2e/           # Test end-to-end su browser reale
+└── README.md      # Questa guida
+```
+
+## 2) Tecnologie usate
+
+- `Vitest`: per `unit`, `integration`, `component`, `stress`
+- `Playwright`: per `e2e`
+
+Tradotto in modo semplice:
+- Vitest controlla parti interne del progetto
+- Playwright controlla il comportamento reale dell'app nel browser
+
+## 3) Prerequisiti (prima di tutto)
+
+### 3.1 Installa dipendenze
+
+Dalla root del progetto:
+
+```bash
+npm install
+```
+
+### 3.2 Installa browser Playwright (solo E2E)
+
+```bash
+npx playwright install chromium firefox
+```
+
+Se non fai questo passo, gli E2E possono fallire subito con errore tipo:
+- `Executable doesn't exist`
+
+## 4) Comandi principali
+
+```bash
+npm run test            # Vitest in watch mode (resta in ascolto)
+npm run test:all        # Tutta la suite Vitest una volta
+npm run test:unit       # Unit + integration
+npm run test:component  # Solo component test
+npm run test:stress     # Solo stress test
+npm run test:e2e        # Tutti gli E2E Playwright
+npm run test:e2e:ui     # Playwright con interfaccia grafica
+```
+
+Ordine consigliato (quando vuoi verificare tutto):
+1. `npm run test:all`
+2. `npm run test:e2e`
+
+## 5) Cosa testa ogni suite (spiegato semplice)
+
+### 5.1 Unit (`tests/unit`)
+
+Cosa sono:
+- test piccoli e veloci sulla logica del gioco
+
+A cosa servono:
+- trovano subito bug in regole punteggio/set/reset
+
+Esempi reali nel progetto:
+- incremento/decremento punti
+- cambio palla
+- vittoria set con regola dei 2 punti di scarto
+- reset stato
+
+Quando falliscono:
+- quasi sempre c'e un problema nella logica core
+
+### 5.2 Integration (`tests/integration`)
+
+Cosa sono:
+- test su pezzi che lavorano insieme (es. WebSocket + handler)
+
+A cosa servono:
+- verificano che i messaggi si muovano nel modo corretto
+
+Esempi reali nel progetto:
+- registrazione client `display`/`controller`
+- broadcast stato ai client
+- validazione input malformati
+- autorizzazioni (solo controller puo inviare certe azioni)
+
+Quando falliscono:
+- spesso c'e problema nel protocollo messaggi o nei controlli di ruolo
+
+### 5.3 Component (`tests/component`)
+
+Cosa sono:
+- test dei componenti Vue senza browser completo
+
+A cosa servono:
+- controllano rendering e comportamento UI locale
+
+Esempi reali nel progetto:
+- punteggio mostrato correttamente
+- stato connessione
+- click bottoni controller
+- dialog reset/config/cambi
+
+Quando falliscono:
+- spesso hai rotto template, computed, metodi o binding
+
+### 5.4 Stress (`tests/stress`)
+
+Cosa sono:
+- test per simulare carico elevato
+
+A cosa servono:
+- verificano che il sistema regga molti client e molte azioni rapide
+
+Esempi reali nel progetto:
+- tanti client display connessi insieme
+- burst di azioni consecutive
+
+Quando falliscono:
+- possono emergere problemi di performance o consistenza stato
+
+### 5.5 End-to-End (`tests/e2e`)
+
+Cosa sono:
+- test realistici nel browser
+
+A cosa servono:
+- verificano che Controller e Display funzionino davvero insieme
+
+File principali:
+- `basic-flow.spec.cjs`: flusso base Controller <-> Display
+- `game-operations.spec.cjs`: reset, config, toggle, cambi
+- `game-simulation.spec.cjs`: simulazione partita
+- `full-match.spec.cjs`: scenari partita completi
+- `accessibility.spec.cjs`: controlli accessibilita con axe
+- `visual-regression.spec.cjs`: confronto screenshot con baseline
+
+Nota importante:
+- gli E2E sono configurati in seriale (`workers: 1`) per evitare interferenze sullo stato partita condiviso.
+
+## 6) Come leggere i risultati
+
+### 6.1 Risultati Vitest
+
+Caso OK (verde):
+
+```text
+Test Files  6 passed (6)
+Tests      159 passed (159)
+```
+
+Significa:
+- tutti i test Vitest sono passati
+
+Caso KO (rosso):
+- guarda prima il nome del file test
+- poi il nome del test (`describe/test`)
+- poi la riga con `expected` e `received`
+- infine vai alla riga indicata nello stack trace
+
+### 6.2 Risultati Playwright
+
+Caso OK:
+
+```text
+72 passed
+```
+
+Caso KO:
+- apri il report HTML
+
+```bash
+npx playwright show-report
+```
+
+Nel report puoi vedere:
+- step del test
+- errori precisi
+- screenshot/diff
+- trace
+
+## 7) Visual Regression (screenshot)
+
+I test visual confrontano immagini attuali con immagini baseline.
+
+Cartella baseline:
+- `tests/e2e/visual-regression.spec.cjs-snapshots/`
+
+Se cambia la UI in modo intenzionale:
+- aggiorna snapshot
+
+```bash
+npm run test:e2e -- --update-snapshots
+```
+
+Poi rilancia controllo:
+
+```bash
+npm run test:e2e
+```
+
+Se la UI non doveva cambiare:
+- non aggiornare snapshot
+- correggi prima il codice UI/CSS
+
+## 8) Errori comuni e soluzione veloce
+
+- Errore Playwright `Executable doesn't exist`:
+  - esegui `npx playwright install chromium firefox`
+
+- E2E instabili con punteggi strani:
+  - assicurati che i test restino seriali (`workers: 1`)
+  - assicurati che ogni test parta da stato pulito (reset)
+
+- Selettore ambiguo (esempio bottone `Cambi`):
+  - usa selector piu specifici, ad esempio `getByRole(..., { exact: true })`
+
+- Failure accessibilita:
+  - controlla prima `alt` delle immagini e contrasto colori
+
+## 9) Mini checklist prima di fare push
+
+Esegui:
+
+```bash
+npm run test:all
+npm run test:e2e
+```
+
+Se hai cambiato UI e i visual falliscono per differenze volute:
+
+```bash
+npm run test:e2e -- --update-snapshots
+npm run test:e2e
+```
+
+## 10) Come aggiungere un nuovo test (consigli pratici)
+
+- metti i test nel posto giusto:
+  - `tests/unit` per logica pura
+  - `tests/integration` per moduli che dialogano
+  - `tests/component` per Vue in isolamento
+  - `tests/stress` per carico
+  - `tests/e2e` per flussi reali
+
+- mantieni nomi chiari:
+  - il titolo del test deve spiegare cosa verifica
+
+- evita test dipendenti da ordine:
+  - ogni test deve potersi eseguire da solo
+
+- negli E2E:
+  - porta sempre il sistema in stato iniziale
+  - usa selector robusti
+  - limita `waitForTimeout` e preferisci attese su condizioni reali
+
+Se segui questi punti, i test restano stabili e facili da capire anche per chi entra ora nel progetto.

tests/component/ControllerPage.test.js

@@ -0,0 +1,255 @@
+// @vitest-environment happy-dom
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { mount } from '@vue/test-utils'
+import ControllerPage from '../../src/components/ControllerPage.vue'
+
+// Mock globale WebSocket per jsdom
+class MockWebSocket {
+    static OPEN = 1
+    static CONNECTING = 0
+    readyState = 0
+    onopen = null
+    onclose = null
+    onmessage = null
+    onerror = null
+    send = vi.fn()
+    close = vi.fn()
+    constructor() {
+        // Simula connessione immediata
+        setTimeout(() => {
+            this.readyState = 1
+            if (this.onopen) this.onopen()
+        }, 0)
+    }
+}
+
+vi.stubGlobal('WebSocket', MockWebSocket)
+
+// Helper per creare il componente con stato personalizzato
+function mountController(stateOverrides = {}) {
+    const wrapper = mount(ControllerPage, {
+        global: {
+            stubs: { 'w-app': true, 'w-button': true }
+        }
+    })
+    if (Object.keys(stateOverrides).length > 0) {
+        wrapper.vm.state = { ...wrapper.vm.state, ...stateOverrides }
+    }
+    return wrapper
+}
+
+describe('ControllerPage.vue', () => {
+
+    beforeEach(() => {
+        vi.useFakeTimers()
+    })
+
+    afterEach(() => {
+        vi.useRealTimers()
+    })
+
+    // =============================================
+    // RENDERING INIZIALE
+    // =============================================
+    describe('Rendering iniziale', () => {
+        it('dovrebbe mostrare i nomi dei team', () => {
+            const wrapper = mountController()
+            const text = wrapper.text()
+            expect(text).toContain('Antoniana')
+            expect(text).toContain('Guest')
+        })
+
+        it('dovrebbe mostrare punteggio 0-0', () => {
+            const wrapper = mountController()
+            const pts = wrapper.findAll('.team-pts')
+            expect(pts[0].text()).toBe('0')
+            expect(pts[1].text()).toBe('0')
+        })
+
+        it('dovrebbe mostrare SET 0 per entrambi i team', () => {
+            const wrapper = mountController()
+            const sets = wrapper.findAll('.team-set')
+            expect(sets[0].text()).toContain('SET 0')
+            expect(sets[1].text()).toContain('SET 0')
+        })
+    })
+
+    // =============================================
+    // CLICK PUNTEGGIO
+    // =============================================
+    describe('Click punteggio', () => {
+        it('dovrebbe chiamare sendAction con incPunt home al click sul team home', async () => {
+            const wrapper = mountController()
+            const spy = vi.spyOn(wrapper.vm, 'sendAction')
+            await wrapper.find('.team-score.home-bg').trigger('click')
+            expect(spy).toHaveBeenCalledWith({ type: 'incPunt', team: 'home' })
+        })
+
+        it('dovrebbe chiamare sendAction con incPunt guest al click sul team guest', async () => {
+            const wrapper = mountController()
+            const spy = vi.spyOn(wrapper.vm, 'sendAction')
+            await wrapper.find('.team-score.guest-bg').trigger('click')
+            expect(spy).toHaveBeenCalledWith({ type: 'incPunt', team: 'guest' })
+        })
+    })
+
+    // =============================================
+    // BOTTONE CAMBIO PALLA
+    // =============================================
+    describe('Cambio Palla', () => {
+        it('dovrebbe essere abilitato a 0-0', () => {
+            const wrapper = mountController()
+            const btn = wrapper.findAll('.btn-ctrl').find(b => b.text().includes('Cambio Palla'))
+            expect(btn.attributes('disabled')).toBeUndefined()
+        })
+
+        it('dovrebbe essere disabilitato se il punteggio non è 0-0', async () => {
+            const wrapper = mountController()
+            wrapper.vm.state.sp.punt.home = 5
+            await wrapper.vm.$nextTick()
+            const btn = wrapper.findAll('.btn-ctrl').find(b => b.text().includes('Cambio Palla'))
+            expect(btn.attributes('disabled')).toBeDefined()
+        })
+    })
+
+    // =============================================
+    // DIALOG RESET
+    // =============================================
+    describe('Dialog Reset', () => {
+        it('click Reset dovrebbe aprire la conferma', async () => {
+            const wrapper = mountController()
+            expect(wrapper.find('.overlay').exists()).toBe(false)
+            await wrapper.find('.btn-danger').trigger('click')
+            expect(wrapper.vm.confirmReset).toBe(true)
+            expect(wrapper.find('.overlay').exists()).toBe(true)
+        })
+
+        it('click NO dovrebbe chiudere la conferma', async () => {
+            const wrapper = mountController()
+            wrapper.vm.confirmReset = true
+            await wrapper.vm.$nextTick()
+            await wrapper.find('.btn-cancel').trigger('click')
+            expect(wrapper.vm.confirmReset).toBe(false)
+        })
+
+        it('click SI dovrebbe chiamare doReset', async () => {
+            const wrapper = mountController()
+            const spy = vi.spyOn(wrapper.vm, 'sendAction')
+            wrapper.vm.confirmReset = true
+            await wrapper.vm.$nextTick()
+            await wrapper.find('.btn-confirm').trigger('click')
+            expect(spy).toHaveBeenCalledWith({ type: 'resetta' })
+            expect(wrapper.vm.confirmReset).toBe(false)
+        })
+    })
+
+    // =============================================
+    // COMPUTED cambiValid
+    // =============================================
+    describe('cambiValid', () => {
+        it('dovrebbe essere false se tutti i campi sono vuoti', () => {
+            const wrapper = mountController()
+            wrapper.vm.cambiData = [{ in: '', out: '' }, { in: '', out: '' }]
+            expect(wrapper.vm.cambiValid).toBe(false)
+        })
+
+        it('dovrebbe essere true con un cambio completo', () => {
+            const wrapper = mountController()
+            wrapper.vm.cambiData = [{ in: '10', out: '1' }, { in: '', out: '' }]
+            expect(wrapper.vm.cambiValid).toBe(true)
+        })
+
+        it('dovrebbe essere false con un cambio parziale (solo IN)', () => {
+            const wrapper = mountController()
+            wrapper.vm.cambiData = [{ in: '10', out: '' }, { in: '', out: '' }]
+            expect(wrapper.vm.cambiValid).toBe(false)
+        })
+
+        it('dovrebbe essere false con un cambio parziale (solo OUT)', () => {
+            const wrapper = mountController()
+            wrapper.vm.cambiData = [{ in: '', out: '1' }, { in: '', out: '' }]
+            expect(wrapper.vm.cambiValid).toBe(false)
+        })
+
+        it('dovrebbe essere true con due cambi completi', () => {
+            const wrapper = mountController()
+            wrapper.vm.cambiData = [{ in: '10', out: '1' }, { in: '11', out: '2' }]
+            expect(wrapper.vm.cambiValid).toBe(true)
+        })
+    })
+
+    // =============================================
+    // SPEAK
+    // =============================================
+    describe('speak', () => {
+        it('dovrebbe generare "zero a zero" a 0-0', () => {
+            const wrapper = mountController()
+            wrapper.vm.wsConnected = true
+            wrapper.vm.ws = { readyState: 1, send: vi.fn() }
+            wrapper.vm.speak()
+            const sent = JSON.parse(wrapper.vm.ws.send.mock.calls[0][0])
+            expect(sent.type).toBe('speak')
+            expect(sent.text).toBe('zero a zero')
+        })
+
+        it('dovrebbe generare "N pari" a punteggio uguale', () => {
+            const wrapper = mountController()
+            wrapper.vm.state.sp.punt.home = 5
+            wrapper.vm.state.sp.punt.guest = 5
+            wrapper.vm.wsConnected = true
+            wrapper.vm.ws = { readyState: 1, send: vi.fn() }
+            wrapper.vm.speak()
+            const sent = JSON.parse(wrapper.vm.ws.send.mock.calls[0][0])
+            expect(sent.text).toBe('5 pari')
+        })
+
+        it('dovrebbe annunciare prima il punteggio di chi batte (home serve)', () => {
+            const wrapper = mountController()
+            wrapper.vm.state.sp.punt.home = 15
+            wrapper.vm.state.sp.punt.guest = 10
+            wrapper.vm.state.sp.servHome = true
+            wrapper.vm.wsConnected = true
+            wrapper.vm.ws = { readyState: 1, send: vi.fn() }
+            wrapper.vm.speak()
+            const sent = JSON.parse(wrapper.vm.ws.send.mock.calls[0][0])
+            expect(sent.text).toBe('15 a 10')
+        })
+
+        it('dovrebbe annunciare prima il punteggio di chi batte (guest serve)', () => {
+            const wrapper = mountController()
+            wrapper.vm.state.sp.punt.home = 10
+            wrapper.vm.state.sp.punt.guest = 15
+            wrapper.vm.state.sp.servHome = false
+            wrapper.vm.wsConnected = true
+            wrapper.vm.ws = { readyState: 1, send: vi.fn() }
+            wrapper.vm.speak()
+            const sent = JSON.parse(wrapper.vm.ws.send.mock.calls[0][0])
+            expect(sent.text).toBe('15 a 10')
+        })
+    })
+
+    // =============================================
+    // BARRA CONNESSIONE
+    // =============================================
+    describe('Barra connessione', () => {
+        it('dovrebbe avere classe "connected" quando connesso', async () => {
+            const wrapper = mountController()
+            wrapper.vm.wsConnected = true
+            await wrapper.vm.$nextTick()
+            expect(wrapper.find('.conn-bar').classes()).toContain('connected')
+        })
+
+        it('non dovrebbe avere classe "connected" quando disconnesso', () => {
+            const wrapper = mountController()
+            wrapper.vm.wsConnected = false
+            expect(wrapper.find('.conn-bar').classes()).not.toContain('connected')
+        })
+
+        it('dovrebbe mostrare "Connesso" quando connesso', async () => {
+            const wrapper = mountController()
+            wrapper.vm.wsConnected = true
+            await wrapper.vm.$nextTick()
+            expect(wrapper.find('.conn-bar').text()).toContain('Connesso')
+        })
+    })
+})

tests/component/DisplayPage.test.js

@@ -0,0 +1,195 @@
+// @vitest-environment happy-dom
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { mount } from '@vue/test-utils'
+import DisplayPage from '../../src/components/DisplayPage.vue'
+
+// Mock globale WebSocket per jsdom
+class MockWebSocket {
+    static OPEN = 1
+    static CONNECTING = 0
+    readyState = 0
+    onopen = null
+    onclose = null
+    onmessage = null
+    onerror = null
+    send = vi.fn()
+    close = vi.fn()
+    constructor() {
+        setTimeout(() => {
+            this.readyState = 1
+            if (this.onopen) this.onopen()
+        }, 0)
+    }
+}
+
+vi.stubGlobal('WebSocket', MockWebSocket)
+
+// Mock requestFullscreen e speechSynthesis
+vi.stubGlobal('speechSynthesis', {
+    speak: vi.fn(),
+    cancel: vi.fn(),
+    getVoices: () => []
+})
+
+function mountDisplay() {
+    return mount(DisplayPage, {
+        global: {
+            stubs: { 'w-app': true }
+        }
+    })
+}
+
+describe('DisplayPage.vue', () => {
+
+    beforeEach(() => {
+        vi.useFakeTimers()
+    })
+
+    afterEach(() => {
+        vi.useRealTimers()
+    })
+
+    // =============================================
+    // RENDERING PUNTEGGIO
+    // =============================================
+    describe('Rendering punteggio', () => {
+        it('dovrebbe mostrare i nomi dei team', () => {
+            const wrapper = mountDisplay()
+            const text = wrapper.text()
+            expect(text).toContain('Antoniana')
+            expect(text).toContain('Guest')
+        })
+
+        it('dovrebbe mostrare punteggio iniziale 0-0', () => {
+            const wrapper = mountDisplay()
+            const punti = wrapper.findAll('.punt')
+            expect(punti[0].text()).toBe('0')
+            expect(punti[1].text()).toBe('0')
+        })
+
+        it('dovrebbe mostrare i set corretti', () => {
+            const wrapper = mountDisplay()
+            const text = wrapper.text()
+            expect(text).toContain('set 0')
+        })
+
+        it('dovrebbe aggiornare il punteggio quando lo stato cambia', async () => {
+            const wrapper = mountDisplay()
+            wrapper.vm.state.sp.punt.home = 15
+            wrapper.vm.state.sp.punt.guest = 12
+            await wrapper.vm.$nextTick()
+            const punti = wrapper.findAll('.punt')
+            expect(punti[0].text()).toBe('15')
+            expect(punti[1].text()).toBe('12')
+        })
+    })
+
+    // =============================================
+    // ORDINE TEAM
+    // =============================================
+    describe('Ordine team', () => {
+        it('order=true → Home prima di Guest', () => {
+            const wrapper = mountDisplay()
+            const headers = wrapper.findAll('.hea')
+            expect(headers[0].classes()).toContain('home')
+            expect(headers[1].classes()).toContain('guest')
+        })
+
+        it('order=false → Guest prima di Home', async () => {
+            const wrapper = mountDisplay()
+            wrapper.vm.state.order = false
+            await wrapper.vm.$nextTick()
+            const headers = wrapper.findAll('.hea')
+            expect(headers[0].classes()).toContain('guest')
+            expect(headers[1].classes()).toContain('home')
+        })
+    })
+
+    // =============================================
+    // FORMAZIONE vs PUNTEGGIO
+    // =============================================
+    describe('visuForm toggle', () => {
+        it('visuForm=false → mostra punteggio grande', () => {
+            const wrapper = mountDisplay()
+            expect(wrapper.find('.punteggio-container').exists()).toBe(true)
+            expect(wrapper.find('.form').exists()).toBe(false)
+        })
+
+        it('visuForm=true → mostra formazione', async () => {
+            const wrapper = mountDisplay()
+            wrapper.vm.state.visuForm = true
+            await wrapper.vm.$nextTick()
+            expect(wrapper.findAll('.form').length).toBeGreaterThan(0)
+            expect(wrapper.find('.punteggio-container').exists()).toBe(false)
+        })
+
+        it('formazione mostra 6 giocatori per team', async () => {
+            const wrapper = mountDisplay()
+            wrapper.vm.state.visuForm = true
+            await wrapper.vm.$nextTick()
+            const formDivs = wrapper.findAll('.formdiv')
+            // 6 per home + 6 per guest = 12
+            expect(formDivs).toHaveLength(12)
+        })
+    })
+
+    // =============================================
+    // STRISCIA
+    // =============================================
+    describe('visuStriscia toggle', () => {
+        it('visuStriscia=true → mostra la striscia', () => {
+            const wrapper = mountDisplay()
+            expect(wrapper.find('.striscia').exists()).toBe(true)
+        })
+
+        it('visuStriscia=false → nasconde la striscia', async () => {
+            const wrapper = mountDisplay()
+            wrapper.vm.state.visuStriscia = false
+            await wrapper.vm.$nextTick()
+            expect(wrapper.find('.striscia').exists()).toBe(false)
+        })
+    })
+
+    // =============================================
+    // INDICATORE CONNESSIONE
+    // =============================================
+    describe('Indicatore connessione', () => {
+        it('dovrebbe avere classe "disconnected" quando non connesso', () => {
+            const wrapper = mountDisplay()
+            const status = wrapper.find('.connection-status')
+            expect(status.classes()).toContain('disconnected')
+        })
+
+        it('dovrebbe avere classe "connected" quando connesso', async () => {
+            const wrapper = mountDisplay()
+            wrapper.vm.wsConnected = true
+            await wrapper.vm.$nextTick()
+            const status = wrapper.find('.connection-status')
+            expect(status.classes()).toContain('connected')
+        })
+
+        it('dovrebbe mostrare "Disconnesso" quando non connesso', () => {
+            const wrapper = mountDisplay()
+            const status = wrapper.find('.connection-status')
+            expect(status.text()).toContain('Disconnesso')
+        })
+    })
+
+    // =============================================
+    // ICONA SERVIZIO
+    // =============================================
+    describe('Icona servizio', () => {
+        it('dovrebbe mostrare l\'icona servizio sul team home quando servHome=true', () => {
+            const wrapper = mountDisplay()
+            // v-show imposta display:none. In happy-dom controlliamo lo style.
+            const imgs = wrapper.findAll('.serv-slot img')
+            // Con state.order=true e servHome=true:
+            // - la prima img (home) è visibile (no display:none)
+            // - la seconda img (guest) ha display:none
+            const homeStyle = imgs[0].attributes('style') || ''
+            const guestStyle = imgs[1].attributes('style') || ''
+            expect(homeStyle).not.toContain('display: none')
+            expect(guestStyle).toContain('display: none')
+        })
+    })
+})

tests/e2e/accessibility.spec.cjs

@@ -0,0 +1,72 @@
+const { test, expect } = require('@playwright/test');
+const AxeBuilderImport = require('@axe-core/playwright');
+const AxeBuilder = AxeBuilderImport.default || AxeBuilderImport;
+
+test.describe('Accessibility (a11y)', () => {
+
+    test('Display: non dovrebbe avere violazioni critiche a11y', async ({ page }) => {
+        await page.goto('http://localhost:3000');
+        await page.waitForTimeout(500);
+
+        const results = await new AxeBuilder({ page })
+            .withTags(['wcag2a', 'wcag2aa'])
+            .disableRules(['color-contrast']) // il display ha sfondo nero con testo grande, valutato separatamente
+            .analyze();
+
+        expect(results.violations).toEqual([]);
+    });
+
+    test('Controller: non dovrebbe avere violazioni critiche a11y', async ({ page }) => {
+        await page.goto('http://localhost:3001');
+        await page.waitForTimeout(500);
+
+        const results = await new AxeBuilder({ page })
+            .withTags(['wcag2a', 'wcag2aa'])
+            .analyze();
+
+        // Mostra i dettagli delle violazioni se ci sono
+        if (results.violations.length > 0) {
+            console.log('A11y violations:', JSON.stringify(results.violations.map(v => ({
+                id: v.id,
+                impact: v.impact,
+                description: v.description,
+                nodes: v.nodes.length
+            })), null, 2));
+        }
+
+        // Accettiamo solo violazioni minor (non critiche o serie)
+        const serious = results.violations.filter(v =>
+            v.impact === 'critical' || v.impact === 'serious'
+        );
+        expect(serious).toEqual([]);
+    });
+
+    test('Controller: i touch target dovrebbero avere dimensione minima', async ({ page }) => {
+        await page.goto('http://localhost:3001');
+        await page.waitForSelector('.conn-bar.connected');
+
+        // Controlla che i bottoni principali abbiano dimensione minima 44x44px
+        const buttons = page.locator('.btn-ctrl');
+        const count = await buttons.count();
+
+        for (let i = 0; i < count; i++) {
+            const box = await buttons.nth(i).boundingBox();
+            expect(box.width).toBeGreaterThanOrEqual(44);
+            expect(box.height).toBeGreaterThanOrEqual(44);
+        }
+    });
+
+    test('Controller: i bottoni punteggio dovrebbero avere dimensione adeguata', async ({ page }) => {
+        await page.goto('http://localhost:3001');
+        await page.waitForSelector('.conn-bar.connected');
+
+        const scoreButtons = page.locator('.team-score');
+        const count = await scoreButtons.count();
+
+        for (let i = 0; i < count; i++) {
+            const box = await scoreButtons.nth(i).boundingBox();
+            expect(box.width).toBeGreaterThanOrEqual(100);
+            expect(box.height).toBeGreaterThanOrEqual(100);
+        }
+    });
+});

tests/e2e/basic-flow.spec.cjs

@@ -0,0 +1,119 @@
+const { test, expect } = require('@playwright/test');
+
+test.describe('Basic Flow: Controller ↔ Display', () => {
+
+    test('dovrebbe caricare Display e Controller con i titoli corretti', async ({ context }) => {
+        const displayPage = await context.newPage();
+        const controllerPage = await context.newPage();
+
+        await displayPage.goto('http://localhost:3000');
+        await controllerPage.goto('http://localhost:3001');
+
+        await expect(displayPage).toHaveTitle(/Segnapunti/);
+        await expect(controllerPage).toHaveTitle(/Controller/);
+    });
+
+    test('il punteggio iniziale dovrebbe essere 0-0', async ({ context }) => {
+        const controllerPage = await context.newPage();
+        await controllerPage.goto('http://localhost:3001');
+
+        // Attende la connessione WebSocket
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        const homeScore = controllerPage.locator('.team-score.home-bg .team-pts');
+        const guestScore = controllerPage.locator('.team-score.guest-bg .team-pts');
+        await expect(homeScore).toHaveText('0');
+        await expect(guestScore).toHaveText('0');
+    });
+
+    test('click +1 Home sul Controller dovrebbe aggiornare il Display', async ({ context }) => {
+        const displayPage = await context.newPage();
+        const controllerPage = await context.newPage();
+
+        await displayPage.goto('http://localhost:3000');
+        await controllerPage.goto('http://localhost:3001');
+
+        // Attende la connessione WebSocket del controller
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        // Reset per stato pulito
+        await controllerPage.getByText(/Reset/i).first().click();
+        const btnConfirm = controllerPage.locator('.dialog .btn-confirm');
+        if (await btnConfirm.isVisible()) {
+            await btnConfirm.click();
+        }
+        await controllerPage.waitForTimeout(200);
+
+        // Click +1 Home
+        await controllerPage.locator('.team-score.home-bg').click();
+        await controllerPage.waitForTimeout(200);
+
+        // Verifica Controller mostra 1
+        await expect(controllerPage.locator('.team-score.home-bg .team-pts')).toHaveText('1');
+
+        // Verifica Display mostra 1 (il punteggio grande)
+        await expect(displayPage.locator('.punt.home')).toHaveText('1');
+    });
+
+    test('click +1 Guest sul Controller dovrebbe aggiornare il Display', async ({ context }) => {
+        const displayPage = await context.newPage();
+        const controllerPage = await context.newPage();
+
+        await displayPage.goto('http://localhost:3000');
+        await controllerPage.goto('http://localhost:3001');
+
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        // Reset
+        await controllerPage.getByText(/Reset/i).first().click();
+        const btnConfirm = controllerPage.locator('.dialog .btn-confirm');
+        if (await btnConfirm.isVisible()) {
+            await btnConfirm.click();
+        }
+        await controllerPage.waitForTimeout(200);
+
+        // Click +1 Guest
+        await controllerPage.locator('.team-score.guest-bg').click();
+        await controllerPage.waitForTimeout(200);
+
+        // Verifica Controller
+        await expect(controllerPage.locator('.team-score.guest-bg .team-pts')).toHaveText('1');
+
+        // Verifica Display
+        await expect(displayPage.locator('.punt.guest')).toHaveText('1');
+    });
+
+    test('la sincronizzazione dovrebbe funzionare con punti alternati', async ({ context }) => {
+        const displayPage = await context.newPage();
+        const controllerPage = await context.newPage();
+
+        await displayPage.goto('http://localhost:3000');
+        await controllerPage.goto('http://localhost:3001');
+
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        // Reset
+        await controllerPage.getByText(/Reset/i).first().click();
+        const btnConfirm = controllerPage.locator('.dialog .btn-confirm');
+        if (await btnConfirm.isVisible()) {
+            await btnConfirm.click();
+        }
+        await controllerPage.waitForTimeout(200);
+
+        // Home +1, Guest +1, Home +1
+        await controllerPage.locator('.team-score.home-bg').click();
+        await controllerPage.waitForTimeout(100);
+        await controllerPage.locator('.team-score.guest-bg').click();
+        await controllerPage.waitForTimeout(100);
+        await controllerPage.locator('.team-score.home-bg').click();
+        await controllerPage.waitForTimeout(200);
+
+        // Controller: Home 2, Guest 1
+        await expect(controllerPage.locator('.team-score.home-bg .team-pts')).toHaveText('2');
+        await expect(controllerPage.locator('.team-score.guest-bg .team-pts')).toHaveText('1');
+
+        // Display: Home 2, Guest 1
+        await expect(displayPage.locator('.punt.home')).toHaveText('2');
+        await expect(displayPage.locator('.punt.guest')).toHaveText('1');
+    });
+});

tests/e2e/full-match.spec.cjs

@@ -0,0 +1,131 @@
+const { test, expect } = require('@playwright/test');
+
+// Helper: reset dal controller
+async function resetGame(controllerPage) {
+    await controllerPage.getByText(/Reset/i).first().click();
+    const btnConfirm = controllerPage.locator('.dialog .btn-confirm');
+    if (await btnConfirm.isVisible()) {
+        await btnConfirm.click();
+    }
+    await controllerPage.waitForTimeout(300);
+}
+
+// Helper: incrementa punti per una squadra N volte
+async function addPoints(controllerPage, team, count) {
+    const selector = team === 'home' ? '.team-score.home-bg' : '.team-score.guest-bg';
+    for (let i = 0; i < count; i++) {
+        await controllerPage.locator(selector).click();
+        await controllerPage.waitForTimeout(30);
+    }
+    await controllerPage.waitForTimeout(100);
+}
+
+// Helper: assegna un set a una squadra (25 punti + click SET)
+async function winSet(controllerPage, team) {
+    await addPoints(controllerPage, team, 25);
+    // Clicca bottone SET
+    const setSelector = team === 'home' ? '.btn-set.home-bg' : '.btn-set.guest-bg';
+    await controllerPage.locator(setSelector).click();
+    await controllerPage.waitForTimeout(100);
+    // Reset punti per il prossimo set
+    // (in questo gioco i punti non si resettano automaticamente, serve reset manuale
+    //  o il controller gestisce il prossimo set manualmente)
+}
+
+test.describe('Full Match Simulation', () => {
+
+    test('Partita 2/3: Home vince 2 set a 0', async ({ context }) => {
+        const controllerPage = await context.newPage();
+        await controllerPage.goto('http://localhost:3001');
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        await resetGame(controllerPage);
+
+        // Cambia modalità a 2/3
+        await controllerPage.getByText('Config').click();
+        await controllerPage.waitForSelector('.dialog-config');
+        await controllerPage.locator('.btn-mode').getByText('2/3').click();
+        await controllerPage.locator('.dialog-config .btn-confirm').click();
+        await controllerPage.waitForTimeout(200);
+
+        // === SET 1: Home vince 25-0 ===
+        await addPoints(controllerPage, 'home', 25);
+
+        // Verifica punteggio 25
+        await expect(controllerPage.locator('.team-score.home-bg .team-pts')).toHaveText('25');
+
+        // Incrementa set Home
+        await controllerPage.locator('.btn-set.home-bg').click();
+        await controllerPage.waitForTimeout(100);
+
+        // Verifica set 1 per Home
+        await expect(controllerPage.locator('.team-score.home-bg .team-set')).toContainText('SET 1');
+    });
+
+    test('Set decisivo 2/3: vittoria a 15 punti', async ({ context }) => {
+        const controllerPage = await context.newPage();
+        await controllerPage.goto('http://localhost:3001');
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        await resetGame(controllerPage);
+
+        // Cambia modalità a 2/3
+        await controllerPage.getByText('Config').click();
+        await controllerPage.waitForSelector('.dialog-config');
+        await controllerPage.locator('.btn-mode').getByText('2/3').click();
+        await controllerPage.locator('.dialog-config .btn-confirm').click();
+        await controllerPage.waitForTimeout(200);
+
+        // Imposta set 1-1 manualmente (simula set pareggiati)
+        await controllerPage.locator('.btn-set.home-bg').click();
+        await controllerPage.waitForTimeout(50);
+        await controllerPage.locator('.btn-set.guest-bg').click();
+        await controllerPage.waitForTimeout(100);
+
+        // Verifica set 1-1
+        await expect(controllerPage.locator('.team-score.home-bg .team-set')).toContainText('SET 1');
+        await expect(controllerPage.locator('.team-score.guest-bg .team-set')).toContainText('SET 1');
+
+        // === SET DECISIVO: Home porta a 15 ===
+        await addPoints(controllerPage, 'home', 15);
+
+        // Verifica punteggio 15 (e il set è decisivo: dopo 15 punti il gioco è vinto)
+        await expect(controllerPage.locator('.team-score.home-bg .team-pts')).toHaveText('15');
+
+        // Verifica che non si possono aggiungere altri punti (vittoria)
+        await controllerPage.locator('.team-score.home-bg').click();
+        await controllerPage.waitForTimeout(100);
+        // Dovrebbe restare 15 (checkVittoria blocca incPunt)
+        await expect(controllerPage.locator('.team-score.home-bg .team-pts')).toHaveText('15');
+    });
+
+    test('Set normale: punti oltre 25 fino ai vantaggi', async ({ context }) => {
+        const controllerPage = await context.newPage();
+        await controllerPage.goto('http://localhost:3001');
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        await resetGame(controllerPage);
+
+        // Porta a 24-24
+        await addPoints(controllerPage, 'home', 24);
+        await addPoints(controllerPage, 'guest', 24);
+
+        await expect(controllerPage.locator('.team-score.home-bg .team-pts')).toHaveText('24');
+        await expect(controllerPage.locator('.team-score.guest-bg .team-pts')).toHaveText('24');
+
+        // Home va a 25 (non è vittoria perché serve scarto di 2)
+        await controllerPage.locator('.team-score.home-bg').click();
+        await controllerPage.waitForTimeout(100);
+        await expect(controllerPage.locator('.team-score.home-bg .team-pts')).toHaveText('25');
+
+        // Si possono ancora aggiungere punti (non è vittoria a 25-24)
+        await controllerPage.locator('.team-score.home-bg').click();
+        await controllerPage.waitForTimeout(100);
+        await expect(controllerPage.locator('.team-score.home-bg .team-pts')).toHaveText('26');
+
+        // 26-24 è vittoria → non si possono più aggiungere punti
+        await controllerPage.locator('.team-score.home-bg').click();
+        await controllerPage.waitForTimeout(100);
+        await expect(controllerPage.locator('.team-score.home-bg .team-pts')).toHaveText('26');
+    });
+});

tests/e2e/game-operations.spec.cjs

@@ -0,0 +1,182 @@
+const { test, expect } = require('@playwright/test');
+
+// Helper: reset dal controller
+async function resetGame(controllerPage) {
+    await controllerPage.getByText(/Reset/i).first().click();
+    const btnConfirm = controllerPage.locator('.dialog .btn-confirm');
+    if (await btnConfirm.isVisible()) {
+        await btnConfirm.click();
+    }
+    await controllerPage.waitForTimeout(300);
+}
+
+test.describe('Game Operations', () => {
+
+    test('Undo: dovrebbe annullare l\'ultimo punto', async ({ context }) => {
+        const controllerPage = await context.newPage();
+        await controllerPage.goto('http://localhost:3001');
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        await resetGame(controllerPage);
+
+        // Incrementa Home a 1
+        await controllerPage.locator('.team-score.home-bg').click();
+        await controllerPage.waitForTimeout(100);
+        await expect(controllerPage.locator('.team-score.home-bg .team-pts')).toHaveText('1');
+
+        // Annulla
+        await controllerPage.getByText('ANNULLA PUNTO').click();
+        await controllerPage.waitForTimeout(100);
+        await expect(controllerPage.locator('.team-score.home-bg .team-pts')).toHaveText('0');
+    });
+
+    test('Reset: dovrebbe azzerare tutto dopo conferma', async ({ context }) => {
+        const controllerPage = await context.newPage();
+        await controllerPage.goto('http://localhost:3001');
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        // Imposta qualche punto
+        for (let i = 0; i < 5; i++) {
+            await controllerPage.locator('.team-score.home-bg').click();
+            await controllerPage.waitForTimeout(50);
+        }
+        await expect(controllerPage.locator('.team-score.home-bg .team-pts')).toHaveText('5');
+
+        // Reset
+        await resetGame(controllerPage);
+
+        await expect(controllerPage.locator('.team-score.home-bg .team-pts')).toHaveText('0');
+        await expect(controllerPage.locator('.team-score.guest-bg .team-pts')).toHaveText('0');
+    });
+
+    test('Config: dovrebbe cambiare i nomi dei team', async ({ context }) => {
+        const displayPage = await context.newPage();
+        const controllerPage = await context.newPage();
+
+        await displayPage.goto('http://localhost:3000');
+        await controllerPage.goto('http://localhost:3001');
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        // Apri config
+        await controllerPage.getByText('Config').click();
+        await controllerPage.waitForSelector('.dialog-config');
+
+        // Modifica nomi
+        const inputs = controllerPage.locator('.dialog-config .input-field');
+        await inputs.first().fill('Padova');
+        await inputs.nth(1).fill('Milano');
+
+        // Salva
+        await controllerPage.locator('.dialog-config .btn-confirm').click();
+        await controllerPage.waitForTimeout(300);
+
+        // Verifica sul Controller
+        await expect(controllerPage.locator('.team-score.home-bg .team-name')).toHaveText('Padova');
+        await expect(controllerPage.locator('.team-score.guest-bg .team-name')).toHaveText('Milano');
+
+        // Verifica sul Display
+        await expect(displayPage.locator('.hea.home')).toContainText('Padova');
+        await expect(displayPage.locator('.hea.guest')).toContainText('Milano');
+    });
+
+    test('Toggle Formazione: dovrebbe mostrare la formazione sul display', async ({ context }) => {
+        const displayPage = await context.newPage();
+        const controllerPage = await context.newPage();
+
+        await displayPage.goto('http://localhost:3000');
+        await controllerPage.goto('http://localhost:3001');
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        // Inizialmente mostra punteggio, non formazione
+        await expect(displayPage.locator('.punteggio-container')).toBeVisible();
+
+        // Click Formazioni
+        await controllerPage.getByText('Formazioni').click();
+        await controllerPage.waitForTimeout(300);
+
+        // Il display mostra le formazioni
+        await expect(displayPage.locator('.form').first()).toBeVisible();
+    });
+
+    test('Toggle Striscia: dovrebbe nascondere/mostrare la striscia', async ({ context }) => {
+        const displayPage = await context.newPage();
+        const controllerPage = await context.newPage();
+
+        await displayPage.goto('http://localhost:3000');
+        await controllerPage.goto('http://localhost:3001');
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        // Inizialmente la striscia è visibile
+        await expect(displayPage.locator('.striscia')).toBeVisible();
+
+        // Toggle off
+        await controllerPage.getByText('Striscia').click();
+        await controllerPage.waitForTimeout(300);
+        await expect(displayPage.locator('.striscia')).not.toBeVisible();
+
+        // Toggle on
+        await controllerPage.getByText('Striscia').click();
+        await controllerPage.waitForTimeout(300);
+        await expect(displayPage.locator('.striscia')).toBeVisible();
+    });
+
+    test('Cambi: dovrebbe effettuare una sostituzione giocatore', async ({ context }) => {
+        const displayPage = await context.newPage();
+        const controllerPage = await context.newPage();
+
+        await displayPage.goto('http://localhost:3000');
+        await controllerPage.goto('http://localhost:3001');
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        await resetGame(controllerPage);
+
+        // Attiva formazione sul display per verificare
+        await controllerPage.getByText('Formazioni').click();
+        await controllerPage.waitForTimeout(200);
+
+        // Apri cambi → scegli Home
+        await controllerPage.getByRole('button', { name: 'Cambi', exact: true }).click();
+        await controllerPage.waitForTimeout(100);
+        await controllerPage.locator('.dialog .btn-set.home-bg').click();
+        await controllerPage.waitForTimeout(100);
+
+        // Inserisci sostituzione: IN=10, OUT=1
+        const inField = controllerPage.locator('.cambi-in-field').first();
+        const outField = controllerPage.locator('.cambi-out-field').first();
+        await inField.fill('10');
+        await outField.fill('1');
+
+        // Conferma
+        await controllerPage.locator('.dialog .btn-confirm').click();
+        await controllerPage.waitForTimeout(300);
+
+        // Verifica formazione aggiornata sul display
+        const formText = await displayPage.locator('.form.home').textContent();
+        expect(formText).toContain('10');
+    });
+
+    test('Cambi: dovrebbe mostrare errore per giocatore non in formazione', async ({ context }) => {
+        const controllerPage = await context.newPage();
+        await controllerPage.goto('http://localhost:3001');
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        await resetGame(controllerPage);
+
+        // Apri cambi → scegli Home
+        await controllerPage.getByRole('button', { name: 'Cambi', exact: true }).click();
+        await controllerPage.waitForTimeout(100);
+        await controllerPage.locator('.dialog .btn-set.home-bg').click();
+        await controllerPage.waitForTimeout(100);
+
+        // Inserisci sostituzione invalida: OUT=99 (non in formazione)
+        await controllerPage.locator('.cambi-in-field').first().fill('10');
+        await controllerPage.locator('.cambi-out-field').first().fill('99');
+
+        // Conferma
+        await controllerPage.locator('.dialog .btn-confirm').click();
+        await controllerPage.waitForTimeout(200);
+
+        // Dovrebbe mostrare errore
+        await expect(controllerPage.locator('.cambi-error')).toBeVisible();
+    });
+});

tests/e2e/game-simulation.spec.cjs

@@ -0,0 +1,69 @@
+const { test, expect } = require('@playwright/test');
+
+test.describe('Game Simulation', () => {
+    test('Simulazione Partita: Controller aggiunge punti finché non cambia il set', async ({ context }) => {
+        // 1. Setup Pagine
+        const displayPage = await context.newPage();
+        const controllerPage = await context.newPage();
+
+        await displayPage.goto('http://localhost:3000');
+        await controllerPage.goto('http://localhost:3001');
+
+        // Selettori (basati su ID ipotetici o classi, adattali al tuo HTML reale)
+        // Assumo che nel DOM ci siano elementi con ID o classi riconoscibili
+        // E che i punteggi siano visibili.
+
+        // Pulisco lo stato iniziale (reset)
+        const btnReset = controllerPage.getByText(/Reset/i).first();
+        if (await btnReset.isVisible()) {
+            await btnReset.click();
+            // La modale di conferma ha un bottone "SI" con classe .btn-confirm
+            const btnConfirmReset = controllerPage.locator('.dialog .btn-confirm').getByText('SI');
+            if (await btnConfirmReset.isVisible()) {
+                await btnConfirmReset.click();
+            }
+        }
+
+        // 2. Loop per vincere il primo set (25 punti)
+        // In ControllerPage.vue, il click su .team-score.home-bg incrementa i punti home
+        const btnHomeScore = controllerPage.locator('.team-score.home-bg');
+
+        for (let i = 0; i < 25; i++) {
+            await btnHomeScore.click();
+            // Piccola pausa per lasciare tempo al server di processare e broadcastare
+            //await displayPage.waitForTimeout(10); 
+        }
+
+        // 3. Verifica Vittoria Set
+        // I punti dovrebbero essere tornati a 0 (o mostrare 25 prima del reset manuale?)
+        // Il codice gameState dice: checkVittoria -> resetta solo se qualcuno chiama resetta?
+        // No, checkVittoria è boolean. applyAction('incPunt') incrementa.
+        // Se vince, il set incrementa? 'incPunt' non incrementa i set in automatico nel codice gameState checkato prima!
+        // Controllo applyAction:
+        // "s.sp.punt[team]++" ... POI "checkVittoria(s)" all'inizio del prossimo incPunt?
+        // NO: "if (checkVittoria(s)) break" all'inizio di incPunt impedisce di andare oltre 25 se già vinto.
+        // MA 'incSet' è un'azione separata!
+
+        // Aspetta, la logica standard è: arrivo a 25 -> vinco set?
+        // In questo codice `gameState.js` NON c'è automatismo "arrivo a 25 -> set++ e palla al centro".
+        // L'utente deve cliccare "SET Antoniana" manualmente?
+        // Guardiamo ControllerPage.vue:
+        // C'è un bottone "SET {{ state.sp.nomi.home }}" che manda { type: 'incSet', team: 'home' }
+
+        // QUINDI: Il test deve:
+        // 1. Arrivare a 25 pt.
+        // 2. Cliccare "SET HOME".
+        // 3. Verificare che Set Home = 1.
+
+        // Verifica che siamo a 25
+        await expect(controllerPage.locator('.team-score.home-bg .team-pts')).toHaveText('25');
+
+        // Clicca bottone SET
+        const btnSetHome = controllerPage.locator('.btn-set.home-bg');
+        await btnSetHome.click();
+
+        // Verifica che il set sia incrementato
+        // Nota: display potrebbe chiamarsi diversamente, controlliamo Controller per coerenza
+        await expect(controllerPage.locator('.team-score.home-bg .team-set')).toContainText('SET 1');
+    });
+});

tests/e2e/visual-regression.spec.cjs

@@ -0,0 +1,86 @@
+const { test, expect } = require('@playwright/test');
+
+// Helper: reset dal controller
+async function resetGame(controllerPage) {
+    await controllerPage.getByText(/Reset/i).first().click();
+    const btnConfirm = controllerPage.locator('.dialog .btn-confirm');
+    if (await btnConfirm.isVisible()) {
+        await btnConfirm.click();
+    }
+    await controllerPage.waitForTimeout(300);
+}
+
+test.describe('Visual Regression', () => {
+
+    test('Display: screenshot a 0-0', async ({ context }) => {
+        const controllerPage = await context.newPage();
+        const displayPage = await context.newPage();
+
+        await controllerPage.goto('http://localhost:3001');
+        await displayPage.goto('http://localhost:3000');
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        // Reset per stato pulito
+        await resetGame(controllerPage);
+
+        // Attende che il display riceva lo stato
+        await displayPage.waitForTimeout(500);
+
+        await expect(displayPage).toHaveScreenshot('display-0-0.png', {
+            maxDiffPixelRatio: 0.05,
+        });
+    });
+
+    test('Display: screenshot durante partita (15-12)', async ({ context }) => {
+        const controllerPage = await context.newPage();
+        const displayPage = await context.newPage();
+
+        await controllerPage.goto('http://localhost:3001');
+        await displayPage.goto('http://localhost:3000');
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        await resetGame(controllerPage);
+
+        // Porta il punteggio a 15-12
+        for (let i = 0; i < 15; i++) {
+            await controllerPage.locator('.team-score.home-bg').click();
+            await controllerPage.waitForTimeout(20);
+        }
+        for (let i = 0; i < 12; i++) {
+            await controllerPage.locator('.team-score.guest-bg').click();
+            await controllerPage.waitForTimeout(20);
+        }
+        await displayPage.waitForTimeout(500);
+
+        await expect(displayPage).toHaveScreenshot('display-15-12.png', {
+            maxDiffPixelRatio: 0.05,
+        });
+    });
+
+    test('Controller: screenshot stato iniziale', async ({ context }) => {
+        const controllerPage = await context.newPage();
+        await controllerPage.goto('http://localhost:3001');
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        await resetGame(controllerPage);
+
+        await expect(controllerPage).toHaveScreenshot('controller-initial.png', {
+            maxDiffPixelRatio: 0.05,
+        });
+    });
+
+    test('Controller: screenshot con modal config aperta', async ({ context }) => {
+        const controllerPage = await context.newPage();
+        await controllerPage.goto('http://localhost:3001');
+        await controllerPage.waitForSelector('.conn-bar.connected');
+
+        // Apri config
+        await controllerPage.getByText('Config').click();
+        await controllerPage.waitForSelector('.dialog-config');
+        await controllerPage.waitForTimeout(300);
+
+        await expect(controllerPage).toHaveScreenshot('controller-config-modal.png', {
+            maxDiffPixelRatio: 0.05,
+        });
+    });
+});

tests/integration/websocket.test.js

@@ -0,0 +1,403 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest'
+import { setupWebSocketHandler } from '../../src/websocket-handler.js'
+import { EventEmitter } from 'events'
+
+// Mock parziale di una WebSocket e del Server
+class MockWebSocket extends EventEmitter {
+    constructor() {
+        super()
+        this.readyState = 1 // OPEN
+    }
+    send = vi.fn()
+    terminate = vi.fn()
+}
+
+class MockWebSocketServer extends EventEmitter {
+    clients = new Set()
+}
+
+// Helper: connette e registra un client
+function connectAndRegister(wss, role) {
+    const ws = new MockWebSocket()
+    wss.emit('connection', ws)
+    wss.clients.add(ws)
+    ws.emit('message', JSON.stringify({ type: 'register', role }))
+    ws.send.mockClear()
+    return ws
+}
+
+// Helper: ultimo messaggio inviato a un ws
+function lastSent(ws) {
+    const calls = ws.send.mock.calls
+    return JSON.parse(calls[calls.length - 1][0])
+}
+
+describe('WebSocket Integration (websocket-handler.js)', () => {
+    let wss
+    let handler
+
+    beforeEach(() => {
+        wss = new MockWebSocketServer()
+        handler = setupWebSocketHandler(wss)
+    })
+
+    afterEach(() => {
+        vi.restoreAllMocks()
+    })
+
+    // =============================================
+    // REGISTRAZIONE
+    // =============================================
+    describe('Registrazione', () => {
+        it('dovrebbe registrare un client come "display" e inviare lo stato', () => {
+            const ws = new MockWebSocket()
+            wss.emit('connection', ws)
+            wss.clients.add(ws)
+            ws.emit('message', JSON.stringify({ type: 'register', role: 'display' }))
+
+            expect(ws.send).toHaveBeenCalled()
+            const sentMsg = JSON.parse(ws.send.mock.calls[0][0])
+            expect(sentMsg.type).toBe('state')
+            expect(sentMsg.state).toBeDefined()
+        })
+
+        it('dovrebbe registrare un client come "controller"', () => {
+            connectAndRegister(wss, 'controller')
+            expect(handler.getClients().size).toBe(1)
+        })
+
+        it('dovrebbe rifiutare ruolo non valido', () => {
+            const ws = new MockWebSocket()
+            wss.emit('connection', ws)
+            wss.clients.add(ws)
+            ws.emit('message', JSON.stringify({ type: 'register', role: 'hacker' }))
+
+            const sentMsg = JSON.parse(ws.send.mock.calls[0][0])
+            expect(sentMsg.type).toBe('error')
+            expect(sentMsg.message).toContain('Invalid role')
+        })
+
+        it('dovrebbe usare "display" come ruolo default se mancante', () => {
+            const ws = new MockWebSocket()
+            wss.emit('connection', ws)
+            wss.clients.add(ws)
+            ws.emit('message', JSON.stringify({ type: 'register' }))
+
+            const sentMsg = JSON.parse(ws.send.mock.calls[0][0])
+            expect(sentMsg.type).toBe('state')
+        })
+    })
+
+    // =============================================
+    // AZIONI
+    // =============================================
+    describe('Azioni', () => {
+        it('dovrebbe permettere al controller di cambiare il punteggio', () => {
+            const controller = connectAndRegister(wss, 'controller')
+
+            controller.emit('message', JSON.stringify({
+                type: 'action',
+                action: { type: 'incPunt', team: 'home' }
+            }))
+
+            expect(controller.send).toHaveBeenCalled()
+            const sentMsg = lastSent(controller)
+            expect(sentMsg.type).toBe('state')
+            expect(sentMsg.state.sp.punt.home).toBe(1)
+        })
+
+        it('dovrebbe impedire al display di inviare azioni', () => {
+            const display = connectAndRegister(wss, 'display')
+
+            display.emit('message', JSON.stringify({
+                type: 'action',
+                action: { type: 'incPunt', team: 'home' }
+            }))
+
+            const sentMsg = lastSent(display)
+            expect(sentMsg.type).toBe('error')
+            expect(sentMsg.message).toContain('Only controllers')
+        })
+
+        it('dovrebbe impedire azioni da client non registrati', () => {
+            const ws = new MockWebSocket()
+            wss.emit('connection', ws)
+            wss.clients.add(ws)
+
+            ws.emit('message', JSON.stringify({
+                type: 'action',
+                action: { type: 'incPunt', team: 'home' }
+            }))
+
+            const sentMsg = JSON.parse(ws.send.mock.calls[0][0])
+            expect(sentMsg.type).toBe('error')
+            expect(sentMsg.message).toContain('Only controllers')
+        })
+
+        it('dovrebbe rifiutare azione con formato invalido (missing action)', () => {
+            const controller = connectAndRegister(wss, 'controller')
+
+            controller.emit('message', JSON.stringify({
+                type: 'action'
+            }))
+
+            const sentMsg = lastSent(controller)
+            expect(sentMsg.type).toBe('error')
+            expect(sentMsg.message).toContain('Invalid action format')
+        })
+
+        it('dovrebbe rifiutare azione con formato invalido (missing action.type)', () => {
+            const controller = connectAndRegister(wss, 'controller')
+
+            controller.emit('message', JSON.stringify({
+                type: 'action',
+                action: { team: 'home' }
+            }))
+
+            const sentMsg = lastSent(controller)
+            expect(sentMsg.type).toBe('error')
+            expect(sentMsg.message).toContain('Invalid action format')
+        })
+    })
+
+    // =============================================
+    // BROADCAST MULTI-CLIENT
+    // =============================================
+    describe('Broadcast', () => {
+        it('dovrebbe inviare lo stato a tutti i client dopo un\'azione', () => {
+            const controller = connectAndRegister(wss, 'controller')
+            const display1 = connectAndRegister(wss, 'display')
+            const display2 = connectAndRegister(wss, 'display')
+
+            controller.emit('message', JSON.stringify({
+                type: 'action',
+                action: { type: 'incPunt', team: 'home' }
+            }))
+
+            // Tutti i client nel set dovrebbero aver ricevuto lo stato
+            expect(controller.send).toHaveBeenCalled()
+            expect(display1.send).toHaveBeenCalled()
+            expect(display2.send).toHaveBeenCalled()
+
+            const msg1 = lastSent(display1)
+            const msg2 = lastSent(display2)
+            expect(msg1.type).toBe('state')
+            expect(msg1.state.sp.punt.home).toBe(1)
+            expect(msg2.state.sp.punt.home).toBe(1)
+        })
+
+        it('non dovrebbe inviare a client con readyState != OPEN', () => {
+            const controller = connectAndRegister(wss, 'controller')
+            const closedClient = connectAndRegister(wss, 'display')
+            closedClient.readyState = 3 // CLOSED
+
+            controller.emit('message', JSON.stringify({
+                type: 'action',
+                action: { type: 'incPunt', team: 'home' }
+            }))
+
+            // closedClient non dovrebbe aver ricevuto il broadcast
+            expect(closedClient.send).not.toHaveBeenCalled()
+        })
+    })
+
+    // =============================================
+    // SPEAK
+    // =============================================
+    describe('Speak', () => {
+        it('dovrebbe inoltrare il messaggio speak solo ai display', () => {
+            const controller = connectAndRegister(wss, 'controller')
+            const display = connectAndRegister(wss, 'display')
+
+            controller.emit('message', JSON.stringify({
+                type: 'speak',
+                text: 'quindici a dieci'
+            }))
+
+            // Il display riceve il messaggio speak
+            expect(display.send).toHaveBeenCalled()
+            const msg = lastSent(display)
+            expect(msg.type).toBe('speak')
+            expect(msg.text).toBe('quindici a dieci')
+        })
+
+        it('non dovrebbe permettere al display di inviare speak', () => {
+            const display = connectAndRegister(wss, 'display')
+
+            display.emit('message', JSON.stringify({
+                type: 'speak',
+                text: 'test'
+            }))
+
+            const msg = lastSent(display)
+            expect(msg.type).toBe('error')
+            expect(msg.message).toContain('Only controllers')
+        })
+
+        it('dovrebbe rifiutare speak con testo vuoto', () => {
+            const controller = connectAndRegister(wss, 'controller')
+
+            controller.emit('message', JSON.stringify({
+                type: 'speak',
+                text: '   '
+            }))
+
+            const msg = lastSent(controller)
+            expect(msg.type).toBe('error')
+            expect(msg.message).toContain('Invalid speak payload')
+        })
+
+        it('dovrebbe rifiutare speak senza testo', () => {
+            const controller = connectAndRegister(wss, 'controller')
+
+            controller.emit('message', JSON.stringify({
+                type: 'speak'
+            }))
+
+            const msg = lastSent(controller)
+            expect(msg.type).toBe('error')
+        })
+
+        it('dovrebbe fare trim del testo speak', () => {
+            const controller = connectAndRegister(wss, 'controller')
+            const display = connectAndRegister(wss, 'display')
+
+            controller.emit('message', JSON.stringify({
+                type: 'speak',
+                text: '  dieci a otto  '
+            }))
+
+            const msg = lastSent(display)
+            expect(msg.text).toBe('dieci a otto')
+        })
+    })
+
+    // =============================================
+    // MESSAGGI MALFORMATI
+    // =============================================
+    describe('Messaggi malformati', () => {
+        it('dovrebbe gestire JSON non valido senza crash', () => {
+            const ws = new MockWebSocket()
+            wss.emit('connection', ws)
+            wss.clients.add(ws)
+
+            expect(() => {
+                ws.emit('message', 'questo non è JSON {{{')
+            }).not.toThrow()
+
+            const msg = lastSent(ws)
+            expect(msg.type).toBe('error')
+            expect(msg.message).toContain('Invalid message format')
+        })
+
+        it('dovrebbe gestire Buffer come input', () => {
+            const controller = connectAndRegister(wss, 'controller')
+
+            const buf = Buffer.from(JSON.stringify({
+                type: 'action',
+                action: { type: 'incPunt', team: 'home' }
+            }))
+
+            controller.emit('message', buf)
+
+            const msg = lastSent(controller)
+            expect(msg.type).toBe('state')
+            expect(msg.state.sp.punt.home).toBe(1)
+        })
+    })
+
+    // =============================================
+    // DISCONNESSIONE
+    // =============================================
+    describe('Disconnessione', () => {
+        it('dovrebbe rimuovere il client dalla mappa alla disconnessione', () => {
+            const controller = connectAndRegister(wss, 'controller')
+            expect(handler.getClients().size).toBe(1)
+
+            controller.emit('close')
+
+            expect(handler.getClients().size).toBe(0)
+        })
+
+        it('i client rimanenti non dovrebbero essere affetti dalla disconnessione', () => {
+            const controller = connectAndRegister(wss, 'controller')
+            const display = connectAndRegister(wss, 'display')
+            expect(handler.getClients().size).toBe(2)
+
+            controller.emit('close')
+            expect(handler.getClients().size).toBe(1)
+
+            expect(handler.getClients().has(display)).toBe(true)
+        })
+    })
+
+    // =============================================
+    // ERRORI WEBSOCKET
+    // =============================================
+    describe('Errori WebSocket', () => {
+        it('dovrebbe terminare la connessione per errore UTF8 invalido', () => {
+            const ws = new MockWebSocket()
+            wss.emit('connection', ws)
+
+            const err = new Error('Invalid UTF8')
+            err.code = 'WS_ERR_INVALID_UTF8'
+            ws.emit('error', err)
+
+            expect(ws.terminate).toHaveBeenCalled()
+        })
+
+        it('dovrebbe terminare la connessione per close code invalido', () => {
+            const ws = new MockWebSocket()
+            wss.emit('connection', ws)
+
+            const err = new Error('Invalid close code')
+            err.code = 'WS_ERR_INVALID_CLOSE_CODE'
+            ws.emit('error', err)
+
+            expect(ws.terminate).toHaveBeenCalled()
+        })
+
+        it('non dovrebbe terminare per altri errori', () => {
+            const ws = new MockWebSocket()
+            wss.emit('connection', ws)
+
+            const err = new Error('Generic error')
+            ws.emit('error', err)
+
+            expect(ws.terminate).not.toHaveBeenCalled()
+        })
+    })
+
+    // =============================================
+    // API PUBBLICA
+    // =============================================
+    describe('API pubblica', () => {
+        it('getState dovrebbe restituire lo stato corrente', () => {
+            const state = handler.getState()
+            expect(state.sp.punt.home).toBe(0)
+            expect(state.sp.punt.guest).toBe(0)
+        })
+
+        it('setState dovrebbe sovrascrivere lo stato', () => {
+            const newState = handler.getState()
+            newState.sp.punt.home = 99
+            handler.setState(newState)
+            expect(handler.getState().sp.punt.home).toBe(99)
+        })
+
+        it('broadcastState dovrebbe inviare a tutti i client', () => {
+            const display = connectAndRegister(wss, 'display')
+            handler.broadcastState()
+            expect(display.send).toHaveBeenCalled()
+            const msg = lastSent(display)
+            expect(msg.type).toBe('state')
+        })
+
+        it('getClients dovrebbe restituire la mappa dei client', () => {
+            expect(handler.getClients()).toBeInstanceOf(Map)
+            expect(handler.getClients().size).toBe(0)
+            connectAndRegister(wss, 'display')
+            expect(handler.getClients().size).toBe(1)
+        })
+    })
+})

tests/stress/websocket-load.test.js

@@ -0,0 +1,118 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest'
+import { setupWebSocketHandler } from '../../src/websocket-handler.js'
+import { EventEmitter } from 'events'
+
+class MockWebSocket extends EventEmitter {
+    constructor() {
+        super()
+        this.readyState = 1
+    }
+    send = vi.fn()
+    terminate = vi.fn()
+}
+
+class MockWebSocketServer extends EventEmitter {
+    clients = new Set()
+}
+
+function connectAndRegister(wss, role) {
+    const ws = new MockWebSocket()
+    wss.emit('connection', ws)
+    wss.clients.add(ws)
+    ws.emit('message', JSON.stringify({ type: 'register', role }))
+    ws.send.mockClear()
+    return ws
+}
+
+describe('Stress Test WebSocket', () => {
+    let wss
+    let handler
+
+    beforeEach(() => {
+        wss = new MockWebSocketServer()
+        handler = setupWebSocketHandler(wss)
+    })
+
+    afterEach(() => {
+        vi.restoreAllMocks()
+    })
+
+    it('dovrebbe gestire 50 client display connessi simultaneamente', () => {
+        const displays = []
+        for (let i = 0; i < 50; i++) {
+            displays.push(connectAndRegister(wss, 'display'))
+        }
+
+        expect(handler.getClients().size).toBe(50)
+
+        // Un controller invia un'azione
+        const controller = connectAndRegister(wss, 'controller')
+        controller.emit('message', JSON.stringify({
+            type: 'action',
+            action: { type: 'incPunt', team: 'home' }
+        }))
+
+        // Tutti i display devono aver ricevuto il broadcast
+        for (const display of displays) {
+            expect(display.send).toHaveBeenCalled()
+            const msg = JSON.parse(display.send.mock.calls[display.send.mock.calls.length - 1][0])
+            expect(msg.type).toBe('state')
+            expect(msg.state.sp.punt.home).toBe(1)
+        }
+    })
+
+    it('dovrebbe gestire 100 azioni rapide in sequenza con stato finale corretto', () => {
+        const controller = connectAndRegister(wss, 'controller')
+
+        // 60 punti home, 40 punti guest
+        for (let i = 0; i < 60; i++) {
+            controller.emit('message', JSON.stringify({
+                type: 'action',
+                action: { type: 'incPunt', team: 'home' }
+            }))
+        }
+        for (let i = 0; i < 40; i++) {
+            controller.emit('message', JSON.stringify({
+                type: 'action',
+                action: { type: 'incPunt', team: 'guest' }
+            }))
+        }
+
+        // Lo stato finale dipende da checkVittoria che blocca a 25+2
+        // Home arriva a 25-0 → vittoria → blocca. Quindi punti home = 25
+        const state = handler.getState()
+        expect(state.sp.punt.home).toBe(25)
+        // Guest: non può segnare dopo vittoria? No, checkVittoria blocca solo il team che ha vinto?
+        // Controlliamo: checkVittoria controlla ENTRAMBI i team.
+        // A 25-0 → vittoria=true → incPunt per guest è anche bloccato
+        expect(state.sp.punt.guest).toBe(0)
+    })
+
+    it('dovrebbe garantire che tutti i display ricevano ogni update sotto carico', () => {
+        const displays = []
+        for (let i = 0; i < 10; i++) {
+            displays.push(connectAndRegister(wss, 'display'))
+        }
+
+        const controller = connectAndRegister(wss, 'controller')
+
+        // 5 azioni rapide
+        for (let i = 0; i < 5; i++) {
+            controller.emit('message', JSON.stringify({
+                type: 'action',
+                action: { type: 'incPunt', team: 'home' }
+            }))
+        }
+
+        // Ogni display deve aver ricevuto esattamente 5 broadcast
+        for (const display of displays) {
+            expect(display.send).toHaveBeenCalledTimes(5)
+        }
+
+        // Verifica stato finale su tutti i display
+        for (const display of displays) {
+            const lastMsg = JSON.parse(display.send.mock.calls[4][0])
+            expect(lastMsg.state.sp.punt.home).toBe(5)
+        }
+    })
+})

tests/unit/gameState.test.js

@@ -0,0 +1,695 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { createInitialState, applyAction, checkVittoria } from '../../src/gameState.js'
+
+describe('Game Logic (gameState.js)', () => {
+    let state
+
+    beforeEach(() => {
+        state = createInitialState()
+    })
+
+    // =============================================
+    // STATO INIZIALE
+    // =============================================
+    describe('Stato iniziale', () => {
+        it('dovrebbe iniziare con 0-0', () => {
+            expect(state.sp.punt.home).toBe(0)
+            expect(state.sp.punt.guest).toBe(0)
+        })
+
+        it('dovrebbe avere i set a 0', () => {
+            expect(state.sp.set.home).toBe(0)
+            expect(state.sp.set.guest).toBe(0)
+        })
+
+        it('dovrebbe avere servizio Home', () => {
+            expect(state.sp.servHome).toBe(true)
+        })
+
+        it('dovrebbe avere formazione di default [1-6]', () => {
+            expect(state.sp.form.home).toEqual(["1", "2", "3", "4", "5", "6"])
+            expect(state.sp.form.guest).toEqual(["1", "2", "3", "4", "5", "6"])
+        })
+
+        it('dovrebbe avere la striscia iniziale con un set vuoto', () => {
+            expect(state.sp.striscia).toHaveLength(1)
+            expect(state.sp.striscia[0].serv).toBe('home')
+            expect(state.sp.striscia[0].r).toEqual([])
+        })
+
+        it('dovrebbe avere modalità 3/5 di default', () => {
+            expect(state.modalitaPartita).toBe("3/5")
+        })
+
+        it('dovrebbe avere visuForm false e visuStriscia true', () => {
+            expect(state.visuForm).toBe(false)
+            expect(state.visuStriscia).toBe(true)
+        })
+    })
+
+    // =============================================
+    // IMMUTABILITÀ
+    // =============================================
+    describe('Immutabilità', () => {
+        it('applyAction non dovrebbe mutare lo stato originale', () => {
+            const original = JSON.stringify(state)
+            applyAction(state, { type: 'incPunt', team: 'home' })
+            expect(JSON.stringify(state)).toBe(original)
+        })
+
+        it('dovrebbe restituire un nuovo oggetto', () => {
+            const newState = applyAction(state, { type: 'incPunt', team: 'home' })
+            expect(newState).not.toBe(state)
+        })
+    })
+
+    // =============================================
+    // INCREMENTO PUNTI (incPunt)
+    // =============================================
+    describe('incPunt', () => {
+        it('dovrebbe incrementare i punti Home', () => {
+            const newState = applyAction(state, { type: 'incPunt', team: 'home' })
+            expect(newState.sp.punt.home).toBe(1)
+            expect(newState.sp.punt.guest).toBe(0)
+        })
+
+        it('dovrebbe incrementare i punti Guest', () => {
+            const newState = applyAction(state, { type: 'incPunt', team: 'guest' })
+            expect(newState.sp.punt.guest).toBe(1)
+            expect(newState.sp.punt.home).toBe(0)
+        })
+
+        it('dovrebbe gestire il cambio palla (Guest segna, batteva Home)', () => {
+            state.sp.servHome = true
+            const s1 = applyAction(state, { type: 'incPunt', team: 'guest' })
+            expect(s1.sp.servHome).toBe(false)
+        })
+
+        it('dovrebbe gestire il cambio palla (Home segna, batteva Guest)', () => {
+            state.sp.servHome = false
+            const s1 = applyAction(state, { type: 'incPunt', team: 'home' })
+            expect(s1.sp.servHome).toBe(true)
+        })
+
+        it('non dovrebbe cambiare palla se segna chi batte', () => {
+            state.sp.servHome = true
+            const s1 = applyAction(state, { type: 'incPunt', team: 'home' })
+            expect(s1.sp.servHome).toBe(true)
+        })
+
+        it('dovrebbe ruotare la formazione al cambio palla', () => {
+            state.sp.servHome = true
+            state.sp.form.guest = ["1", "2", "3", "4", "5", "6"]
+            const newState = applyAction(state, { type: 'incPunt', team: 'guest' })
+            expect(newState.sp.form.guest).toEqual(["2", "3", "4", "5", "6", "1"])
+        })
+
+        it('non dovrebbe ruotare la formazione se non c\'è cambio palla', () => {
+            state.sp.servHome = true
+            state.sp.form.home = ["1", "2", "3", "4", "5", "6"]
+            const newState = applyAction(state, { type: 'incPunt', team: 'home' })
+            expect(newState.sp.form.home).toEqual(["1", "2", "3", "4", "5", "6"])
+        })
+
+        it('dovrebbe aggiornare la striscia per punto Home', () => {
+            const s = applyAction(state, { type: 'incPunt', team: 'home' })
+            expect(s.sp.striscia.at(-1).r).toEqual(['home'])
+        })
+
+        it('dovrebbe aggiornare la striscia per punto Guest', () => {
+            const s = applyAction(state, { type: 'incPunt', team: 'guest' })
+            expect(s.sp.striscia.at(-1).r).toEqual(['guest'])
+        })
+
+        it('dovrebbe registrare scorer nella striscia', () => {
+            let s = applyAction(state, { type: 'incPunt', team: 'home' })
+            s = applyAction(s, { type: 'incPunt', team: 'guest' })
+            s = applyAction(s, { type: 'incPunt', team: 'home' })
+            expect(s.sp.striscia.at(-1).r).toEqual(['home', 'guest', 'home'])
+        })
+
+        it('non dovrebbe incrementare i punti dopo vittoria', () => {
+            state.sp.punt.home = 25
+            state.sp.punt.guest = 23
+            const s = applyAction(state, { type: 'incPunt', team: 'home' })
+            expect(s.sp.punt.home).toBe(25)
+        })
+    })
+
+    // =============================================
+    // DECREMENTO PUNTI (decPunt)
+    // =============================================
+    describe('decPunt', () => {
+        it('dovrebbe annullare l\'ultimo punto Home', () => {
+            const s1 = applyAction(state, { type: 'incPunt', team: 'home' })
+            const s2 = applyAction(s1, { type: 'decPunt' })
+            expect(s2.sp.punt.home).toBe(0)
+            expect(s2.sp.punt.guest).toBe(0)
+        })
+
+        it('dovrebbe annullare l\'ultimo punto Guest', () => {
+            const s1 = applyAction(state, { type: 'incPunt', team: 'guest' })
+            const s2 = applyAction(s1, { type: 'decPunt' })
+            expect(s2.sp.punt.home).toBe(0)
+            expect(s2.sp.punt.guest).toBe(0)
+        })
+
+        it('non dovrebbe fare nulla sullo stato iniziale', () => {
+            const s = applyAction(state, { type: 'decPunt' })
+            expect(s.sp.punt.home).toBe(0)
+            expect(s.sp.punt.guest).toBe(0)
+        })
+
+        it('dovrebbe ripristinare il servizio dopo undo con cambio palla', () => {
+            state.sp.servHome = true
+            const s1 = applyAction(state, { type: 'incPunt', team: 'guest' })
+            expect(s1.sp.servHome).toBe(false)
+            const s2 = applyAction(s1, { type: 'decPunt' })
+            expect(s2.sp.servHome).toBe(true)
+        })
+
+        it('dovrebbe invertire la rotazione dopo undo con cambio palla', () => {
+            state.sp.servHome = true
+            state.sp.form.guest = ["1", "2", "3", "4", "5", "6"]
+            const s1 = applyAction(state, { type: 'incPunt', team: 'guest' })
+            expect(s1.sp.form.guest).toEqual(["2", "3", "4", "5", "6", "1"])
+            const s2 = applyAction(s1, { type: 'decPunt' })
+            expect(s2.sp.form.guest).toEqual(["1", "2", "3", "4", "5", "6"])
+        })
+
+        it('dovrebbe ripristinare la striscia', () => {
+            const s1 = applyAction(state, { type: 'incPunt', team: 'home' })
+            const s2 = applyAction(s1, { type: 'decPunt' })
+            expect(s2.sp.striscia.at(-1).r).toEqual([])
+        })
+
+        it('dovrebbe gestire undo multipli in sequenza', () => {
+            let s = state
+            s = applyAction(s, { type: 'incPunt', team: 'home' })
+            s = applyAction(s, { type: 'incPunt', team: 'guest' })
+            s = applyAction(s, { type: 'incPunt', team: 'home' })
+            expect(s.sp.punt.home).toBe(2)
+            expect(s.sp.punt.guest).toBe(1)
+            s = applyAction(s, { type: 'decPunt' })
+            expect(s.sp.punt.home).toBe(1)
+            s = applyAction(s, { type: 'decPunt' })
+            expect(s.sp.punt.guest).toBe(0)
+            s = applyAction(s, { type: 'decPunt' })
+            expect(s.sp.punt.home).toBe(0)
+        })
+    })
+
+    // =============================================
+    // INCREMENTO SET (incSet)
+    // =============================================
+    describe('incSet', () => {
+        it('dovrebbe incrementare il set Home', () => {
+            const s = applyAction(state, { type: 'incSet', team: 'home' })
+            expect(s.sp.set.home).toBe(1)
+        })
+
+        it('dovrebbe incrementare il set Guest', () => {
+            const s = applyAction(state, { type: 'incSet', team: 'guest' })
+            expect(s.sp.set.guest).toBe(1)
+        })
+
+        it('dovrebbe fare wrap da 2 a 0', () => {
+            state.sp.set.home = 2
+            const s = applyAction(state, { type: 'incSet', team: 'home' })
+            expect(s.sp.set.home).toBe(0)
+        })
+
+        it('dovrebbe incrementare da 1 a 2', () => {
+            state.sp.set.home = 1
+            const s = applyAction(state, { type: 'incSet', team: 'home' })
+            expect(s.sp.set.home).toBe(2)
+        })
+    })
+
+    // =============================================
+    // NUOVO SET (nuovoSet)
+    // =============================================
+    describe('nuovoSet', () => {
+        it('dovrebbe incrementare il set della squadra vincente', () => {
+            state.sp.punt.home = 25
+            const s = applyAction(state, { type: 'nuovoSet', team: 'home' })
+            expect(s.sp.set.home).toBe(1)
+            expect(s.sp.set.guest).toBe(0)
+        })
+
+        it('dovrebbe azzerare i punti', () => {
+            state.sp.punt.home = 25
+            state.sp.punt.guest = 10
+            const s = applyAction(state, { type: 'nuovoSet', team: 'home' })
+            expect(s.sp.punt.home).toBe(0)
+            expect(s.sp.punt.guest).toBe(0)
+        })
+
+        it('dovrebbe aggiungere un nuovo set vuoto alla striscia', () => {
+            const s = applyAction(state, { type: 'nuovoSet', team: 'home' })
+            expect(s.sp.striscia).toHaveLength(2)
+            expect(s.sp.striscia.at(-1).r).toEqual([])
+            expect(s.sp.striscia.at(-1).serv).toBe('home')
+        })
+
+        it('dovrebbe conservare il set precedente nella striscia', () => {
+            state.sp.striscia[0].r = ['home', 'guest', 'home']
+            const s = applyAction(state, { type: 'nuovoSet', team: 'home' })
+            expect(s.sp.striscia[0].r).toEqual(['home', 'guest', 'home'])
+        })
+
+        it('dovrebbe resettare le formazioni', () => {
+            state.sp.form.home = ['7', '8', '9', '10', '11', '12']
+            state.sp.form.guest = ['7', '8', '9', '10', '11', '12']
+            const s = applyAction(state, { type: 'nuovoSet', team: 'home' })
+            expect(s.sp.form.home).toEqual(['1', '2', '3', '4', '5', '6'])
+            expect(s.sp.form.guest).toEqual(['1', '2', '3', '4', '5', '6'])
+        })
+
+        it('dovrebbe ignorare team non valido', () => {
+            const s = applyAction(state, { type: 'nuovoSet', team: 'invalid' })
+            expect(s.sp.set.home).toBe(0)
+            expect(s.sp.set.guest).toBe(0)
+        })
+    })
+
+    // =============================================
+    // CAMBIO PALLA (cambiaPalla)
+    // =============================================
+    describe('cambiaPalla', () => {
+        it('dovrebbe invertire il servizio a 0-0', () => {
+            expect(state.sp.servHome).toBe(true)
+            const s = applyAction(state, { type: 'cambiaPalla' })
+            expect(s.sp.servHome).toBe(false)
+        })
+
+        it('dovrebbe tornare a Home con doppio toggle', () => {
+            let s = applyAction(state, { type: 'cambiaPalla' })
+            s = applyAction(s, { type: 'cambiaPalla' })
+            expect(s.sp.servHome).toBe(true)
+        })
+
+        it('non dovrebbe cambiare palla se il punteggio non è 0-0', () => {
+            state.sp.punt.home = 1
+            const s = applyAction(state, { type: 'cambiaPalla' })
+            expect(s.sp.servHome).toBe(true)
+        })
+
+        it('non dovrebbe cambiare palla se Guest ha punti', () => {
+            state.sp.punt.guest = 3
+            const s = applyAction(state, { type: 'cambiaPalla' })
+            expect(s.sp.servHome).toBe(true)
+        })
+    })
+
+    // =============================================
+    // TOGGLE (toggleFormazione, toggleStriscia, toggleOrder)
+    // =============================================
+    describe('Toggle', () => {
+        it('toggleFormazione: false → true', () => {
+            expect(state.visuForm).toBe(false)
+            const s = applyAction(state, { type: 'toggleFormazione' })
+            expect(s.visuForm).toBe(true)
+        })
+
+        it('toggleFormazione: true → false', () => {
+            state.visuForm = true
+            const s = applyAction(state, { type: 'toggleFormazione' })
+            expect(s.visuForm).toBe(false)
+        })
+
+        it('toggleStriscia: true → false', () => {
+            expect(state.visuStriscia).toBe(true)
+            const s = applyAction(state, { type: 'toggleStriscia' })
+            expect(s.visuStriscia).toBe(false)
+        })
+
+        it('toggleOrder: true → false', () => {
+            expect(state.order).toBe(true)
+            const s = applyAction(state, { type: 'toggleOrder' })
+            expect(s.order).toBe(false)
+        })
+    })
+
+    // =============================================
+    // NOMI (setNomi)
+    // =============================================
+    describe('setNomi', () => {
+        it('dovrebbe aggiornare entrambi i nomi', () => {
+            const s = applyAction(state, { type: 'setNomi', home: 'Volley A', guest: 'Volley B' })
+            expect(s.sp.nomi.home).toBe('Volley A')
+            expect(s.sp.nomi.guest).toBe('Volley B')
+        })
+
+        it('dovrebbe aggiornare solo il nome Home se guest è undefined', () => {
+            const s = applyAction(state, { type: 'setNomi', home: 'Volley A' })
+            expect(s.sp.nomi.home).toBe('Volley A')
+            expect(s.sp.nomi.guest).toBe('Guest')
+        })
+
+        it('dovrebbe aggiornare solo il nome Guest se home è undefined', () => {
+            const s = applyAction(state, { type: 'setNomi', guest: 'Volley B' })
+            expect(s.sp.nomi.home).toBe('Antoniana')
+            expect(s.sp.nomi.guest).toBe('Volley B')
+        })
+    })
+
+    // =============================================
+    // MODALITÀ (setModalita)
+    // =============================================
+    describe('setModalita', () => {
+        it('dovrebbe cambiare in 2/3', () => {
+            const s = applyAction(state, { type: 'setModalita', modalita: '2/3' })
+            expect(s.modalitaPartita).toBe('2/3')
+        })
+
+        it('dovrebbe cambiare in 3/5', () => {
+            state.modalitaPartita = '2/3'
+            const s = applyAction(state, { type: 'setModalita', modalita: '3/5' })
+            expect(s.modalitaPartita).toBe('3/5')
+        })
+    })
+
+    // =============================================
+    // FORMAZIONE (setFormazione)
+    // =============================================
+    describe('setFormazione', () => {
+        it('dovrebbe sostituire la formazione Home', () => {
+            const nuova = ["10", "11", "12", "13", "14", "15"]
+            const s = applyAction(state, { type: 'setFormazione', team: 'home', form: nuova })
+            expect(s.sp.form.home).toEqual(nuova)
+        })
+
+        it('dovrebbe sostituire la formazione Guest', () => {
+            const nuova = ["7", "8", "9", "10", "11", "12"]
+            const s = applyAction(state, { type: 'setFormazione', team: 'guest', form: nuova })
+            expect(s.sp.form.guest).toEqual(nuova)
+        })
+
+        it('non dovrebbe modificare se manca team', () => {
+            const s = applyAction(state, { type: 'setFormazione', form: ["7", "8", "9", "10", "11", "12"] })
+            expect(s.sp.form.home).toEqual(["1", "2", "3", "4", "5", "6"])
+        })
+
+        it('non dovrebbe modificare se manca form', () => {
+            const s = applyAction(state, { type: 'setFormazione', team: 'home' })
+            expect(s.sp.form.home).toEqual(["1", "2", "3", "4", "5", "6"])
+        })
+    })
+
+    // =============================================
+    // CAMBI GIOCATORI (confermaCambi)
+    // =============================================
+    describe('confermaCambi', () => {
+        it('dovrebbe effettuare una sostituzione valida', () => {
+            state.sp.form.home = ["1", "2", "3", "4", "5", "6"]
+            const s = applyAction(state, {
+                type: 'confermaCambi',
+                team: 'home',
+                cambi: [{ in: "10", out: "3" }]
+            })
+            expect(s.sp.form.home).toContain("10")
+            expect(s.sp.form.home).not.toContain("3")
+        })
+
+        it('dovrebbe gestire doppia sostituzione', () => {
+            state.sp.form.home = ["1", "2", "3", "4", "5", "6"]
+            const s = applyAction(state, {
+                type: 'confermaCambi',
+                team: 'home',
+                cambi: [
+                    { in: "10", out: "1" },
+                    { in: "11", out: "2" }
+                ]
+            })
+            expect(s.sp.form.home).toContain("10")
+            expect(s.sp.form.home).toContain("11")
+            expect(s.sp.form.home).not.toContain("1")
+            expect(s.sp.form.home).not.toContain("2")
+        })
+
+        it('non dovrebbe accettare input non numerico', () => {
+            state.sp.form.home = ["1", "2", "3", "4", "5", "6"]
+            const s = applyAction(state, {
+                type: 'confermaCambi',
+                team: 'home',
+                cambi: [{ in: "abc", out: "1" }]
+            })
+            expect(s.sp.form.home).toEqual(["1", "2", "3", "4", "5", "6"])
+        })
+
+        it('non dovrebbe accettare in == out', () => {
+            const s = applyAction(state, {
+                type: 'confermaCambi',
+                team: 'home',
+                cambi: [{ in: "1", out: "1" }]
+            })
+            expect(s.sp.form.home).toEqual(["1", "2", "3", "4", "5", "6"])
+        })
+
+        it('non dovrebbe accettare giocatore IN già in formazione', () => {
+            const s = applyAction(state, {
+                type: 'confermaCambi',
+                team: 'home',
+                cambi: [{ in: "2", out: "1" }]
+            })
+            expect(s.sp.form.home).toEqual(["1", "2", "3", "4", "5", "6"])
+        })
+
+        it('non dovrebbe accettare giocatore OUT non in formazione', () => {
+            const s = applyAction(state, {
+                type: 'confermaCambi',
+                team: 'home',
+                cambi: [{ in: "10", out: "99" }]
+            })
+            expect(s.sp.form.home).toEqual(["1", "2", "3", "4", "5", "6"])
+        })
+
+        it('dovrebbe saltare cambi con campo vuoto', () => {
+            const s = applyAction(state, {
+                type: 'confermaCambi',
+                team: 'home',
+                cambi: [
+                    { in: "", out: "" },
+                    { in: "10", out: "1" }
+                ]
+            })
+            expect(s.sp.form.home).toContain("10")
+        })
+
+        it('dovrebbe mantenere la posizione del giocatore sostituito', () => {
+            state.sp.form.home = ["1", "2", "3", "4", "5", "6"]
+            const s = applyAction(state, {
+                type: 'confermaCambi',
+                team: 'home',
+                cambi: [{ in: "10", out: "3" }]
+            })
+            expect(s.sp.form.home[2]).toBe("10")
+        })
+
+        it('dovrebbe gestire cambi sequenziali che dipendono l\'uno dall\'altro', () => {
+            // Sostituisci 1→10, poi 10→20 (il secondo dipende dal risultato del primo)
+            state.sp.form.home = ["1", "2", "3", "4", "5", "6"]
+            const s = applyAction(state, {
+                type: 'confermaCambi',
+                team: 'home',
+                cambi: [
+                    { in: "10", out: "1" },
+                    { in: "20", out: "10" }
+                ]
+            })
+            expect(s.sp.form.home).toContain("20")
+            expect(s.sp.form.home).not.toContain("1")
+            expect(s.sp.form.home).not.toContain("10")
+        })
+    })
+
+    // =============================================
+    // VITTORIA SET (checkVittoria)
+    // =============================================
+    describe('checkVittoria', () => {
+        it('non dovrebbe dare vittoria a 24-24', () => {
+            state.sp.punt.home = 24
+            state.sp.punt.guest = 24
+            expect(checkVittoria(state)).toBe(false)
+        })
+
+        it('dovrebbe dare vittoria a 25-23', () => {
+            state.sp.punt.home = 25
+            state.sp.punt.guest = 23
+            expect(checkVittoria(state)).toBe(true)
+        })
+
+        it('non dovrebbe dare vittoria a 25-24 (serve 2 punti di scarto)', () => {
+            state.sp.punt.home = 25
+            state.sp.punt.guest = 24
+            expect(checkVittoria(state)).toBe(false)
+        })
+
+        it('dovrebbe dare vittoria a 26-24', () => {
+            state.sp.punt.home = 26
+            state.sp.punt.guest = 24
+            expect(checkVittoria(state)).toBe(true)
+        })
+
+        it('dovrebbe dare vittoria Guest a 25-20', () => {
+            state.sp.punt.home = 20
+            state.sp.punt.guest = 25
+            expect(checkVittoria(state)).toBe(true)
+        })
+
+        it('dovrebbe dare vittoria ai vantaggi (30-28)', () => {
+            state.sp.punt.home = 30
+            state.sp.punt.guest = 28
+            expect(checkVittoria(state)).toBe(true)
+        })
+
+        it('non dovrebbe dare vittoria ai vantaggi senza scarto (28-27)', () => {
+            state.sp.punt.home = 28
+            state.sp.punt.guest = 27
+            expect(checkVittoria(state)).toBe(false)
+        })
+    })
+
+    // =============================================
+    // SET DECISIVO (15 punti)
+    // =============================================
+    describe('Set decisivo', () => {
+        it('modalità 3/5: set decisivo dopo 4 set totali → vittoria a 15', () => {
+            state.modalitaPartita = "3/5"
+            state.sp.set.home = 2
+            state.sp.set.guest = 2
+            state.sp.punt.home = 15
+            state.sp.punt.guest = 10
+            expect(checkVittoria(state)).toBe(true)
+        })
+
+        it('modalità 3/5: non vittoria a 14-10 nel set decisivo', () => {
+            state.modalitaPartita = "3/5"
+            state.sp.set.home = 2
+            state.sp.set.guest = 2
+            state.sp.punt.home = 14
+            state.sp.punt.guest = 10
+            expect(checkVittoria(state)).toBe(false)
+        })
+
+        it('modalità 3/5: vittoria a 15-13 nel set decisivo', () => {
+            state.modalitaPartita = "3/5"
+            state.sp.set.home = 2
+            state.sp.set.guest = 2
+            state.sp.punt.home = 15
+            state.sp.punt.guest = 13
+            expect(checkVittoria(state)).toBe(true)
+        })
+
+        it('modalità 3/5: non vittoria a 15-14 nel set decisivo (serve scarto)', () => {
+            state.modalitaPartita = "3/5"
+            state.sp.set.home = 2
+            state.sp.set.guest = 2
+            state.sp.punt.home = 15
+            state.sp.punt.guest = 14
+            expect(checkVittoria(state)).toBe(false)
+        })
+
+        it('modalità 3/5: vittoria a 16-14 nel set decisivo', () => {
+            state.modalitaPartita = "3/5"
+            state.sp.set.home = 2
+            state.sp.set.guest = 2
+            state.sp.punt.home = 16
+            state.sp.punt.guest = 14
+            expect(checkVittoria(state)).toBe(true)
+        })
+
+        it('modalità 2/3: set decisivo dopo 2 set totali → vittoria a 15', () => {
+            state.modalitaPartita = "2/3"
+            state.sp.set.home = 1
+            state.sp.set.guest = 1
+            state.sp.punt.home = 15
+            state.sp.punt.guest = 10
+            expect(checkVittoria(state)).toBe(true)
+        })
+
+        it('modalità 2/3: non vittoria a 24-20 nel set decisivo (soglia 15)', () => {
+            state.modalitaPartita = "2/3"
+            state.sp.set.home = 1
+            state.sp.set.guest = 1
+            state.sp.punt.home = 14
+            state.sp.punt.guest = 10
+            expect(checkVittoria(state)).toBe(false)
+        })
+
+        it('modalità 2/3: set non decisivo (1-0) → soglia 25', () => {
+            state.modalitaPartita = "2/3"
+            state.sp.set.home = 1
+            state.sp.set.guest = 0
+            state.sp.punt.home = 15
+            state.sp.punt.guest = 10
+            expect(checkVittoria(state)).toBe(false)
+        })
+
+        it('modalità 3/5: set non decisivo (2-1) → soglia 25', () => {
+            state.modalitaPartita = "3/5"
+            state.sp.set.home = 2
+            state.sp.set.guest = 1
+            state.sp.punt.home = 15
+            state.sp.punt.guest = 10
+            expect(checkVittoria(state)).toBe(false)
+        })
+    })
+
+    // =============================================
+    // RESET
+    // =============================================
+    describe('Reset', () => {
+        it('dovrebbe resettare punti e set a zero', () => {
+            state.sp.punt.home = 10
+            state.sp.punt.guest = 8
+            state.sp.set.home = 1
+            state.sp.set.guest = 1
+            const s = applyAction(state, { type: 'resetta' })
+            expect(s.sp.punt.home).toBe(0)
+            expect(s.sp.punt.guest).toBe(0)
+            expect(s.sp.set.home).toBe(0)
+            expect(s.sp.set.guest).toBe(0)
+        })
+
+        it('dovrebbe resettare formazioni a default', () => {
+            state.sp.form.home = ["10", "11", "12", "13", "14", "15"]
+            const s = applyAction(state, { type: 'resetta' })
+            expect(s.sp.form.home).toEqual(["1", "2", "3", "4", "5", "6"])
+            expect(s.sp.form.guest).toEqual(["1", "2", "3", "4", "5", "6"])
+        })
+
+        it('dovrebbe resettare la striscia a un set vuoto', () => {
+            state.sp.striscia = [{ serv: 'home', r: ['home', 'guest', 'home'] }, { serv: 'home', r: ['guest'] }]
+            const s = applyAction(state, { type: 'resetta' })
+            expect(s.sp.striscia).toHaveLength(1)
+            expect(s.sp.striscia[0].r).toEqual([])
+        })
+
+        it('dovrebbe impostare visuForm a false', () => {
+            state.visuForm = true
+            const s = applyAction(state, { type: 'resetta' })
+            expect(s.visuForm).toBe(false)
+        })
+
+        it('dovrebbe mantenere nomi e modalità', () => {
+            state.sp.nomi.home = "Squadra A"
+            state.modalitaPartita = "2/3"
+            const s = applyAction(state, { type: 'resetta' })
+            expect(s.sp.nomi.home).toBe("Squadra A")
+            expect(s.modalitaPartita).toBe("2/3")
+        })
+    })
+
+    // =============================================
+    // AZIONE SCONOSCIUTA
+    // =============================================
+    describe('Azione sconosciuta', () => {
+        it('dovrebbe restituire lo stato invariato con azione non riconosciuta', () => {
+            const s = applyAction(state, { type: 'azioneInesistente' })
+            expect(s.sp.punt.home).toBe(0)
+            expect(s.sp.punt.guest).toBe(0)
+        })
+    })
+})

tests/unit/server-utils.test.js

@@ -0,0 +1,148 @@
+import { describe, it, expect, vi, afterEach } from 'vitest'
+import * as os from 'os'
+
+vi.mock('os', async (importOriginal) => {
+    return {
+        ...await importOriginal(),
+        networkInterfaces: vi.fn(() => ({}))
+    }
+})
+
+import { getNetworkIPs, printServerInfo } from '../../src/server-utils.js'
+
+describe('Server Utils', () => {
+
+    afterEach(() => {
+        vi.restoreAllMocks()
+    })
+
+    // =============================================
+    // getNetworkIPs
+    // =============================================
+    describe('getNetworkIPs', () => {
+        it('dovrebbe restituire indirizzi IPv4 non-loopback', () => {
+            os.networkInterfaces.mockReturnValue({
+                eth0: [
+                    { family: 'IPv4', internal: false, address: '192.168.1.100' }
+                ]
+            })
+            expect(getNetworkIPs()).toEqual(['192.168.1.100'])
+        })
+
+        it('dovrebbe escludere indirizzi loopback (internal)', () => {
+            os.networkInterfaces.mockReturnValue({
+                lo: [
+                    { family: 'IPv4', internal: true, address: '127.0.0.1' }
+                ],
+                eth0: [
+                    { family: 'IPv4', internal: false, address: '192.168.1.100' }
+                ]
+            })
+            const ips = getNetworkIPs()
+            expect(ips).not.toContain('127.0.0.1')
+            expect(ips).toContain('192.168.1.100')
+        })
+
+        it('dovrebbe escludere indirizzi IPv6', () => {
+            os.networkInterfaces.mockReturnValue({
+                eth0: [
+                    { family: 'IPv6', internal: false, address: 'fe80::1' },
+                    { family: 'IPv4', internal: false, address: '192.168.1.100' }
+                ]
+            })
+            const ips = getNetworkIPs()
+            expect(ips).toEqual(['192.168.1.100'])
+        })
+
+        it('dovrebbe escludere bridge Docker 172.17.x.x', () => {
+            os.networkInterfaces.mockReturnValue({
+                docker0: [
+                    { family: 'IPv4', internal: false, address: '172.17.0.1' }
+                ],
+                eth0: [
+                    { family: 'IPv4', internal: false, address: '10.0.0.5' }
+                ]
+            })
+            const ips = getNetworkIPs()
+            expect(ips).not.toContain('172.17.0.1')
+            expect(ips).toContain('10.0.0.5')
+        })
+
+        it('dovrebbe escludere bridge Docker 172.18.x.x', () => {
+            os.networkInterfaces.mockReturnValue({
+                br0: [
+                    { family: 'IPv4', internal: false, address: '172.18.0.1' }
+                ]
+            })
+            expect(getNetworkIPs()).toEqual([])
+        })
+
+        it('dovrebbe restituire array vuoto se nessuna interfaccia disponibile', () => {
+            os.networkInterfaces.mockReturnValue({})
+            expect(getNetworkIPs()).toEqual([])
+        })
+
+        it('dovrebbe restituire più indirizzi da interfacce diverse', () => {
+            os.networkInterfaces.mockReturnValue({
+                eth0: [
+                    { family: 'IPv4', internal: false, address: '192.168.1.100' }
+                ],
+                wlan0: [
+                    { family: 'IPv4', internal: false, address: '192.168.1.101' }
+                ]
+            })
+            const ips = getNetworkIPs()
+            expect(ips).toHaveLength(2)
+            expect(ips).toContain('192.168.1.100')
+            expect(ips).toContain('192.168.1.101')
+        })
+    })
+
+    // =============================================
+    // printServerInfo
+    // =============================================
+    describe('printServerInfo', () => {
+        it('dovrebbe stampare la porta di default (3000)', () => {
+            os.networkInterfaces.mockReturnValue({})
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+            printServerInfo()
+            const allLogs = consoleSpy.mock.calls.map(c => c[0]).join('\n')
+            expect(allLogs).toContain('3000')
+            expect(allLogs).toContain('/display')
+            expect(allLogs).toContain('/controller')
+            consoleSpy.mockRestore()
+        })
+
+        it('dovrebbe stampare la porta personalizzata', () => {
+            os.networkInterfaces.mockReturnValue({})
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+            printServerInfo(8080)
+            const allLogs = consoleSpy.mock.calls.map(c => c[0]).join('\n')
+            expect(allLogs).toContain('8080')
+            consoleSpy.mockRestore()
+        })
+
+        it('dovrebbe mostrare gli URL remoti se ci sono IP di rete', () => {
+            os.networkInterfaces.mockReturnValue({
+                eth0: [
+                    { family: 'IPv4', internal: false, address: '192.168.1.50' }
+                ]
+            })
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+            printServerInfo(3000)
+            const allLogs = consoleSpy.mock.calls.map(c => c[0]).join('\n')
+            expect(allLogs).toContain('192.168.1.50')
+            expect(allLogs).toContain('remoti')
+            consoleSpy.mockRestore()
+        })
+
+        it('non dovrebbe mostrare sezione remoti se nessun IP di rete', () => {
+            os.networkInterfaces.mockReturnValue({})
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+            printServerInfo(3000)
+            const allLogs = consoleSpy.mock.calls.map(c => c[0]).join('\n')
+            expect(allLogs).not.toContain('remoti')
+            consoleSpy.mockRestore()
+        })
+    })
+})

vite-plugin-websocket.js

@@ -0,0 +1,35 @@
+import { WebSocketServer } from 'ws'
+import { setupWebSocketHandler } from './src/websocket-handler.js'
+import { printServerInfo } from './src/server-utils.js'
+import { loadState, saveState } from './src/persist.js'
+
+export default function websocketPlugin() {
+  return {
+    name: 'vite-plugin-websocket',
+    configureServer(server) {
+      const wss = new WebSocketServer({ noServer: true })
+      setupWebSocketHandler(wss, { initialState: loadState(), onStateChange: saveState })
+
+      // Rewrite /display → / (index.html) e /controller → /controller.html
+      server.middlewares.use((req, _res, next) => {
+        if (req.url === '/display' || req.url === '/display/') req.url = '/'
+        else if (req.url === '/controller' || req.url === '/controller/') req.url = '/controller.html'
+        next()
+      })
+
+      server.httpServer.on('upgrade', (request, socket, head) => {
+        const pathname = new URL(request.url, `http://${request.headers.host}`).pathname
+        if (pathname === '/ws') {
+          wss.handleUpgrade(request, socket, head, (ws) => {
+            wss.emit('connection', ws, request)
+          })
+        }
+      })
+
+      server.httpServer.once('listening', () => {
+        const { port } = server.httpServer.address()
+        setTimeout(() => printServerInfo(port), 100)
+      })
+    }
+  }
+}

vite.config.js

@@ -1,12 +1,26 @@
 import { defineConfig } from 'vite'
+import { resolve, dirname } from 'path'
+import { fileURLToPath } from 'url'
 import vue from '@vitejs/plugin-vue'
 import { VitePWA } from 'vite-plugin-pwa'
+import websocketPlugin from './vite-plugin-websocket.js'
 
-// https://vitejs.dev/config/
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+// Configurazione principale di Vite
 export default defineConfig({
-  base: process.env.NODE_ENV === 'production' ? '/segnap' : '/',
+  base: '/',
+  build: {
+    rollupOptions: {
+      input: {
+        main: resolve(__dirname, 'index.html'),
+        controller: resolve(__dirname, 'controller.html'),
+      },
+    },
+  },
   plugins: [
     vue(),
+    websocketPlugin(),
     VitePWA({
       registerType: 'autoUpdate',
       manifest: {
@@ -32,4 +46,8 @@ export default defineConfig({
       }
     })
   ],
+  server: {
+    host: '0.0.0.0',
+    port: 5173,
+  },
 })

vitest.config.js

@@ -0,0 +1,19 @@
+import { defineConfig } from 'vitest/config'
+import vue from '@vitejs/plugin-vue'
+
+export default defineConfig({
+    plugins: [vue()],
+    test: {
+        include: [
+            'tests/unit/**/*.{test,spec}.js',
+            'tests/integration/**/*.{test,spec}.js',
+            'tests/component/**/*.{test,spec}.js',
+            'tests/stress/**/*.{test,spec}.js',
+        ],
+        globals: true,
+        environment: 'node',
+        environmentMatchGlobs: [
+            ['tests/component/**', 'happy-dom'],
+        ],
+    },
+})