@noeva/analytics-core 0.0.0-stage → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,53 @@
+# @noeva/analytics-core — registro delle modifiche
+
+Le versioni del pacchetto che i repository dei progetti installano (ADR 0005). Prima di
+`analytics upgrade` si legge cosa cambia fra la versione installata e la nuova.
+
+## 0.3.0 — 6 novembre 2026
+
+Il repository del progetto basta a se stesso (ADR 0005): pubblica pagine e modello e
+rilascia i due eseguibili Windows senza il monorepo.
+
+- `analytics pubblica` e `analytics modello` chiedono il biglietto all'API NOEVA con la
+  chiave di un membro del workspace (`NOEVA_API_KEY` o `~/.noeva-api-key`) quando il
+  segreto del contenitore non c'e'. Serve l'API con il campo `tipo` del biglietto
+  (noeva-server-api, `POST /api/analytics/biglietto-dati`).
+- `.github/workflows/ci.yml` (gestito): il job `pubblica` porta online pagine e modello a
+  ogni push su `main` che passa la verifica. Si accende con il secret `NOEVA_API_KEY` e
+  la variabile `ANALYTICS_PUBBLICA=si`.
+- `.github/workflows/rilascio-windows.yml` (gestito): la cartella MCP per i PC e
+  l'eseguibile degli snapshot, costruiti e provati su Windows, e le release nel repository
+  del progetto. Le ricette sono nel pacchetto (`contenuto/lib/mcp-locale`,
+  `contenuto/lib/snapshot`) e leggono `consegna.yml`, che ora e' la configurazione di
+  consegna intera: cliente, connessione senza password, verifiche, trasformazioni.
+- La pubblicazione dei dati (`aggiorna.sh --pubblica`) trova il workspace in
+  `analytics.json`: fuori dal monorepo il registro non c'e'.
+- `.gitignore` del modello: `dist/`, dove escono le cartelle Windows.
+
+## 0.2.0 — 6 novembre 2026
+
+- `analytics pubblica --url <url>`: la `apps/` del commit (HEAD, non il disco) sul
+  contenitore, in R2, meno quello che `apps/.assetsignore` esclude (ADR 0005, punto 3).
+  `--prova` elenca soltanto. In prova il biglietto si firma col segreto del contenitore
+  (`SEGRETO_DATI` o `~/.segreto-dati`); quello rilasciato dall'API NOEVA alla CI non c'e'
+  ancora.
+- `analytics modello --url <url>`: il modello del commit (wren_project.yml, relationships.yml,
+  models/, knowledge/), con le trasformazioni di `consegna.yml`, compilato come `wren context
+  build` e pubblicato su R2 per il servizio locale (ADR 0005, punto 6). Vuole python3 con
+  pyyaml e wrenai (il contenitore di sviluppo li ha); `--prova` compila soltanto.
+- `analytics.json` accetta `workspace`: il workspace NOEVA che possiede il progetto, che il
+  biglietto nomina.
+
+## 0.1.0 — 6 novembre 2026
+
+Prima versione, per la prima prova dell'ADR 0005.
+
+- `analytics init`, `ci`, `upgrade [--check]`, `agent sync`, `percorso`.
+- File gestiti: i moduli di pagina in `apps/assets/` (da `lib/pagina` e `snapshot.js`),
+  `.github/workflows/ci.yml`, la skill `progetto` in `.claude/skills/noeva-analytics-progetto/`
+  e il blocco NOEVA Analytics di `AGENTS.md`.
+- `analytics ci`: struttura dello standard (§2), `.assetsignore`, `controlli` di
+  `snapshot.yml`, file gestiti, nessun dato o credenziale in git, nessun riferimento
+  fuori dal prefisso del progetto.
+- Gli strumenti dello snapshot (`contenuto/lib/`) per `aggiorna.sh`, e il Dockerfile del
+  contenitore di sviluppo (`modello/contenitore/`).

package/README.md

@@ -1,3 +1,24 @@
-# Temporary Holding Version
+# @noeva/analytics-core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Il pacchetto che il repository di ogni progetto installa (ADR 0005): la CLI `analytics`,
+i moduli di pagina, gli strumenti dello snapshot, il kit dell'agente e il modello del
+repository. La forma e' quella di `@noeva/etl-core` (noeva-etl, ADR-0093 e 0094).
+
+La fonte resta `lib/`: `prepara.js` ne copia in `contenuto/` (gitignorata) i file che il
+pacchetto porta, a ogni `npm pack` e a ogni prova. Questo README non va nel pacchetto.
+
+```bash
+node lib/core/prepara.js && node --test lib/core/test/*.test.js   # le prove, anche in CI
+cd lib/core && npm pack --dry-run                                  # cosa pubblicherebbe
+python3 lib/rilascio/estrai-progetto.py <id> <cartella vuota>      # un progetto nel suo repository
+```
+
+- **Il pacchetto non nomina clienti**: `test/nomi.test.js` lo prova contro il registro.
+  Un commento in `lib/pagina` o `lib/snapshot` che cita un cliente arriva a tutti.
+- **La CI del repository nuovo puo' non partire**: con OIKI (6/11/2026) GitHub ha registrato
+  `ci.yml`, arrivato col push che crea il repository, ma non partiva su push e PR, solo a mano.
+  Si e' sbloccato al primo push di un commit che cambiava `ci.yml`, anche su un branch di
+  prova poi cancellato. Dopo il primo push si controlla che la PR abbia il check `verifica`.
+- **Una versione nuova** si scrive in `package.json` e in `CHANGELOG.md`, che i progetti
+  leggono prima di aggiornare. Pubblicare su npm lo fa Stefano Denti, come i rilasci
+  (`AGENTS.md`, «Chi rilascia»).

package/cli.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+// La CLI del pacchetto @noeva/analytics-core, nel repository di un progetto:
+//
+//   analytics init <id> [cartella]   il repository di un progetto nuovo, da una cartella vuota
+//   analytics ci                     la verifica dello standard (la stessa della CI)
+//   analytics upgrade --check        la versione installata, l'ultima, i file gestiti cambiati
+//   analytics upgrade                aggiorna il pacchetto e riscrive i file gestiti
+//   analytics agent sync             riscrive solo il kit dell'agente
+//   analytics pubblica --url <url>   la apps/ di HEAD sul contenitore, in R2 (--prova: elenca soltanto)
+//   analytics modello --url <url>    il modello di HEAD, compilato, sul contenitore in R2 (python3, wren)
+//   analytics percorso               dove sta il contenuto del pacchetto (per aggiorna.sh)
+//   analytics versione
+//
+// Le funzioni stanno in core.js; qui solo argomenti, stampa e codice d'uscita.
+
+import { execFileSync } from 'node:child_process';
+import { join, resolve } from 'node:path';
+import {
+  ErroreConfig, PACCHETTO, VERSIONE, derive, init, leggiConfig, scriviGestiti, trovaRadice,
+  piuNuova, ultimaVersione, verifica,
+} from './core.js';
+import { pubblica } from './pubblica.js';
+
+const verde = (s) => `\x1b[0;32m${s}\x1b[0m`;
+const rosso = (s) => `\x1b[0;31m${s}\x1b[0m`;
+const giallo = (s) => `\x1b[0;33m${s}\x1b[0m`;
+
+function elenca(titolo, voci) {
+  if (!voci.length) return;
+  console.log(titolo);
+  for (const v of voci) console.log(`  ${v}`);
+}
+
+async function principale(argv) {
+  const [comando, ...resto] = argv;
+  switch (comando) {
+    case 'init': {
+      const [id, cartella = '.'] = resto;
+      const scritti = init(resolve(cartella), id);
+      console.log(verde(`noeva-analytics-${id} creato in ${resolve(cartella)} (@noeva/analytics-core ${VERSIONE}, ${scritti.length} file gestiti)`));
+      console.log('Poi: npm install, la cartella del progetto, npx analytics ci.');
+      return 0;
+    }
+    case 'ci': {
+      const radice = trovaRadice();
+      const config = leggiConfig(radice);
+      const { errori, avvisi } = verifica(radice, config);
+      console.log(`analytics ci — ${config.progetto}, @noeva/analytics-core ${VERSIONE}`);
+      elenca(giallo('avvisi'), avvisi);
+      elenca(rosso('errori'), errori);
+      const ultima = await ultimaVersione();
+      if (piuNuova(ultima, VERSIONE)) console.log(giallo(`c'e' la versione ${ultima}: npx analytics upgrade --check`));
+      console.log(errori.length ? rosso(`KO: ${errori.length} errori`) : verde('ok'));
+      return errori.length ? 1 : 0;
+    }
+    case 'upgrade': {
+      const radice = trovaRadice();
+      const config = leggiConfig(radice);
+      if (resto.includes('--check')) {
+        const ultima = await ultimaVersione();
+        console.log(`installata ${VERSIONE}, ultima ${ultima ?? 'non raggiungibile o non pubblicata'}`);
+        if (piuNuova(ultima, VERSIONE)) console.log(`il registro delle modifiche: npm view @noeva/analytics-core@${ultima} — leggerlo prima di aggiornare`);
+        const d = derive(radice, config);
+        elenca(giallo('file gestiti diversi dal pacchetto installato'), d.map((x) => `${x.stato}: ${x.percorso}`));
+        if (!d.length) console.log(verde('file gestiti allineati'));
+        return 0;
+      }
+      if (!resto.includes('--solo-file')) {
+        // Il pacchetto nuovo, poi la sua CLI scrive i file: questa e' ancora la
+        // versione vecchia, e scriverebbe i file di prima.
+        execFileSync('npm', ['install', '--save-dev', '@noeva/analytics-core@latest'], { cwd: radice, stdio: 'inherit' });
+        execFileSync(process.execPath, [join(radice, 'node_modules', '@noeva', 'analytics-core', 'cli.js'), 'upgrade', '--solo-file'], { cwd: radice, stdio: 'inherit' });
+        return 0;
+      }
+      elenca(`riscritti alla versione ${VERSIONE}`, scriviGestiti(radice, config));
+      console.log(verde('file gestiti allineati'));
+      return 0;
+    }
+    case 'agent': {
+      if (resto[0] !== 'sync') break;
+      const radice = trovaRadice();
+      elenca('kit dell\'agente riscritto', scriviGestiti(radice, leggiConfig(radice), { soloKit: true }));
+      console.log(verde('kit allineato'));
+      return 0;
+    }
+    case 'pubblica': {
+      const radice = trovaRadice();
+      const config = leggiConfig(radice);
+      const valore = (nome) => { const i = resto.indexOf(nome); return i >= 0 ? resto[i + 1] : undefined; };
+      const prova = resto.includes('--prova');
+      const esito = await pubblica(radice, config, {
+        url: valore('--url') ?? process.env.NOEVA_ANALYTICS_URL,
+        workspace: valore('--workspace') ?? config.workspace,
+        prova,
+        stampa: console.log,
+      });
+      const quanto = `${esito.file} file, ${Math.round(esito.byte / 1024)} kB`;
+      console.log(prova ? `versione ${esito.versione}: ${quanto} (prova, niente caricato)` : verde(`pubblicata ${esito.versione}: ${quanto}`));
+      return 0;
+    }
+    case 'modello': {
+      // Compilare il modello e' di wren, che e' Python: lo fa lib/modello/pubblica.py
+      // del pacchetto, con il python3 dell'ambiente (il contenitore di sviluppo, la CI).
+      const radice = trovaRadice();
+      const script = join(PACCHETTO, 'contenuto', 'lib', 'modello', 'pubblica.py');
+      try {
+        execFileSync(process.env.PYTHON || 'python3', [script, radice, ...resto], { stdio: 'inherit' });
+      } catch (e) {
+        return e.status ?? 1;
+      }
+      return 0;
+    }
+    case 'percorso':
+      console.log(join(PACCHETTO, 'contenuto'));
+      return 0;
+    case 'versione':
+    case '--version':
+      console.log(VERSIONE);
+      return 0;
+    default:
+  }
+  console.error('uso: analytics init <id> [cartella] | ci | upgrade [--check] | agent sync | pubblica --url <url> [--prova] | modello --url <url> [--prova] | percorso | versione');
+  return 2;
+}
+
+try {
+  process.exitCode = await principale(process.argv.slice(2));
+} catch (e) {
+  if (!(e instanceof ErroreConfig)) throw e;
+  console.error(rosso(e.message));
+  process.exitCode = 2;
+}

package/contenuto/assets/accessibile.js

@@ -0,0 +1,101 @@
+// Modulo condiviso delle dashboard NOEVA Analytics. La sorgente e' lib/pagina/accessibile.js;
+// la copia in apps/assets/ la scrive lib/snapshot/installa.sh --pagina. Non modificare la copia.
+/* Accessibilita' comune a tutte le dashboard (WCAG 2.2 AA).
+ *
+ *   rendiAccessibile();   // una volta, all'avvio della pagina
+ *
+ * Le pagine si ridisegnano a ogni filtro: qui un osservatore rimette a posto
+ * dopo ogni ridisegno quello che il disegno non fa da se'.
+ *
+ *  - "Vai ai contenuti": il primo Tab salta barra e filtri (2.4.1).
+ *  - La barra in alto e' il banner della pagina, e se la pagina passa da h1 a
+ *    h3 c'e' un h2 per i lettori di schermo (1.3.1).
+ *  - Le intestazioni ordinabili si raggiungono con Tab e si attivano con Invio
+ *    o Spazio, come il clic (2.1.1).
+ *  - Ogni altra tabella si ordina cliccando l'intestazione (ordina.js), con
+ *    aria-sort e la tastiera; l'ordine scelto resta dopo un ridisegno.
+ *  - Ogni grafico ha i suoi numeri anche in tabella: i valori che il grafico
+ *    mostra solo al passaggio del mouse (data-et, data-v sulle colonne) si
+ *    leggono in "I numeri del grafico", da tastiera e con il lettore (1.1.1).
+ */
+
+import { t, LOCALE } from "./lingua.js";
+import { montaOrdinamento } from "./ordina.js";
+
+export function rendiAccessibile() {
+  const main = document.querySelector("main");
+  if (main && !main.id) main.id = "contenuto";
+  if (main && !document.querySelector(".salta")) {
+    const a = document.createElement("a");
+    a.className = "salta"; a.href = `#${main.id}`; a.textContent = t("Vai ai contenuti");
+    a.onclick = (e) => {
+      e.preventDefault();
+      const dove = document.querySelector("#pagina:not([hidden])") || main;
+      dove.setAttribute("tabindex", "-1"); dove.focus();
+    };
+    document.body.prepend(a);
+  }
+  const barra = document.querySelector(".topbar");
+  if (barra && !barra.getAttribute("role")) barra.setAttribute("role", "banner");
+
+  const pagina = document.getElementById("pagina");
+  if (pagina && !pagina.querySelector("h2") && pagina.querySelector("h3")) {
+    const h2 = document.createElement("h2");
+    h2.className = "sr-only";
+    h2.textContent = t("{titolo}: indicatori e dettagli", { titolo: (document.querySelector(".topbar h1")?.textContent || "Dashboard").replace(/^[\s·]+/, "") });
+    pagina.prepend(h2);
+  }
+
+  let inCorso = false;
+  const ordinaTabelle = montaOrdinamento({ t, locale: LOCALE });
+  const sistema = () => {
+    if (inCorso) return;
+    inCorso = true;
+    try { intestazioni(); numeriDeiGrafici(); ordinaTabelle(); } finally { inCorso = false; }
+  };
+  sistema();
+  new MutationObserver(() => queueMicrotask(sistema)).observe(document.body, { childList: true, subtree: true });
+}
+
+function intestazioni() {
+  for (const th of document.querySelectorAll("th[data-col]")) {
+    if (th.dataset.tastiera) continue;
+    th.dataset.tastiera = "si";
+    th.tabIndex = 0;
+    th.setAttribute("title", t("Ordina per questa colonna"));
+    th.addEventListener("keydown", (e) => {
+      if (e.key !== "Enter" && e.key !== " ") return;
+      e.preventDefault();
+      const col = th.dataset.col, tab = th.closest("table");
+      th.click();
+      // la tabella si ridisegna: il fuoco torna sulla stessa colonna
+      requestAnimationFrame(() => tab?.querySelector(`th[data-col="${CSS.escape(col)}"]`)?.focus());
+    });
+  }
+}
+
+const esc = (s) => String(s ?? "").replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[c]));
+
+function numeriDeiGrafici() {
+  for (const svg of document.querySelectorAll("svg.grafico")) {
+    const colonne = [...svg.querySelectorAll(".hit[data-et][data-v]")];
+    const riquadro = svg.closest(".card");
+    if (!colonne.length || !riquadro) continue;
+    let det = riquadro.querySelector("details.numeri-auto");
+    // un grafico che ha gia' la sua tabella dei numeri non ne vuole una seconda
+    if (!det && riquadro.querySelector("details.numeri, details table")) continue;
+    const html = `<thead><tr><th>${t("Voce")}</th><th>${t("Valori")}</th></tr></thead><tbody>${colonne.map((h) =>
+      `<tr><td>${esc(h.dataset.et)}</td><td style="text-align:left;white-space:normal">${esc(h.dataset.v)}</td></tr>`).join("")}</tbody>`;
+    if (!det) {
+      det = document.createElement("details");
+      det.className = "numeri numeri-auto";
+      det.style.marginTop = "10px";
+      det.innerHTML = `<summary style="cursor:pointer;font-size:12px;color:var(--ink-3)">${t("I numeri del grafico")}</summary>
+        <div class="tabella-wrap"><table></table></div>`;
+      svg.after(det);
+    }
+    // confronto con l'ultima versione scritta, non con innerHTML: il browser la
+    // riscrive a modo suo, e l'osservatore girerebbe all'infinito
+    if (det._ultimo !== html) { det._ultimo = html; det.querySelector("table").innerHTML = html; }
+  }
+}

package/contenuto/assets/agenti.js

@@ -0,0 +1,110 @@
+// Modulo condiviso delle dashboard NOEVA Analytics. La sorgente e' lib/pagina/agenti.js;
+// la copia in apps/assets/ la scrive lib/snapshot/installa.sh --pagina. Non modificare la copia.
+/* La chat su NOEVA Agents (ADR 0006, in prova): agents UI in un iframe dentro il
+ * pannello della chat, che conserva le sue quattro viste.
+ *
+ *   const a = await agentiDisponibili();   // null, o { agenti, token, ... }
+ *   if (a) montaAgenti(contenitore, { pagina, accesso: a });
+ *
+ * Il Worker custodisce i token NOEVA dell'utente e da' alla pagina solo
+ * l'access token, da ai/token, con l'indirizzo di agents UI (AGENTI_URL). La
+ * pagina lo passa all'iframe con INIT e, prima che scada, con AUTH_REFRESH: lo
+ * stesso protocollo del client NOEVA. Progetto, pagina, lingua e lo stato della
+ * pagina (contesto() del commento) viaggiano in customMetadata, aggiornato con
+ * UPDATE_METADATA quando i filtri cambiano. I messaggi vanno solo all'origine
+ * di agents UI, e se ne ascoltano solo da li'.
+ */
+import { contesto } from "./commento.js";
+import { rotta } from "./servizio.js";
+import { t, LINGUA } from "./lingua.js";
+import { PROGETTO } from "./progetto.js";
+
+const AGENTE = "analyticsChatAgent";
+// Il token si chiede di nuovo un minuto prima del margine del Worker (5 minuti):
+// arriva gia' rinnovato.
+const ANTICIPO_MS = 6 * 60 * 1000;
+
+let _accesso = null;
+/** L'accesso ad agents UI, o null se il contenitore non lo offre (niente SESSIONI o AGENTI_URL). */
+export function agentiDisponibili() {
+  _accesso ||= chiediToken().catch(() => null);
+  return _accesso;
+}
+
+async function chiediToken() {
+  const r = await fetch(rotta("ai/token"), { cache: "no-store" });
+  if (!r.ok) return null;
+  const j = await r.json();
+  return j?.token && j?.agenti ? j : null;
+}
+
+const tema = () => {
+  try { return { light: "light", dark: "dark" }[localStorage.getItem("noeva-tema")] || "system"; } catch { return "system"; }
+};
+
+export function montaAgenti(contenitore, { pagina, accesso, suggerimenti = [] }) {
+  const origine = new URL(accesso.agenti).origin;
+  const f = document.createElement("iframe");
+  f.src = accesso.agenti;
+  f.title = t("Chat sulla pagina");
+  f.className = "ch-agenti";
+  f.setAttribute("allow", "microphone; clipboard-write");
+  f.style.cssText = "flex: 1; width: 100%; border: 0; background: transparent;";
+  contenitore.append(f);
+
+  const manda = (messaggio) => f.contentWindow?.postMessage(messaggio, origine);
+  const metadata = () => ({ progetto: PROGETTO.id, pagina, lingua: LINGUA, contesto: contesto() });
+  let pronto = false, rinnovo = null;
+
+  function programmaRinnovo(scade) {
+    clearTimeout(rinnovo);
+    rinnovo = setTimeout(async () => {
+      const nuovo = await chiediToken().catch(() => null);
+      if (!nuovo) { location.reload(); return; }           // sessione finita: il cancello porta al login
+      manda({ type: "AUTH_REFRESH", payload: { authToken: nuovo.token } });
+      programmaRinnovo(nuovo.scade);
+    }, Math.max(30_000, scade - Date.now() - ANTICIPO_MS));
+  }
+
+  addEventListener("message", (e) => {
+    if (e.origin !== origine || e.source !== f.contentWindow) return;
+    if (e.data?.type !== "READY" || pronto) return;
+    pronto = true;
+    manda({
+      type: "INIT",
+      payload: {
+        userId: accesso.utente,
+        workspaceId: accesso.workspace,
+        authToken: accesso.token,
+        agentId: AGENTE,
+        initialState: { agentId: AGENTE, viewChat: true },
+        // lo storico e' per progetto: chi segue due progetti ne ha due (ADR 0006)
+        threadsResource: `analytics:${PROGETTO.id}`,
+        theme: tema(),
+        language: LINGUA === "en" ? "en" : "it",
+        customChatTitle: PROGETTO.agenti?.titolo || t("Domande sulla pagina"),
+        ...(PROGETTO.agenti?.avatar ? { titleAvatar: PROGETTO.agenti.avatar } : {}),
+        welcomeMessage: t("Chiedi quello che la pagina non dice: rispondo dai numeri che vedi e, se serve, interrogo il modello dei dati con i filtri scelti."),
+        welcomeMessageQuickActions: suggerimenti.map((s) => ({ label: s, message: s })),
+        hideChatSettings: true,
+        showTokenUsage: true,
+        showSpinner: true,
+        disableAttachments: true,
+        customMetadata: metadata(),
+      },
+    });
+    programmaRinnovo(accesso.scade);
+  });
+
+  // I filtri cambiano: lo stato della pagina nuovo va al prossimo turno.
+  let attesa = null;
+  const aggiorna = () => {
+    if (!pronto) return;
+    clearTimeout(attesa);
+    attesa = setTimeout(() => manda({ type: "UPDATE_METADATA", payload: metadata() }), 400);
+  };
+  document.addEventListener("change", aggiorna, true);
+  document.addEventListener("click", (e) => { if (!contenitore.contains(e.target)) aggiorna(); }, true);
+  addEventListener("popstate", aggiorna);
+  return { aggiorna };
+}

package/contenuto/assets/animazione.js

@@ -0,0 +1,156 @@
+// Modulo condiviso delle dashboard NOEVA Analytics. La sorgente e' lib/pagina/animazione.js;
+// la copia in apps/assets/ la scrive lib/snapshot/installa.sh --pagina. Non modificare la copia.
+/* La regia delle slide quando si presentano dall'app (Presenta in presentazione.js).
+ *
+ *   const a = animaSlide(box, tipo);   // parte subito
+ *   a.finisci();                       // un tasto durante la regia: tutto al posto finale
+ *   a.finita                           // true quando la regia e' conclusa
+ *
+ * Web Animations API, niente librerie: funziona anche senza rete. La regia e'
+ * fatta per far leggere, non per stupire: ogni cosa entra nell'ordine in cui si
+ * legge, i numeri grandi contano fino al valore, le barre crescono dal basso, le
+ * linee si disegnano, le righe di una tabella arrivano una alla volta e quella di
+ * cui si parla si accende per ultima. Tutto in meno di tre secondi.
+ *
+ * Con `prefers-reduced-motion` non si muove niente: la slide appare pronta.
+ */
+
+import { LOCALE, SEPARATORI } from "./lingua.js";
+
+const FUORI = "cubic-bezier(.22,.61,.36,1)";     // ease-out: parte deciso, arriva piano
+const fermo = () => matchMedia("(prefers-reduced-motion: reduce)").matches;
+
+/* Un numero scritto come lo scrive la pagina ("57,7 mln€", "−4,1%", "2.468", "52 mila";
+ * in inglese "57.7m€", "2,468") conta da zero al suo valore, tenendo segno,
+ * decimali, separatori e quello che segue. */
+const escRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const RE_NUMERO = new RegExp(`^(\\s*)(−|-|\\+)?(\\d[\\d${escRe(SEPARATORI.migliaia)}]*)(${escRe(SEPARATORI.decimali)}\\d+)?([\\s\\S]*)$`);
+function contaFinoA(el, durata, ritardo, registro) {
+  const testo = el.textContent;
+  const m = testo.match(RE_NUMERO);
+  if (!m) return;
+  const [, pre, segno = "", intero, dec = "", resto] = m;
+  const decimali = dec ? dec.length - 1 : 0;
+  const valore = parseFloat(intero.split(SEPARATORI.migliaia).join("") + (dec ? "." + dec.slice(1) : ""));
+  if (!isFinite(valore) || valore === 0) return;
+  const scrivi = (v) => { el.textContent = pre + segno + v.toLocaleString(LOCALE, { minimumFractionDigits: decimali, maximumFractionDigits: decimali }) + resto; };
+  const t0 = performance.now() + ritardo;
+  let vivo = true;
+  scrivi(0);
+  const passo = (ora) => {
+    if (!vivo) return;
+    const x = Math.min(Math.max((ora - t0) / durata, 0), 1);
+    const e = 1 - Math.pow(1 - x, 3);
+    scrivi(Math.round(valore * e * 10 ** decimali) / 10 ** decimali);
+    if (x < 1) requestAnimationFrame(passo); else vivo = false;
+  };
+  requestAnimationFrame(passo);
+  registro.push({ finish: () => { vivo = false; scrivi(valore); }, get playState() { return vivo ? "running" : "finished"; } });
+}
+
+const entra = (el, { ritardo = 0, durata = 520, da = "translateY(18px)" } = {}, registro) => {
+  const a = el.animate([{ opacity: 0, transform: da }, { opacity: 1, transform: "none" }],
+    { duration: durata, delay: ritardo, easing: FUORI, fill: "backwards" });
+  registro.push(a);
+  return a;
+};
+
+const appare = (el, ritardo, registro, durata = 400) => {
+  registro.push(el.animate([{ opacity: 0 }, { opacity: 1 }], { duration: durata, delay: ritardo, easing: "ease-out", fill: "backwards" }));
+};
+
+/* Il grafico della dashboard, clonato nella slide: barre dal basso, linee disegnate, punti che spuntano. */
+function animaGrafico(svg, t0, registro) {
+  const barre = [...svg.querySelectorAll("rect")].filter((r) => !r.matches(".hit, .sel, .griglia rect"));
+  barre.forEach((r, i) => {
+    r.style.transformBox = "fill-box"; r.style.transformOrigin = "50% 100%";
+    registro.push(r.animate([{ transform: "scaleY(0.001)" }, { transform: "scaleY(1)" }],
+      { duration: 650, delay: t0 + Math.min(i, 40) * 18, easing: FUORI, fill: "backwards" }));
+  });
+  const linee = [...svg.querySelectorAll("path, polyline")].filter((p) => {
+    const cs = getComputedStyle(p); return cs.stroke !== "none" && cs.fill === "none";
+  });
+  const tLinee = t0 + 350;
+  linee.forEach((p, i) => {
+    const cs = getComputedStyle(p);
+    if (cs.strokeDasharray !== "none" || typeof p.getTotalLength !== "function") { appare(p, tLinee + i * 120, registro, 600); return; }
+    const L = p.getTotalLength();
+    p.style.strokeDasharray = `${L}`;
+    const a = p.animate([{ strokeDashoffset: L }, { strokeDashoffset: 0 }], { duration: 1100, delay: tLinee + i * 120, easing: FUORI, fill: "backwards" });
+    a.onfinish = () => { p.style.strokeDasharray = ""; };
+    registro.push(a);
+  });
+  // aree piene (es. sotto una linea) e punti
+  [...svg.querySelectorAll("path, polygon")].filter((p) => getComputedStyle(p).fill !== "none" && !linee.includes(p))
+    .forEach((p) => appare(p, t0 + 200, registro, 700));
+  [...svg.querySelectorAll("circle")].forEach((c, i) => {
+    c.style.transformBox = "fill-box"; c.style.transformOrigin = "center";
+    registro.push(c.animate([{ transform: "scale(0)", opacity: 0 }, { transform: "scale(1)", opacity: 1 }],
+      { duration: 300, delay: tLinee + 500 + Math.min(i, 30) * 40, easing: FUORI, fill: "backwards" }));
+  });
+  // le etichette degli assi arrivano con la griglia, subito e piano
+  [...svg.querySelectorAll("text")].forEach((t) => appare(t, t0, registro, 500));
+  const evid = svg.querySelector(".hit.evid");
+  if (evid) registro.push(evid.animate([{ opacity: 0 }, { opacity: 0.14 }, { opacity: 0.4 }, { opacity: 0.14 }],
+    { duration: 900, delay: t0 + 1300, easing: "ease-in-out", fill: "backwards" }));
+  return t0 + 1300;
+}
+
+/* La tabella: una riga alla volta, quella indicata si accende per ultima. */
+function animaTabella(tab, t0, registro) {
+  const righe = [...tab.querySelectorAll("tr")];
+  const passo = righe.length > 8 ? 35 : 50;
+  righe.forEach((tr, i) => entra(tr, { ritardo: t0 + i * passo, durata: 380, da: "translateY(6px)" }, registro));
+  const fine = t0 + righe.length * passo + 200;
+  const evid = tab.querySelector("tr.evid");
+  if (evid) registro.push(evid.animate([{ outline: "0 solid transparent" }, { outline: "3px solid var(--primary)", offset: .4 }, { outline: "3px solid transparent" }],
+    { duration: 900, delay: fine, easing: "ease-in-out", fill: "backwards" }));
+  // i punti partono mentre la riga si accende: la regia resta sotto i tre secondi
+  return fine + 150;
+}
+
+export function animaSlide(box, tipo) {
+  const registro = [];
+  const esito = {
+    registro,
+    get finita() { return registro.every((a) => a.playState === "finished"); },
+    finisci() { for (const a of registro) try { a.finish(); } catch { /* gia' finita */ } },
+  };
+  if (fermo()) return esito;
+  const $ = (s) => box.querySelector(s), $$ = (s) => [...box.querySelectorAll(s)];
+  const piede = $(".s-piede");
+  if (piede) appare(piede, 1200, registro, 500);
+
+  if (box.classList.contains("s-cover")) {
+    const logo = $(".s-logo"); if (logo) appare(logo, 0, registro);
+    const barra = $(".s-barra");
+    if (barra) { barra.style.transformOrigin = "0 50%"; registro.push(barra.animate([{ transform: "scaleX(0)" }, { transform: "scaleX(1)" }], { duration: 600, delay: 250, easing: FUORI, fill: "backwards" })); }
+    const h1 = $(".s-h1"); if (h1) entra(h1, { ritardo: 450, durata: 700, da: "translateY(28px)" }, registro);
+    const sotto = $(".s-sotto"); if (sotto) entra(sotto, { ritardo: 800 }, registro);
+    const meta = $(".s-cover-meta"); if (meta) entra(meta, { ritardo: 1050 }, registro);
+    return esito;
+  }
+
+  const titolo = $(".s-titolo"); if (titolo) entra(titolo, { ritardo: 0, durata: 600, da: "translateY(16px)" }, registro);
+  let t = 350;
+  if (tipo === "numeri") {
+    $$(".s-card").forEach((c, i) => { entra(c, { ritardo: t + i * 110, durata: 560, da: "translateY(22px)" }, registro);
+      const n = c.querySelector(".s-n"); if (n) contaFinoA(n, 1100, t + i * 110 + 150, registro); });
+    t += $$(".s-card").length * 110 + 900;
+  } else if (tipo === "riquadro") {
+    const vista = $(".s-vista"), eyebrow = $(".s-sx .s-eyebrow");
+    if (eyebrow) appare(eyebrow, t, registro);
+    if (vista) {
+      entra(vista, { ritardo: t, durata: 500, da: "translateY(12px)" }, registro);
+      const svg = vista.querySelector("svg"), tab = vista.querySelector("table");
+      t = svg ? animaGrafico(svg, t + 250, registro) : tab ? animaTabella(tab, t + 200, registro) : t + 500;
+    }
+    const barra = $(".s-barra-v"); if (barra) entra(barra, { ritardo: t - 300, durata: 400, da: "scaleY(0)" }, registro);
+    t -= 250;
+  } else {
+    const barra = $(".s-barra-v"); if (barra) entra(barra, { ritardo: t, durata: 400, da: "scaleY(0)" }, registro);
+    t += 150;
+  }
+  $$(".s-punti li").forEach((li, i) => entra(li, { ritardo: t + i * 140, durata: 480, da: "translateX(-14px)" }, registro));
+  return esito;
+}