emilsoftware-utilities 2.0.0-dev.23 → 2.0.0-dev.25

package/dist/accessi-module/Console/console.js

@@ -167,6 +167,33 @@ var assignPermissionsToUser = async (codiceUtente, assignPermissionsToUserReques
     }
   );
 };
+var getDeleteRoleUrl = (codiceRuolo) => {
+  return `/api/accessi/permission/delete-role/${codiceRuolo}`;
+};
+var deleteRole = async (codiceRuolo, options) => {
+  return accessiFetch(
+    getDeleteRoleUrl(codiceRuolo),
+    {
+      ...options,
+      method: "DELETE"
+    }
+  );
+};
+var getCreateMenuUrl = () => {
+  return `/api/accessi/permission/menus`;
+};
+var createMenu = async (createMenuRequest, options) => {
+  return accessiFetch(
+    getCreateMenuUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        createMenuRequest
+      )
+    }
+  );
+};
 var getGetGroupsWithMenusUrl = (params) => {
   const normalizedParams = new URLSearchParams();
   Object.entries(params || {}).forEach(([key, value]) => {
@@ -187,6 +214,129 @@ var getGroupsWithMenus = async (params, options) => {
     }
   );
 };
+var getGetMenuTypesUrl = () => {
+  return `/api/accessi/permission/menu-types`;
+};
+var getMenuTypes = async (options) => {
+  return accessiFetch(
+    getGetMenuTypesUrl(),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getCreateMenuTypeUrl = () => {
+  return `/api/accessi/permission/menu-types`;
+};
+var createMenuType = async (createMenuTypeRequest, options) => {
+  return accessiFetch(
+    getCreateMenuTypeUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        createMenuTypeRequest
+      )
+    }
+  );
+};
+var getUpdateMenuUrl = (codiceMenu) => {
+  return `/api/accessi/permission/menus/${codiceMenu}`;
+};
+var updateMenu = async (codiceMenu, updateMenuRequest, options) => {
+  return accessiFetch(
+    getUpdateMenuUrl(codiceMenu),
+    {
+      ...options,
+      method: "PUT",
+      body: JSON.stringify(
+        updateMenuRequest
+      )
+    }
+  );
+};
+var getDeleteMenuUrl = (codiceMenu) => {
+  return `/api/accessi/permission/menus/${codiceMenu}`;
+};
+var deleteMenu = async (codiceMenu, options) => {
+  return accessiFetch(
+    getDeleteMenuUrl(codiceMenu),
+    {
+      ...options,
+      method: "DELETE"
+    }
+  );
+};
+var getCreateMenuGroupUrl = () => {
+  return `/api/accessi/permission/menu-groups`;
+};
+var createMenuGroup = async (createMenuGroupRequest, options) => {
+  return accessiFetch(
+    getCreateMenuGroupUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        createMenuGroupRequest
+      )
+    }
+  );
+};
+var getUpdateMenuGroupUrl = (codiceGruppo) => {
+  return `/api/accessi/permission/menu-groups/${codiceGruppo}`;
+};
+var updateMenuGroup = async (codiceGruppo, updateMenuGroupRequest, options) => {
+  return accessiFetch(
+    getUpdateMenuGroupUrl(codiceGruppo),
+    {
+      ...options,
+      method: "PUT",
+      body: JSON.stringify(
+        updateMenuGroupRequest
+      )
+    }
+  );
+};
+var getDeleteMenuGroupUrl = (codiceGruppo) => {
+  return `/api/accessi/permission/menu-groups/${codiceGruppo}`;
+};
+var deleteMenuGroup = async (codiceGruppo, options) => {
+  return accessiFetch(
+    getDeleteMenuGroupUrl(codiceGruppo),
+    {
+      ...options,
+      method: "DELETE"
+    }
+  );
+};
+var getUpdateMenuTypeUrl = (codiceTipo) => {
+  return `/api/accessi/permission/menu-types/${codiceTipo}`;
+};
+var updateMenuType = async (codiceTipo, updateMenuTypeRequest, options) => {
+  return accessiFetch(
+    getUpdateMenuTypeUrl(codiceTipo),
+    {
+      ...options,
+      method: "PUT",
+      body: JSON.stringify(
+        updateMenuTypeRequest
+      )
+    }
+  );
+};
+var getDeleteMenuTypeUrl = (codiceTipo) => {
+  return `/api/accessi/permission/menu-types/${codiceTipo}`;
+};
+var deleteMenuType = async (codiceTipo, options) => {
+  return accessiFetch(
+    getDeleteMenuTypeUrl(codiceTipo),
+    {
+      ...options,
+      method: "DELETE"
+    }
+  );
+};
 var getGetUserRolesAndGrantsUrl = (codiceUtente) => {
   return `/api/accessi/permission/grants/${codiceUtente}`;
 };
@@ -231,6 +381,21 @@ var deleteUser = async (codiceUtente, options) => {
     }
   );
 };
+var getSetStatoRegistrazioneUrl = () => {
+  return `/api/accessi/user/set-stato`;
+};
+var setStatoRegistrazione = async (setStatoRegistrazioneDto, options) => {
+  return accessiFetch(
+    getSetStatoRegistrazioneUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        setStatoRegistrazioneDto
+      )
+    }
+  );
+};
 var getCreateManagedUserUrl = () => {
   return `/api/accessi/user/create-managed-user`;
 };
@@ -261,6 +426,60 @@ var updateUtente = async (codiceUtente, userDto, options) => {
     }
   );
 };
+var getGetTipiFiltroUrl = () => {
+  return `/api/accessi/filtri/tipi`;
+};
+var getTipiFiltro = async (options) => {
+  return accessiFetch(
+    getGetTipiFiltroUrl(),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getCreateTipoFiltroUrl = () => {
+  return `/api/accessi/filtri/tipi`;
+};
+var createTipoFiltro = async (createFilterTypeRequest, options) => {
+  return accessiFetch(
+    getCreateTipoFiltroUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        createFilterTypeRequest
+      )
+    }
+  );
+};
+var getUpdateTipoFiltroUrl = (tipFil) => {
+  return `/api/accessi/filtri/tipi/${tipFil}`;
+};
+var updateTipoFiltro = async (tipFil, updateFilterTypeRequest, options) => {
+  return accessiFetch(
+    getUpdateTipoFiltroUrl(tipFil),
+    {
+      ...options,
+      method: "PUT",
+      body: JSON.stringify(
+        updateFilterTypeRequest
+      )
+    }
+  );
+};
+var getDeleteTipoFiltroUrl = (tipFil) => {
+  return `/api/accessi/filtri/tipi/${tipFil}`;
+};
+var deleteTipoFiltro = async (tipFil, options) => {
+  return accessiFetch(
+    getDeleteTipoFiltroUrl(tipFil),
+    {
+      ...options,
+      method: "DELETE"
+    }
+  );
+};
 var getGetFiltriUtenteUrl = (params) => {
   const normalizedParams = new URLSearchParams();
   Object.entries(params || {}).forEach(([key, value]) => {
@@ -368,6 +587,18 @@ var updateFederatedProvider = async (provider, updateFederatedProviderRequest, o
     }
   );
 };
+var getDeleteFederatedProviderUrl = (provider) => {
+  return `/api/accessi/federated-auth/providers/${provider}`;
+};
+var deleteFederatedProvider = async (provider, options) => {
+  return accessiFetch(
+    getDeleteFederatedProviderUrl(provider),
+    {
+      ...options,
+      method: "DELETE"
+    }
+  );
+};
 var getGetFederatedIdentitiesUrl = (codiceUtente) => {
   return `/api/accessi/federated-auth/users/${codiceUtente}/identities`;
 };
@@ -437,22 +668,1187 @@ var deleteFederatedIdentityPermanently = async (codiceUtente, identityKey, optio
     }
   );
 };
+var getCreateServiceTokenUrl = () => {
+  return `/api/accessi/service-token`;
+};
+var createServiceToken = async (createServiceTokenRequest, options) => {
+  return accessiFetch(
+    getCreateServiceTokenUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        createServiceTokenRequest
+      )
+    }
+  );
+};
+var getGetServiceTokensUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value === null) {
+      normalizedParams.append(key, "null");
+    } else if (value !== void 0) {
+      normalizedParams.append(key, value.toString());
+    }
+  });
+  return `/api/accessi/service-token?${normalizedParams.toString()}`;
+};
+var getServiceTokens = async (params, options) => {
+  return accessiFetch(
+    getGetServiceTokensUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getRevokeServiceTokenUrl = (tokenId) => {
+  return `/api/accessi/service-token/${tokenId}`;
+};
+var revokeServiceToken = async (tokenId, options) => {
+  return accessiFetch(
+    getRevokeServiceTokenUrl(tokenId),
+    {
+      ...options,
+      method: "DELETE"
+    }
+  );
+};
+var getRotateServiceTokenUrl = (tokenId) => {
+  return `/api/accessi/service-token/${tokenId}/rotate`;
+};
+var rotateServiceToken = async (tokenId, options) => {
+  return accessiFetch(
+    getRotateServiceTokenUrl(tokenId),
+    {
+      ...options,
+      method: "POST"
+    }
+  );
+};
+
+// src/accessi-module/Console/wiki.ts
+var p = (text) => ({ kind: "p", text });
+var h = (text) => ({ kind: "h", text });
+var list = (items, ordered = false) => ({ kind: "list", items, ordered });
+var code = (language, codeText, title, variant) => ({ kind: "code", language, title, code: codeText, variant });
+var good = (language, codeText, title) => code(language, codeText, title, "good");
+var bad = (language, codeText, title) => code(language, codeText, title, "bad");
+var note = (tone, title, text) => ({ kind: "callout", tone, title, text });
+var table = (head, rows) => ({ kind: "table", head, rows });
+var WIKI_SECTIONS = [
+  // -------------------------------------------------------------------------
+  {
+    id: "panoramica",
+    group: "Per iniziare",
+    title: "Panoramica e architettura",
+    summary: "Che cosa fa Accessi, come si incastra nel backend e come scorre una richiesta.",
+    blocks: [
+      p(`Accessi \xE8 un modulo Node/NestJS che aggiunge a un backend gi\xE0 esistente: autenticazione JWT, autorizzazione per ruoli e menu, gestione utenti, reset password, codici email (2FA e passwordless), SSO generico, token macchina-a-macchina e una console amministrativa. Il database \xE8 Firebird/InterBase.`),
+      h(`Che cosa possiede il modulo`),
+      list([
+        `Le rotte sotto /api/accessi/* (login, utenti, ruoli, menu, filtri, SSO, token, console).`,
+        `Lo schema database del dominio Accessi, riconciliato automaticamente al bootstrap.`,
+        `Il middleware di autorizzazione authorizeAccessi per le rotte della tua applicazione.`,
+        `La console web su /api/accessi/console.`
+      ]),
+      h(`Che cosa resta alla tua applicazione`),
+      list([
+        `Il proprio frontend e le proprie rotte di business.`,
+        `La validazione dei token dei provider SSO esterni (Accessi non li vede).`,
+        `I segreti: jwtOptions.secret, SMTP, database ed encryptionKey non raggiungono mai il browser.`
+      ]),
+      h(`Flusso di una richiesta protetta`),
+      list([
+        `Il client chiama una rotta della tua app con header Authorization: Bearer <jwt>.`,
+        `La tua rotta esegue authorizeAccessi, che verifica firma HS256, scadenza e stato utente corrente.`,
+        `Se passi un requisito, il modulo carica ruoli e grant dell'utente e li valuta.`,
+        `Su successo req.user, req.data e (se richiesto) req.userGrants sono popolati; altrimenti risponde con il contratto errore Accessi.`
+      ], true),
+      note("info", `Due modalit\xE0 di bootstrap`, `Express esistente: initializeAccessiModule(app, options). NestJS esistente: AccessiModule.forRoot(options) nei tuoi imports. Non usarle entrambe.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "installazione",
+    group: "Per iniziare",
+    title: "Installazione",
+    summary: "Dipendenze, peer e build.",
+    blocks: [
+      code("bash", `npm install emilsoftware-utilities`, "Installazione"),
+      p(`La libreria dipende da node-firebird per il database e da Express 5 come peer per il montaggio. \xC8 consigliato Node 18 o superiore.`),
+      note("warn", `Un solo modulo per processo`, `AccessiModule \xE8 @Global(): inizializzalo una sola volta per processo. In caso di pi\xF9 istanze, usa un processo per istanza.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "bootstrap-express",
+    group: "Per iniziare",
+    title: "Bootstrap su Express esistente",
+    summary: "initializeAccessiModule: ordine corretto e attesa prima di listen.",
+    blocks: [
+      p(`Chiama initializeAccessiModule prima di aprire la porta HTTP. Durante il bootstrap, authorizeAccessi risponde 503 ACCESSI_AUTH_INITIALIZING invece di autorizzare richieste parziali.`),
+      good("ts", [
+        "import express from 'express';",
+        "import { initializeAccessiModule, authorizeAccessi } from 'emilsoftware-utilities';",
+        "",
+        "const app = express();",
+        "app.use(express.json());",
+        "",
+        "await initializeAccessiModule(app, options); // prima di app.listen",
+        "",
+        "app.get('/api/ordini', authorizeAccessi, (req, res) => {",
+        "  res.json({ utente: req.user });",
+        "});",
+        "",
+        "app.get('/api/ordini/scrivi', (req, res, next) =>",
+        "  authorizeAccessi(req, res, next, {",
+        "    requirements: [{ menuCode: 'ORDINI', minPermissionLevel: 20 }],",
+        "  }),",
+        "(req, res) => res.json({ ok: true }));",
+        "",
+        "app.listen(3000);"
+      ].join("\n"), "Express + Accessi"),
+      bad("ts", [
+        "const app = express();",
+        "app.listen(3000); // porta aperta prima del bootstrap",
+        "await initializeAccessiModule(app, options); // le richieste nel frattempo ricevono 503"
+      ].join("\n"), "Non aprire la porta prima del bootstrap"),
+      h(`Rotte montate`),
+      p(`Accessi intercetta solo /api/accessi/*, /accessi/swagger* e /accessi/swagger.json. Tutte le altre rotte passano intatte al tuo stack Express.`),
+      note("ok", `req.user`, `authorizeAccessi popola req.user con il payload utente corrente (utente, codiceUtente, flag) e req.data come alias storico. req.userGrants \xE8 presente solo se hai richiesto dei requisiti.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "bootstrap-nest",
+    group: "Per iniziare",
+    title: "Bootstrap su NestJS esistente",
+    summary: "AccessiModule.forRoot e uso dei provider esportati.",
+    blocks: [
+      p(`Se la tua applicazione \xE8 gi\xE0 NestJS, importa AccessiModule.forRoot(options). Il modulo \xE8 @Global e riesporta i servizi (AuthService, UserService, PermissionService, FederatedAuthService, ServiceTokenService, ServiceTokenGuard, AuthenticateGenService).`),
+      good("ts", [
+        "import { Module } from '@nestjs/common';",
+        "import { AccessiModule } from 'emilsoftware-utilities';",
+        "",
+        "@Module({",
+        "  imports: [AccessiModule.forRoot(options)],",
+        "})",
+        "export class AppModule {}"
+      ].join("\n"), "app.module.ts"),
+      p(`Il global prefix api e le rotte /api/accessi/* sono gestiti dal modulo. Le tue rotte Nest si proteggono con JwtSimpleGuard usando il JWT Accessi.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "opzioni",
+    group: "Configurazione",
+    title: "AccessiOptions (riferimento completo)",
+    summary: "Ogni campo di configurazione con tipo, obbligo e note.",
+    blocks: [
+      table(
+        ["Campo", "Tipo", "Obbligo", "Note"],
+        [
+          ["databaseOptions", "Options (node-firebird)", "s\xEC", "Connessione Firebird al database Accessi."],
+          ["confirmationEmailUrl", "string", "s\xEC", "Base URL usata per il reset password."],
+          ["confirmationEmailReturnUrl", "string", "s\xEC", "URL di ritorno dopo il reset."],
+          ["confirmationEmailPrefix", "string", "no", "Prefisso passato alla pagina di reset."],
+          ["customResetPage", "string", "no", "Sostituisce la pagina HTML di reset inclusa."],
+          ["encryptionKey", "string", "s\xEC", "Compatibilit\xE0 e migrazione delle password legacy."],
+          ["mockDemoUser", "boolean", "s\xEC", "Utenti fittizi admin e demo solo fuori produzione."],
+          ["passwordExpiration", "boolean", "no", "Attiva il controllo della scadenza password al login."],
+          ["passwordExpirationDays", "number", "no", "Valore predefinito: 90 giorni."],
+          ["legacyPasswordMigrationOnStartup", "boolean", "no", "Predefinito true: converte le password legacy."],
+          ["autoUpdateDatabase", "boolean", "no", "Predefinito true: riconcilia lo schema al boot."],
+          ["jwtOptions", "{ secret, expiresIn }", "s\xEC", "Firma HS256 e durata dei JWT Accessi."],
+          ["emailOptions", "EmailOptions", "s\xEC", "SMTP per reset e codici email."],
+          ["publicAuthRateLimit", "PublicAuthRateLimitOptions", "no", "Limiti in-memory sugli endpoint pubblici."],
+          ["publicRegistration", "{ enabled }", "no", "Registrazione pubblica: disattivata per impostazione predefinita."],
+          ["federatedAuthentication", "FederatedAuthenticationOptions", "no", `Abilita l'SSO generico.`],
+          ["extensionFieldsOptions", "ExtensionFieldsOptions[]", "no", "Tabelle esterne allegate al profilo."],
+          ["serviceTokens", "{ enabled, defaultTtlDays }", "no", "Token macchina-a-macchina, abilitati per impostazione predefinita."]
+        ]
+      ),
+      good("ts", [
+        "import type { AccessiOptions } from 'emilsoftware-utilities';",
+        "",
+        "export const options: AccessiOptions = {",
+        "  databaseOptions: {",
+        "    host: process.env.ACCESSI_DB_HOST!,",
+        "    port: Number(process.env.ACCESSI_DB_PORT ?? 3050),",
+        "    database: process.env.ACCESSI_DB_NAME!,",
+        "    user: process.env.ACCESSI_DB_USER!,",
+        "    password: process.env.ACCESSI_DB_PASSWORD!,",
+        "  },",
+        "  confirmationEmailUrl: 'https://app.example.com',",
+        "  confirmationEmailReturnUrl: 'https://app.example.com/login',",
+        "  encryptionKey: process.env.ACCESSI_ENCRYPTION_KEY!,",
+        "  mockDemoUser: false,",
+        "  passwordExpiration: true,",
+        "  passwordExpirationDays: 90,",
+        "  jwtOptions: {",
+        "    secret: process.env.ACCESSI_JWT_SECRET!, // almeno 32 caratteri casuali, unico per ambiente",
+        "    expiresIn: '24h',",
+        "  },",
+        "  emailOptions: {",
+        "    host: process.env.SMTP_HOST!,",
+        "    port: Number(process.env.SMTP_PORT ?? 587),",
+        "    secure: false,",
+        "    requireTLS: true,",
+        "    tls: { rejectUnauthorized: true },",
+        "    from: 'no-reply@example.com',",
+        "    auth: { user: process.env.SMTP_USER!, pass: process.env.SMTP_PASS! },",
+        "  },",
+        "  publicRegistration: { enabled: false },",
+        "  serviceTokens: { enabled: true, defaultTtlDays: 365 },",
+        "};"
+      ].join("\n"), "Configurazione tipica"),
+      bad("ts", [
+        "jwtOptions: { secret: 'accessi', expiresIn: '24h' }, // segreto debole e condiviso",
+        "mockDemoUser: true, // MAI in produzione"
+      ].join("\n"), "Errori comuni"),
+      note("danger", `Segreti`, `Non versionare i segreti e non passarli al frontend. jwtOptions.secret deve essere identico tra le istanze del backend e diverso da quello dei provider SSO.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "database",
+    group: "Configurazione",
+    title: "Schema e aggiornamento del database",
+    summary: "Tabelle, riconciliazione automatica e CLI.",
+    blocks: [
+      p(`Accessi possiede lo schema del dominio. Con autoUpdateDatabase true (predefinito) lo riconcilia a ogni avvio; con false verifica comunque la compatibilit\xE0 in sola lettura e blocca gli avvii incompatibili.`),
+      h(`Tabelle principali`),
+      list([
+        `PARAMETRI, UTENTI, UTENTI_CONFIG, UTENTI_PWD, UTENTI_OLDPWD, UTENTI_GDPR`,
+        `RUOLI, MENU_GRP, MENU_TIPI, MENU, ABILITAZIONI, RUOLI_MNU, UTENTI_RUOLI`,
+        `FILTRI, FILTRI_TIPO`,
+        `SSO_PROVIDER, UTENTI_IDENTITA_EXT`,
+        `ACCESSI_2FA, ACCESSI_SERVICE_TOKEN`
+      ]),
+      code("bash", `npm run db:update:accessi   # riconcilia lo schema
+npm run db:check:accessi    # verifica senza modificare`, "CLI schema"),
+      note("warn", `Versioni`, `La libreria richiede uno schema compatibile con la versione corrente (ACCESSI_SCHEMA_VERSION). Se la verifica fallisce, leggi il codice errore ACCESSI_DATABASE_SCHEMA_OUTDATED ed esegui db:update:accessi.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "login",
+    group: "Autenticazione",
+    title: "Login locale e JWT",
+    summary: "Endpoint di login, risposta e gestione della password scaduta.",
+    blocks: [
+      code("http", `POST /api/accessi/auth/login
+Content-Type: application/json
+
+{ "email": "utente@example.com", "password": "Segreta123!" }`, "Login con password"),
+      p(`La risposta include Result.token (il JWT) e il profilo utente con ruoli, permessi e filtri. Se l'account \xE8 passwordless, ometti la password: il server risponde con un challenge via email (vedi la sezione su 2FA e passwordless).`),
+      good("ts", [
+        "const res = await fetch('/api/accessi/auth/login', {",
+        "  method: 'POST',",
+        "  headers: { 'Content-Type': 'application/json' },",
+        "  body: JSON.stringify({ email, password }),",
+        "});",
+        "const body = await res.json();",
+        "if (body.Result?.challenge) { /* richiedi il codice */ }",
+        "const token = body.Result?.token;"
+      ].join("\n"), "Chiamata dal frontend"),
+      note("warn", `Password scaduta`, `Con passwordExpiration attivo, una password scaduta produce una PasswordExpiredResponse con code PASSWORD_EXPIRED. Il client deve avviare il reset della password.`),
+      h(`Verifica del token`),
+      code("http", `POST /api/accessi/auth/get-user-by-token
+Content-Type: application/json
+
+{ "token": "<jwt>" }`, "get-user-by-token"),
+      p(`Usalo per verificare un JWT e ottenere il profilo corrente (utile al bootstrap di una SPA). Restituisce Result.userData.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "passwordless-2fa",
+    group: "Autenticazione",
+    title: "Codici email, 2FA e passwordless",
+    summary: "Verifica in due passi, challenge e policy per utente.",
+    blocks: [
+      p(`La verifica con codice email \xE8 per-utente (flagDueFattori / UTENTI_CONFIG.FLG2FATT) ed \xE8 disattivata per impostazione predefinita. Con passwordlessLoginEnabled (FLGPWDLESS, richiede la 2FA attiva) l'accesso avviene con il solo codice email.`),
+      table(
+        ["Configurazione", "Accesso locale", "Accesso SSO"],
+        [
+          ["2FA disattivata", "Password", "Provider"],
+          ["2FA attiva", "Password + codice email", "Provider + codice email"],
+          ["2FA + passwordless", "Solo codice email", "Provider + codice email"]
+        ]
+      ),
+      code("json", `{
+  "Result": {
+    "challenge": {
+      "twoFactorRequired": true,
+      "challengeId": "64-caratteri-esadecimali",
+      "method": "email",
+      "expiresAt": "2026-09-11T14:00:00.000Z",
+      "resendAfterSeconds": 60
+    }
+  }
+}`, "Risposta con challenge"),
+      code("http", `POST /api/accessi/auth/two-factor/verify
+{ "challengeId": "...", "code": "012345" }
+
+POST /api/accessi/auth/two-factor/resend
+{ "challengeId": "..." }`, "Verifica e reinvio"),
+      list([
+        `Il codice ha 6 cifre, dura 10 minuti, consente 5 tentativi totali e al massimo 3 invii per challenge.`,
+        `Fino alla verifica non sono presenti token, profilo o grant.`,
+        `Il challenge non \xE8 un JWT e non va usato nell'header Authorization.`
+      ]),
+      bad("ts", [
+        "// Sbagliato: usare il challenge come token",
+        "fetch('/api/ordini', { headers: { Authorization: 'Bearer ' + challengeId } }); // 401"
+      ].join("\n"), "Il challenge non \xE8 un token")
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "reset-password",
+    group: "Autenticazione",
+    title: "Reset password",
+    summary: "Invio email e conferma con token monouso.",
+    blocks: [
+      code("http", `POST /api/accessi/email/send-reset-password-email
+{ "email": "utente@example.com" }
+
+POST /api/accessi/auth/confirm-reset-password/{token}
+{ "newPassword": "NuovaSegreta123!" }`, "Reset in due passi"),
+      p(`L'invio non rivela se l'email esiste (anti-enumerazione). Il token di reset \xE8 monouso ed \xE8 firmato con una chiave dedicata.`),
+      note("info", `Pagina personalizzata`, `Imposta customResetPage per usare la tua pagina di reset invece di quella inclusa. confirmationEmailReturnUrl e confirmationEmailPrefix controllano il ritorno.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "middleware",
+    group: "Autorizzazione",
+    title: "authorizeAccessi (middleware)",
+    summary: "Proteggere le rotte della tua app con il JWT Accessi.",
+    blocks: [
+      p(`authorizeAccessi \xE8 un middleware Express che verifica il JWT, ricarica lo stato utente corrente e applica i requisiti. Su successo prosegue; su errore risponde direttamente con il contratto Accessi (non chiamare un tuo next(error)).`),
+      good("ts", [
+        "app.get('/api/report',",
+        "  (req, res, next) => authorizeAccessi(req, res, next, {",
+        "    requirements: [{ menuCode: 'REPORT', minPermissionLevel: 10 }],",
+        "  }),",
+        "  (req, res) => res.json({ user: req.user, grants: req.userGrants }),",
+        ");"
+      ].join("\n"), "Rotta protetta"),
+      h(`Che cosa trovi nella request`),
+      list([
+        `req.user e req.data: payload utente corrente (alias storici).`,
+        `req.userGrants: grant effettivi, presente solo quando hai richiesto dei requisiti.`
+      ]),
+      bad("ts", [
+        "app.get('/api/report', authorizeAccessi, (req, res) => {",
+        "  // Sbagliato: assumere che req.userGrants esista senza requisiti",
+        "  const grants = req.userGrants.grants; // possibile TypeError",
+        "});"
+      ].join("\n"), "Non dare per scontato req.userGrants"),
+      note("danger", `Lo stato utente \xE8 sempre ricontrollato`, `Un JWT valido non basta: se l'utente \xE8 stato bloccato, eliminato o ha cambiato policy, il middleware risponde 401 AUTH_USER_DISABLED.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "requisiti",
+    group: "Autorizzazione",
+    title: "Requisiti e livelli di abilitazione",
+    summary: "DSL accessiRequirement: permission, and, or, not, custom.",
+    blocks: [
+      p(`I requisiti si compongono con accessiRequirement. La forma storica requirements \xE8 un AND di permessi. Il livello \xE8 TipoAbilitazione: NESSUNA=0, LETTURA=10, SCRITTURA=20, SPECIAL=30; il confronto \xE8 tipoAbilitazione >= soglia.`),
+      good("ts", [
+        "import { authorizeAccessi, accessiRequirement as r } from 'emilsoftware-utilities';",
+        "",
+        "// AND (entrambi i menu)",
+        'const both = r.and(r.permission("ORDINI", 20), r.permission("CLIENTI", 10));',
+        "",
+        "// OR",
+        'const either = r.or(r.permission("REPORT", 10), r.permission("EXPORT", 20));',
+        "",
+        "// NOT + custom",
+        "const policy = r.and(",
+        '  r.permission("AREA_RISERVATA", 10),',
+        '  r.not(r.permission("BLOCCO_TOTALE", 0)),',
+        ");",
+        "",
+        'app.get("/api/riservato", (req, res, next) => authorizeAccessi(req, res, next, {',
+        "  requirementTree: policy,",
+        "  customRequirementHandlers: {",
+        "    stessoReparto: async (ctx) => ctx.userCode === Number(ctx.req.query.reparto),",
+        "  },",
+        "}), handler);"
+      ].join("\n"), "Policy composte"),
+      bad("ts", [
+        "// Sbagliato: AND/OR senza figli -> errore di configurazione (500 AUTH_REQUIREMENTS_MISCONFIGURED)",
+        "const empty = r.and();"
+      ].join("\n"), "Configurazione non valida"),
+      note("warn", `custom senza handler`, `Un requisito custom la cui chiave non ha un handler produce 500 AUTH_REQUIREMENTS_MISCONFIGURED: \xE8 un errore di programmazione, non un 403.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "utenti",
+    group: "Dominio",
+    title: "Utenti",
+    summary: "Creazione, aggiornamento, stati, GDPR e filtri.",
+    blocks: [
+      h(`Stati di registrazione (STAREG)`),
+      table(
+        ["Valore", "Nome", "Effetto sul login"],
+        [
+          ["0", "NULL", "Non confermato"],
+          ["5", "INSERT", "Non confermato"],
+          ["10", "INVIO", "Richiede il rinnovo della password"],
+          ["20", "CONF", "Valido"],
+          ["50", "DELETE", "Bloccato (soft delete)"],
+          ["99", "BLOCC", "Bloccato"]
+        ]
+      ),
+      h(`Endpoint principali (superutente salvo diversamente indicato)`),
+      table(
+        ["Metodo", "Percorso", "Descrizione"],
+        [
+          ["GET", "/api/accessi/user/get-users", "Elenco con paginazione (limit e offset, header X-Total-Count)."],
+          ["POST", "/api/accessi/user/create-managed-user", "Crea un utente locale e invia il reset password."],
+          ["PUT", "/api/accessi/user/update-user/:codiceUtente", "Aggiorna profilo e policy (campi privilegiati solo superutente)."],
+          ["DELETE", "/api/accessi/user/delete-user/:codiceUtente", "Soft delete: STAREG=DELETE."],
+          ["POST", "/api/accessi/user/set-stato", "Imposta lo stato di registrazione."],
+          ["PATCH", "/api/accessi/user/set-gdpr/:codiceUtente", "Registra il consenso GDPR."],
+          ["POST", "/api/accessi/user/register", "Registrazione pubblica, solo se publicRegistration.enabled."]
+        ]
+      ),
+      good("ts", [
+        "await fetch('/api/accessi/user/create-managed-user', {",
+        "  method: 'POST',",
+        "  headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + adminToken },",
+        "  body: JSON.stringify({",
+        "    email: 'nuovo@example.com',",
+        "    nome: 'Mario',",
+        "    cognome: 'Rossi',",
+        "    roles: [1, 2],",
+        "    permissions: [{ codiceMenu: 'REPORT', tipoAbilitazione: 10 }],",
+        "  }),",
+        "});"
+      ].join("\n"), "Creazione di un utente gestito"),
+      bad("ts", [
+        "// Sbagliato: inviare flag privilegiati dal frontend pubblico",
+        'fetch("/api/accessi/user/register", {',
+        '  method: "POST",',
+        "  body: JSON.stringify({ email, flagSuper: true }), // ignorato o negato",
+        "});"
+      ].join("\n"), "Privilegi dal client"),
+      note("info", `Campi estesi`, `extensionFieldsOptions allega colonne di tabelle applicative al profilo (per esempio la ragione sociale). Le colonne sono in whitelist: non costruirle mai da input HTTP.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "ruoli",
+    group: "Dominio",
+    title: "Ruoli e permessi",
+    summary: "Assegnazioni sostitutive e composizione dei grant.",
+    blocks: [
+      p(`I ruoli contengono una lista di menu con livello. Le assegnazioni (ruoli e permessi diretti) sono SOSTITUTIVE: invia sempre la lista completa desiderata. I grant diretti prevalgono su quelli dei ruoli; i superutenti vedono tutti i menu attivi.`),
+      table(
+        ["Metodo", "Percorso", "Descrizione"],
+        [
+          ["GET", "/api/accessi/permission/roles", "Ruoli con i menu associati."],
+          ["POST", "/api/accessi/permission/create-role", "Crea un ruolo (i menu sono obbligatori)."],
+          ["PUT", "/api/accessi/permission/update-role/:codiceRuolo", "Aggiorna un ruolo (menu sostitutivi)."],
+          ["DELETE", "/api/accessi/permission/delete-role/:codiceRuolo", "Elimina ruolo, mapping e assegnazioni."],
+          ["POST", "/api/accessi/permission/assign-roles/:codiceUtente", `Sostituisce i ruoli dell'utente.`],
+          ["POST", "/api/accessi/permission/assign-permissions/:codiceUtente", "Sostituisce i permessi diretti."],
+          ["GET", "/api/accessi/permission/grants/:codiceUtente", "Grant effettivi, permessi diretti e ruoli."]
+        ]
+      ),
+      good("ts", [
+        "const role = {",
+        "  descrizioneRuolo: 'Gestore ordini',",
+        "  menu: [",
+        "    { codiceMenu: 'ORDINI', tipoAbilitazione: 20 },",
+        "    { codiceMenu: 'CLIENTI', tipoAbilitazione: 10 },",
+        "  ],",
+        "};",
+        "await createRole(role); // POST /api/accessi/permission/create-role",
+        "",
+        "// Sostitutivo: questa lista diventa l'intero set di ruoli dell'utente",
+        "await assignRolesToUser(codiceUtente, { roles: [3, 7] });"
+      ].join("\n"), "Creazione di un ruolo e assegnazione"),
+      bad("ts", [
+        "// Sbagliato: pensare che l'assegnazione sia incrementale",
+        "await assignRolesToUser(codiceUtente, { roles: [3] });",
+        "// ora l'utente ha SOLO il ruolo 3, non 3 pi\xF9 quelli di prima"
+      ].join("\n"), "Assegnazione non additiva"),
+      note("warn", `Menu obbligatori`, `create-role e update-role rifiutano un ruolo senza menu. Se ti serve un ruolo senza accessi, non crearlo.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "menu",
+    group: "Dominio",
+    title: "Menu, gruppi e tipi menu",
+    summary: "Catalogo di navigazione e CRUD completo (superutente).",
+    blocks: [
+      table(
+        ["Metodo", "Percorso", "Descrizione"],
+        [
+          ["GET", "/api/accessi/permission/menus", "Menu attivi."],
+          ["GET", "/api/accessi/permission/menu-types", "Catalogo dei tipi menu."],
+          ["GET", "/api/accessi/permission/groups-with-menus?includeDisabled=true", "Gruppi con menu (anche disabilitati)."],
+          ["POST", "/api/accessi/permission/menus", "Crea un menu."],
+          ["PUT", "/api/accessi/permission/menus/:codiceMenu", "Aggiorna un menu."],
+          ["DELETE", "/api/accessi/permission/menus/:codiceMenu", "Elimina un menu (con grant e associazioni ai ruoli)."],
+          ["POST", "/api/accessi/permission/menu-groups", "Crea un gruppo."],
+          ["PUT", "/api/accessi/permission/menu-groups/:codiceGruppo", "Aggiorna un gruppo."],
+          ["DELETE", "/api/accessi/permission/menu-groups/:codiceGruppo", "Elimina un gruppo (solo se vuoto)."],
+          ["POST/PUT/DELETE", "/api/accessi/permission/menu-types[/:codiceTipo]", "CRUD dei tipi menu."]
+        ]
+      ),
+      p(`I codici (CODMNU, CODGRP, CODTIP) sono chiavi immutabili: si indicano in creazione e poi si passano nel percorso. Un gruppo o un tipo si elimina solo se non \xE8 referenziato.`),
+      good("ts", [
+        "await createMenuGroup({ codiceGruppo: 'A', descrizioneGruppo: 'Amministrazione', ordineGruppo: 1, enabled: true });",
+        "await createMenuType({ codiceTipo: 'X', descrizioneTipo: 'Operativo' });",
+        "await createMenu({ codiceMenu: 'ORDINI', descrizioneMenu: 'Ordini', codiceGruppo: 'A', tipo: 'X', ordineMenu: 10, enabled: true });"
+      ].join("\n"), "Catalogo in ordine"),
+      bad("ts", [
+        "// Sbagliato: eliminare un gruppo che contiene menu -> 400 con spiegazione",
+        "await deleteMenuGroup('A'); // contiene N menu"
+      ].join("\n"), "Vincoli di integrit\xE0")
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "filtri",
+    group: "Dominio",
+    title: "Filtri applicativi",
+    summary: "Filtri per utente e catalogo dei tipi filtro.",
+    blocks: [
+      table(
+        ["Metodo", "Percorso", "Descrizione"],
+        [
+          ["GET", "/api/accessi/filtri/tipi", "Catalogo dei tipi filtro."],
+          ["POST", "/api/accessi/filtri/tipi", "Crea un tipo filtro (superutente)."],
+          ["PUT", "/api/accessi/filtri/tipi/:tipFil", "Aggiorna un tipo filtro."],
+          ["DELETE", "/api/accessi/filtri/tipi/:tipFil", "Elimina un tipo filtro (se non \xE8 usato)."],
+          ["GET", "/api/accessi/filtri/utente?codUte=123", "Filtri di un utente (self o superutente)."],
+          ["POST", "/api/accessi/filtri/utente", "Upsert dei filtri (self o superutente)."]
+        ]
+      ),
+      note("info", `Mapping delle colonne`, `I campi filtro sono mappati su colonne FILTRI in whitelist (FILTRI_UTENTE_DB_MAPPING). I campi non configurati nello schema vengono rifiutati.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "sso",
+    group: "SSO",
+    title: "SSO generico (federated authentication)",
+    summary: "Il backend valida il provider, Accessi gestisce identit\xE0 e sessioni.",
+    blocks: [
+      p(`Accessi non valida i token Azure, Google o SAML: \xE8 il TUO backend a validare il flusso SSO e a passare solo { provider, subject } verificati a FederatedAuthService. Cos\xEC issuer, secret e token restano fuori dal modulo.`),
+      good("ts", [
+        "import { FederatedAuthService } from 'emilsoftware-utilities';",
+        "",
+        "// Nel tuo callback SSO, dopo aver validato il token del provider:",
+        'const verified = { provider: "azure-ad-acme", subject: claims.oid };',
+        "const result = await federatedAuthService.authenticate(verified);",
+        "",
+        "if (result.login.challenge) {",
+        "  // 2FA attiva: restituisci il challenge al frontend",
+        "  return res.json({ challenge: result.login.challenge });",
+        "}",
+        "return res.json({ login: result.login, token: result.token });"
+      ].join("\n"), "Login SSO"),
+      h(`API amministrative (superutente)`),
+      list([
+        `GET/POST /api/accessi/federated-auth/providers, PATCH/DELETE providers/:provider`,
+        `GET/POST /api/accessi/federated-auth/users/:codiceUtente/identities`,
+        `POST /api/accessi/federated-auth/users (crea un utente SSO-only)`,
+        `PATCH /api/accessi/federated-auth/users/:codiceUtente/password-login`
+      ]),
+      bad("ts", [
+        "// Sbagliato: far validare il token del provider ad Accessi o fidarsi del frontend",
+        "await federatedAuthService.authenticate({ provider, subject: req.body.email }); // subject non verificato"
+      ].join("\n"), `Non fidarti dell'input`),
+      note("warn", `Provider in uso`, `Un provider si elimina solo se nessuna identit\xE0 \xE8 collegata; altrimenti disabilitalo. La chiave del provider deve coincidere con la configurazione del backend.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "service-token",
+    group: "Token di servizio",
+    title: "Token macchina-a-macchina",
+    summary: "Autenticazione tecnica con scope: non \xE8 un superutente.",
+    blocks: [
+      p(`Formato: st_<id>.<segreto> (segreto da 256 bit). Nel database si salva solo lo SHA-256 del segreto; il segreto \xE8 mostrato una sola volta. La verifica restituisce { tokenId, label, scopes }: nessun ruolo o grant.`),
+      note("danger", `Non \xE8 un superutente`, `Un service token non apre le API Accessi: abilita solo le rotte della tua app che proteggi con ServiceTokenGuard.`),
+      good("ts", [
+        "import { ServiceTokenGuard, RequireServiceTokenScopes } from 'emilsoftware-utilities';",
+        "",
+        "@UseGuards(ServiceTokenGuard)",
+        "@RequireServiceTokenScopes('ia')",
+        '@Post("internal/ask")',
+        "ask() { /* req.accessiServiceToken = { tokenId, label, scopes } */ }"
+      ].join("\n"), "Rotta tecnica protetta"),
+      h(`Gestione (superutente)`),
+      list([
+        `POST /api/accessi/service-token (label, scopes, expiresAt o ttlDays) -> segreto mostrato una volta`,
+        `GET /api/accessi/service-token?includeRevoked=true`,
+        `DELETE /api/accessi/service-token/:tokenId (revoca immediata)`,
+        `POST /api/accessi/service-token/:tokenId/rotate`
+      ]),
+      bad("ts", [
+        "// Sbagliato: usare un service token per autenticare un utente umano",
+        "fetch('/api/profilo', { headers: { Authorization: 'Bearer ' + serviceToken } }); // req.user assente"
+      ].join("\n"), "Non \xE8 un utente"),
+      note("warn", `Scadenza`, `Senza expiresAt n\xE9 defaultTtlDays il token non scade: imposta serviceTokens.defaultTtlDays o una scadenza esplicita.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "console",
+    group: "Console",
+    title: "Console amministrativa",
+    summary: "Accesso, sezioni e che cosa si pu\xF2 fare.",
+    blocks: [
+      p(`La console \xE8 servita dal modulo su /api/accessi/console e richiede un superutente Accessi. Non ha stato proprio: ogni azione chiama le API protette con il JWT dell'utente connesso.`),
+      list([
+        `Utenti: elenco, creazione locale o SSO, profilo, ruoli, grant diretti, stato, 2FA.`,
+        `Ruoli e grant: CRUD dei ruoli con l'albero delle abilitazioni.`,
+        `Menu e gruppi: CRUD di gruppi, menu e tipi menu.`,
+        `Filtri: filtri utente e tipi filtro.`,
+        `Token di servizio: creazione, rotazione, revoca.`,
+        `SSO: provider e identit\xE0.`
+      ]),
+      note("info", `Accesso`, `Apri /api/accessi/console e accedi con un utente con flagSuper=true. Le sezioni sono raggiungibili anche tramite deep link (per esempio /api/accessi/console/menu-e-gruppi/menu).`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "errori",
+    group: "Riferimenti",
+    title: "Contratto errori e codici",
+    summary: "Formato della risposta e codici stabili ACCESSI_* e AUTH_*.",
+    blocks: [
+      p(`Gli errori HTTP delle API Accessi usano un contratto stabile: severity, status, statusCode, code, error (campo legacy uguale a code), message e details per gli errori di validazione.`),
+      code("json", `{
+  "severity": "error",
+  "status": 400,
+  "statusCode": 2,
+  "code": "ACCESSI_VALIDATION_ERROR",
+  "error": "ACCESSI_VALIDATION_ERROR",
+  "message": "La richiesta contiene dati non validi.",
+  "details": ["email: deve essere una stringa."]
+}`, "Errore di validazione"),
+      table(
+        ["Codice", "Quando"],
+        [
+          ["ACCESSI_VALIDATION_ERROR", "Body o parametri non validi (400)."],
+          ["ACCESSI_AUTH_INITIALIZING", "Bootstrap in corso (503)."],
+          ["ACCESSI_AUTH_NOT_INITIALIZED", "Modulo non inizializzato (500)."],
+          ["AUTH_HEADER_MISSING / AUTH_TOKEN_MISSING", "Header Authorization assente (401)."],
+          ["AUTH_TOKEN_INVALID", "JWT non valido o scaduto (401)."],
+          ["AUTH_USER_DISABLED", "Utente non pi\xF9 autorizzato (401)."],
+          ["AUTH_INSUFFICIENT_PERMISSIONS", "Requisiti non soddisfatti (403)."],
+          ["AUTH_REQUIREMENTS_MISCONFIGURED", "Policy malformata o handler custom mancante (500)."],
+          ["ACCESSI_DATABASE_SCHEMA_OUTDATED", "Schema del database incompatibile."],
+          ["ACCESSI_SERVICE_TOKEN_RATE_LIMITED", "Troppi tentativi (429)."]
+        ]
+      )
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "endpoint",
+    group: "Riferimenti",
+    title: "Indice degli endpoint",
+    summary: "Tutte le rotte /api/accessi/* in una tabella.",
+    blocks: [
+      table(
+        ["Area", "Endpoint principali"],
+        [
+          ["Auth", "POST auth/login, auth/get-user-by-token, auth/confirm-reset-password/:token, auth/two-factor/verify, auth/two-factor/resend"],
+          ["Email", "POST email/send-reset-password-email, GET email/reset-password-page/:token"],
+          ["Utenti", "GET user/get-users, POST user/create-managed-user, PUT user/update-user/:codiceUtente, DELETE user/delete-user/:codiceUtente, POST user/set-stato, PATCH user/set-gdpr/:codiceUtente, POST user/register"],
+          ["Permessi", "GET permission/roles, POST permission/create-role, PUT permission/update-role/:codiceRuolo, DELETE permission/delete-role/:codiceRuolo, POST permission/assign-roles/:codiceUtente, POST permission/assign-permissions/:codiceUtente, GET permission/grants/:codiceUtente, GET permission/menus, GET permission/menu-types, GET permission/groups-with-menus"],
+          ["Catalogo", "POST/PUT/DELETE permission/menus[/:codiceMenu], permission/menu-groups[/:codiceGruppo], permission/menu-types[/:codiceTipo]"],
+          ["Configurator", "PATCH configurator/menus/:codiceMenu/enabled, PATCH configurator/groups/:codiceGruppo/enabled"],
+          ["Filtri", "GET filtri/tipi, POST/PUT/DELETE filtri/tipi[/:tipFil], GET/POST filtri/utente"],
+          ["SSO", "GET/POST federated-auth/providers, PATCH/DELETE providers/:provider, GET/POST users/:codiceUtente/identities, POST users, PATCH users/:codiceUtente/password-login"],
+          ["Token", "POST/GET service-token, DELETE service-token/:tokenId, POST service-token/:tokenId/rotate"],
+          ["Console", "GET console, console/:view, console/:view/:sub, console/assets/:file"]
+        ]
+      )
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "antipattern",
+    group: "Riferimenti",
+    title: "Antipattern e checklist",
+    summary: "Che cosa non fare, in breve.",
+    blocks: [
+      list([
+        `Non aprire la porta HTTP prima di initializeAccessiModule.`,
+        `Non usare authorizeAccessi come unico strato: valida sempre anche l'input applicativo.`,
+        `Non dare per scontato che req.userGrants esista se non hai richiesto dei requisiti.`,
+        `Non considerare incrementali assignRolesToUser e assignPermissionsToUser: sono sostitutivi.`,
+        `Non far validare i token SSO ad Accessi: passagli solo { provider, subject } verificati.`,
+        `Non usare un service token come identit\xE0 utente.`,
+        `Non versionare segreti; jwtOptions.secret deve essere unico per ambiente.`,
+        `Non eliminare gruppi o tipi in uso: gestisci l'errore 400 e disabilita invece.`,
+        `Non usare il challenge 2FA come JWT.`
+      ]),
+      note("ok", `Checklist di rilascio`, `Schema verificato (db:check), segreti da un secret manager, mockDemoUser=false, rate limit pubblico configurato, SMTP reale testato, serviceTokens.defaultTtlDays impostato.`)
+    ]
+  }
+];
+function wikiGroups() {
+  const groups = [];
+  for (const section of WIKI_SECTIONS) {
+    let bucket = groups.find((item) => item.group === section.group);
+    if (!bucket) {
+      bucket = { group: section.group, sections: [] };
+      groups.push(bucket);
+    }
+    bucket.sections.push(section);
+  }
+  return groups;
+}
+function buildAiDigest() {
+  const lines = [
+    `# Accessi (emilsoftware-utilities) - guida compatta per l'integrazione backend`,
+    "",
+    `Modulo NestJS/Express + Firebird per autenticazione JWT, autorizzazione per menu, utenti, 2FA e passwordless, SSO generico, service token e console.`,
+    ""
+  ];
+  for (const { group, sections } of wikiGroups()) {
+    lines.push(`## ${group}`);
+    for (const section of sections) {
+      lines.push(`### ${section.title}`);
+      lines.push(section.summary);
+      for (const block of section.blocks) {
+        switch (block.kind) {
+          case "p":
+            lines.push(block.text);
+            break;
+          case "h":
+            lines.push(`**${block.text}**`);
+            break;
+          case "list":
+            block.items.forEach((item, index) => lines.push(`${block.ordered ? `${index + 1}.` : "-"} ${item}`));
+            break;
+          case "code":
+            lines.push("```" + block.language);
+            lines.push(block.code);
+            lines.push("```");
+            break;
+          case "callout":
+            lines.push(`[${block.tone.toUpperCase()}] ${block.title ? block.title + ": " : ""}${block.text}`);
+            break;
+          case "table":
+            lines.push("| " + block.head.join(" | ") + " |");
+            lines.push("| " + block.head.map(() => "---").join(" | ") + " |");
+            block.rows.forEach((row) => lines.push("| " + row.join(" | ") + " |"));
+            break;
+        }
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+// src/accessi-module/Console/help.ts
+var p2 = (text) => ({ kind: "p", text });
+var list2 = (items) => ({ kind: "list", items });
+var code2 = (language, codeText, title) => ({ kind: "code", language, title, code: codeText });
+var note2 = (tone, title, text) => ({ kind: "callout", tone, title, text });
+var table2 = (head, rows) => ({ kind: "table", head, rows });
+var HELP = {
+  // ------------------------------------------------------------------ SSO
+  "sso-provider": {
+    title: "Provider SSO",
+    blocks: [
+      p2(`La chiave del provider censito in Accessi. Deve coincidere esattamente con quella usata dal backend quando valida il login SSO e chiama FederatedAuthService.authenticate({ provider, subject }).`),
+      p2(`Se il backend usa la chiave azure-ad-acme-prod, qui va la stessa stringa: una differenza, anche di un carattere, fa fallire il collegamento.`),
+      note2("info", "Chi crea il provider", `Prima si censisce il provider in "SSO \u2192 Provider" (superutente), poi lo si sceglie qui. Se l'elenco \xE8 vuoto, non ci sono provider attivi.`)
+    ]
+  },
+  "sso-subject": {
+    title: "ID utente del provider (subject)",
+    blocks: [
+      p2(`\xC8 l'identificatore STABILE della persona nel provider, non l'email. Il backend lo ottiene dopo aver validato il token del provider e lo passa ad Accessi; Accessi non vede mai il token esterno.`),
+      p2(`Ecco il claim corretto per i provider pi\xF9 comuni:`),
+      table2(
+        ["Provider", "Claim da usare", "Note"],
+        [
+          ["Azure AD / Entra ID", "oid", "Object ID. Non usare preferred_username n\xE9 email."],
+          ["Google", "sub", "ID numerico di 21 cifre. Non l indirizzo email."],
+          ["Apple", "sub", "Identificatore stabile per la tua app; disponibile solo al primo login, va salvato subito."],
+          ["Okta", "sub", "Claim standard OIDC."],
+          ["Auth0", "sub", "Formato auth0|... oppure google-oauth2|... ."],
+          ["Keycloak", "sub", "Claim standard OIDC."],
+          ["Microsoft personale (MSA)", "sub", "Account outlook/live."],
+          ["SAML 2.0", "NameID", "Identificatore persistente dell utente."],
+          ["OIDC generico", "sub", "Claim standard OIDC."]
+        ]
+      ),
+      note2("danger", "Mai usare l email", `L'email pu\xF2 cambiare e non \xE8 un identificatore stabile: usarla come subject crea duplicati e collegamenti errati.`),
+      code2("ts", [
+        "// Nel backend, dopo aver validato il token del provider:",
+        "// Azure AD / Entra ID",
+        "const subject = claims.oid;",
+        "// Google / Okta / Keycloak / OIDC generico",
+        "const subject = claims.sub;",
+        "// Apple (disponibile al primo login, salvalo subito)",
+        "const subject = claims.sub;",
+        "// SAML",
+        "const subject = assertion.nameId;"
+      ].join("\n"), "Come ricavare il subject")
+    ]
+  },
+  "sso-note": {
+    title: "Nota",
+    blocks: [
+      p2(`Nota interna per gli amministratori, utile a ricordare perch\xE9 il collegamento esiste (per esempio "migrato da AD il 2026-01-10"). Non viene inviata al provider.`)
+    ]
+  },
+  "provider-key": {
+    title: "Chiave provider",
+    blocks: [
+      p2(`Identificativo tecnico del provider, usato dal backend nel payload SSO. Scegli una chiave descrittiva e stabile, per esempio azure-ad-acme-prod o google-workspace-acme.`),
+      note2("warn", "Immutabile", `Dopo il censimento la chiave non si modifica: identit\xE0 e configurazione del backend la referenziano. Se serve cambiarla, disabilita il provider e creane uno nuovo.`)
+    ]
+  },
+  "provider-description": {
+    title: "Descrizione",
+    blocks: [
+      p2(`Nome leggibile mostrato agli amministratori (per esempio "Azure AD \u2013 Acme produzione"). Non \xE8 la chiave tecnica: pu\xF2 contenere spazi.`)
+    ]
+  },
+  "provider-note": {
+    title: "Nota",
+    blocks: [
+      p2(`Nota interna del catalogo. Non inserire segreti, issuer, client id o dati personali: quei valori restano nel backend.`)
+    ]
+  },
+  "provider-active": {
+    title: "Provider attivo",
+    blocks: [
+      p2(`Se disattivato, il provider non accetta nuovi login e nuovi collegamenti; le identit\xE0 e lo storico restano. Riattivalo quando il backend \xE8 pronto.`)
+    ]
+  },
+  // --------------------------------------------------------- service token
+  "token-label": {
+    title: "Descrizione del token",
+    blocks: [
+      p2(`Nome del token, mostrato agli amministratori (per esempio "Integrazione IA \u2013 produzione"). Non \xE8 un segreto.`)
+    ]
+  },
+  "token-scopes": {
+    title: "Scope",
+    blocks: [
+      p2(`Etichette che il backend controlla per autorizzare le chiamate tecniche. Un token non \xE8 un superutente: abilita solo le rotte protette con ServiceTokenGuard e @RequireServiceTokenScopes.`),
+      list2([
+        `Formato: lettere, numeri, ':', '_' o '-', massimo 40 caratteri.`,
+        `Esempi: ia, chat, tools, report:read.`,
+        `Separa gli scope con una virgola.`
+      ]),
+      code2("ts", [
+        "@UseGuards(ServiceTokenGuard)",
+        "@RequireServiceTokenScopes('ia')",
+        '@Post("internal/ask")',
+        "ask() { /* il token deve avere lo scope ia */ }"
+      ].join("\n"), "Come li usa il backend"),
+      note2("warn", "Scope vuoto", `Senza scope il token non soddisfa nessun @RequireServiceTokenScopes, ma passa comunque le rotte protette senza scope richiesto.`)
+    ]
+  },
+  "token-ttl": {
+    title: "Durata (giorni)",
+    blocks: [
+      p2(`Giorni di validit\xE0 del token. Alla scadenza il token smette di funzionare.`),
+      note2("danger", "Nessuna scadenza", `Se lasci vuoto questo campo e non imposti una data, il token non scade mai: sconsigliato in produzione.`)
+    ]
+  },
+  // ----------------------------------------------------------------- utenti
+  "user-email": {
+    title: "Email",
+    blocks: [
+      p2(`Identificativo di accesso dell'utente e recapito per le email di reset o codici. Deve essere univoca.`)
+    ]
+  },
+  "user-name": {
+    title: "Nome e cognome",
+    blocks: [
+      p2(`Dati anagrafici mostrati in console e restituiti nel profilo. Non incidono sull'autenticazione.`)
+    ]
+  },
+  "user-password-login": {
+    title: "Login con password",
+    blocks: [
+      p2(`Se disattivato, il login con email e password viene rifiutato (PASSWORD_LOGIN_DISABLED). Restano validi i login con identit\xE0 SSO attive.`),
+      note2("info", "Utente solo SSO", `\xC8 l'opzione tipica per gli utenti federati: nessuna password locale, accesso solo dal provider.`)
+    ]
+  },
+  "user-2fa": {
+    title: "Codice via email (2FA)",
+    blocks: [
+      p2(`Richiede un codice monouso inviato per email dopo la password o dopo il provider SSO. \xC8 per-utente e disattivata per impostazione predefinita.`),
+      list2([
+        `Codice a 6 cifre, valido 10 minuti, 5 tentativi, massimo 3 invii.`,
+        `Non sono token: fino alla verifica non esiste alcun JWT.`
+      ])
+    ]
+  },
+  "user-passwordless": {
+    title: "Accesso con il solo codice email",
+    blocks: [
+      p2(`Abilita il login senza password: si inserisce solo l'email e si usa il codice ricevuto. Richiede il codice email (2FA) attivo.`),
+      note2("warn", "Non sono due fattori", `L'accesso con il solo codice \xE8 autenticazione tramite possesso della casella email: un solo fattore.`)
+    ]
+  },
+  "user-state": {
+    title: "Stato di registrazione",
+    blocks: [
+      table2(
+        ["Stato", "Significato"],
+        [
+          ["Non definito / Inserito", "Utente non confermato."],
+          ["Invitato (10)", "Richiede il rinnovo della password."],
+          ["Confermato (20)", "Utente valido, pu\xF2 accedere."],
+          ["Eliminato (50)", "Soft delete: login bloccato."],
+          ["Bloccato (99)", "Login bloccato."]
+        ]
+      )
+    ]
+  },
+  // ------------------------------------------------------------------ ruoli
+  "role-description": {
+    title: "Descrizione del ruolo",
+    blocks: [
+      p2(`Nome del ruolo (per esempio "Gestore ordini"). Deve avere almeno un menu selezionato: il salvataggio sostituisce integralmente i menu del ruolo.`)
+    ]
+  },
+  "role-level": {
+    title: "Livello di abilitazione",
+    blocks: [
+      table2(
+        ["Livello", "Valore", "Uso tipico"],
+        [
+          ["Lettura", "10", "Sola consultazione."],
+          ["Scrittura", "20", "Modifica dei dati."],
+          ["Legacy (30)", "30", "Valore storico, mantenuto senza perdita."]
+        ]
+      ),
+      p2(`Il controllo confronta tipoAbilitazione >= soglia: un livello 20 soddisfa anche una richiesta di livello 10.`)
+    ]
+  },
+  // --------------------------------------------------------- catalogo menu
+  "menu-code": {
+    title: "Codice menu",
+    blocks: [
+      p2(`Chiave tecnica del menu, stabile e senza spazi (per esempio ORDINI o MNU001). \xC8 la chiave primaria: non si modifica dopo la creazione.`),
+      note2("warn", "Immutabile", `Il codice \xE8 referenziato da ruoli e grant: per cambiarlo, elimina e ricrea il menu.`)
+    ]
+  },
+  "menu-group-code": {
+    title: "Codice gruppo",
+    blocks: [
+      p2(`Un solo carattere (per esempio A). Raggruppa i menu nella navigazione. Immutabile dopo la creazione.`)
+    ]
+  },
+  "menu-type-code": {
+    title: "Codice tipo menu",
+    blocks: [
+      p2(`Un solo carattere (per esempio X). Classifica i menu (amministrazione, operativo, ...). Immutabile dopo la creazione.`)
+    ]
+  },
+  "menu-group-order": {
+    title: "Ordine del gruppo",
+    blocks: [
+      p2(`Numero che determina l'ordine dei gruppi nella navigazione: valori pi\xF9 bassi compaiono prima.`)
+    ]
+  },
+  "menu-order": {
+    title: "Ordine del menu",
+    blocks: [
+      p2(`Numero che determina l'ordine dei menu all'interno del gruppo: valori pi\xF9 bassi compaiono prima.`)
+    ]
+  },
+  "menu-page": {
+    title: "Pagina",
+    blocks: [
+      p2(`Percorso o nome della pagina del frontend associata al menu (per esempio /ordini). \xC8 informativo: lo usano la UI host e i client.`)
+    ]
+  },
+  "menu-icon": {
+    title: "Icona",
+    blocks: [
+      p2(`Identificatore dell'icona usato dalla UI host (per esempio fa-box o un nome concordato). Accessi non impone un set di icone.`)
+    ]
+  },
+  "menu-rifmenu": {
+    title: "Menu di riferimento",
+    blocks: [
+      p2(`Codice di un altro menu che fa da padre, per costruire gerarchie di menu. Lascia vuoto per un menu di primo livello.`)
+    ]
+  },
+  "menu-note": {
+    title: "Nota",
+    blocks: [
+      p2(`Nota descrittiva mostrata agli amministratori. Non incide sui permessi.`)
+    ]
+  },
+  "menu-enabled": {
+    title: "Menu abilitato",
+    blocks: [
+      p2(`Se disattivato, il menu non compare nel catalogo attivo e non viene considerato nel calcolo dei grant. I collegamenti a ruoli e utenti restano.`)
+    ]
+  },
+  "menu-group-enabled": {
+    title: "Gruppo abilitato",
+    blocks: [
+      p2(`Disattiva l'intero gruppo: i menu al suo interno non sono considerati attivi, ma restano configurabili per una riattivazione futura.`)
+    ]
+  },
+  // ----------------------------------------------------------------- filtri
+  "filter-type-code": {
+    title: "Codice tipo filtro",
+    blocks: [
+      p2(`Numero identificativo del tipo filtro. \xC8 la chiave primaria: non si modifica dopo la creazione.`)
+    ]
+  },
+  "filter-type-field": {
+    title: "Campo",
+    blocks: [
+      p2(`Nome della colonna applicativa della tabella FILTRI a cui il tipo \xE8 associato (per esempio CODCLI). Deve esistere nello schema, altrimenti i filtri che lo usano vengono rifiutati.`)
+    ]
+  },
+  "filter-type-enabled": {
+    title: "Tipo filtro abilitato",
+    blocks: [
+      p2(`Se disattivato, il tipo non \xE8 proposto ai client, ma i filtri gi\xE0 salvati restano nel database.`)
+    ]
+  },
+  "filters-json": {
+    title: "Filtro JSON",
+    blocks: [
+      p2(`Rappresentazione JSON dei filtri applicativi dell'utente. Usa "Carica" per partire dalla struttura esistente, modifica i valori e poi "Salva".`),
+      note2("info", "Campi ammessi", `Sono accettati solo i campi mappati nello schema (FILTRI_UTENTE_DB_MAPPING). Un campo non configurato viene rifiutato con un errore esplicito.`)
+    ]
+  },
+  "filters-user": {
+    title: "Utente",
+    blocks: [
+      p2(`Utente a cui appartengono i filtri. Selezionalo prima di caricare o salvare: i filtri sono sempre per singolo utente.`)
+    ]
+  },
+  // ------------------------------------------------------------ assegnazioni
+  "role-assignment": {
+    title: "Assegnazione dei ruoli",
+    blocks: [
+      p2(`Il salvataggio SOSTITUISCE integralmente i ruoli dell'utente: la lista selezionata diventa l'unico set di ruoli.`),
+      list2([
+        `Per aggiungere un ruolo, selezionalo mantenendo quelli gi\xE0 presenti.`,
+        `Per rimuovere un ruolo, deselezionalo.`,
+        `Non modificare i grant diretti: quelli si gestiscono nella scheda "Grant diretti".`
+      ]),
+      note2("warn", "Non \xE8 incrementale", `Inviare solo il nuovo ruolo rimuove gli altri. Invia sempre la lista completa desiderata.`)
+    ]
+  },
+  "grant-direct": {
+    title: "Grant diretti",
+    blocks: [
+      p2(`Permessi assegnati direttamente all'utente, indipendenti dai ruoli. Hanno precedenza sui permessi ereditati dai ruoli per lo stesso menu.`),
+      list2([
+        `Imposta il livello per concedere l'accesso.`,
+        `Scegli "nessuno" per rimuovere il grant diretto.`,
+        `Il salvataggio sostituisce l'intero set di grant diretti.`
+      ])
+    ]
+  },
+  "grant-level": {
+    title: "Livello di grant",
+    blocks: [
+      table2(
+        ["Voce", "Valore", "Significato"],
+        [
+          ["nessuno", "\u2014", "Nessun grant diretto per quel menu (il permesso pu\xF2 arrivare dai ruoli)."],
+          ["Lettura", "10", "Sola consultazione."],
+          ["Scrittura", "20", "Modifica dei dati."]
+        ]
+      ),
+      p2(`Il confronto \xE8 tipoAbilitazione >= soglia richiesta dalla rotta.`)
+    ]
+  },
+  "user-delete": {
+    title: "Imposta stato eliminato",
+    blocks: [
+      p2(`Esegue un soft delete: imposta lo stato di registrazione a "Eliminato" (50). L'utente non pu\xF2 pi\xF9 accedere, ma i dati restano nel database.`),
+      note2("info", "Reversibile", `Non \xE8 una cancellazione fisica: puoi ripristinare l'utente cambiando lo stato di registrazione.`)
+    ]
+  },
+  // ----------------------------------------------------- selezioni di menu
+  "menu-group-select": {
+    title: "Gruppo",
+    blocks: [
+      p2(`Gruppo di appartenenza del menu. Se l'elenco \xE8 vuoto, crea prima un gruppo in "Menu e gruppi \u2192 Gruppi".`)
+    ]
+  },
+  "menu-type-select": {
+    title: "Tipo menu",
+    blocks: [
+      p2(`Classificazione del menu (amministrazione, operativo, ...). \xC8 facoltativa: se non serve, lascia "Nessun tipo". I tipi si gestiscono in "Menu e gruppi \u2192 Tipi menu".`)
+    ]
+  },
+  // ------------------------------------------------------------------ login
+  "login-email": {
+    title: "Email o utente",
+    blocks: [
+      p2(`Indirizzo email dell'utente Accessi. Se l'account \xE8 abilitato al solo codice, dopo questo passo riceverai un codice via email invece di inserire la password.`)
+    ]
+  },
+  "login-password": {
+    title: "Password",
+    blocks: [
+      p2(`Password locale dell'utente. Non serve per gli account passwordless, che accedono con il solo codice email.`)
+    ]
+  }
+};
 
 // src/accessi-module/Console/console.ts
 var routeSegment = {
   users: "utenti",
   roles: "ruoli-e-grant",
-  menus: "menu-e-gruppi",
-  filters: "filtri",
-  sso: "sso"
+  menuGroups: "menu-e-gruppi/gruppi",
+  menuItems: "menu-e-gruppi/menu",
+  menuTypes: "menu-e-gruppi/tipi-menu",
+  filterUser: "filtri/utente",
+  filterTypes: "filtri/tipi",
+  ssoProviders: "sso/provider",
+  ssoUsers: "sso/utenti",
+  tokens: "token-di-servizio",
+  wiki: "wiki"
 };
 var routeView = Object.fromEntries(Object.entries(routeSegment).map(([view, segment]) => [segment, view]));
+var parentDefaultView = {
+  "menu-e-gruppi": "menuGroups",
+  filtri: "filterUser",
+  sso: "ssoProviders"
+};
 var consoleMarker = "/accessi/console";
 var consoleMarkerIndex = window.location.pathname.indexOf(consoleMarker);
 var consoleBasePath = consoleMarkerIndex >= 0 ? window.location.pathname.slice(0, consoleMarkerIndex + consoleMarker.length) : `${window.location.pathname.replace(/\/$/, "")}`;
+var USERS_PAGE_SIZE = 25;
 var token = sessionStorage.getItem("accessi-console-token");
 var currentUser = null;
 var federatedAuthenticationAvailable = false;
+var usersPage = 0;
+var usersTotal = 0;
+var booting = true;
 var pendingNetworkRequests = 0;
 var loadingRevealTimer;
 var loadingHideTimer;
@@ -471,7 +1867,7 @@ function result(response) {
   return body.Result;
 }
 function showNotice(message, isError = false) {
-  byId("notice").innerHTML = `<span class="${isError ? "error" : ""}">${escapeHtml(message)}</span>`;
+  byId("notice").innerHTML = message ? `<span class="${isError ? "error" : ""}">${escapeHtml(message)}</span>` : "";
 }
 function menuMetadata(menu) {
   const details = [
@@ -491,9 +1887,9 @@ function groupMetadata(group) {
   return `<dl class="entity-metadata"><div><dt>Codice</dt><dd>${escapeHtml(group.codiceGruppo)}</dd></div><div><dt>Ordine</dt><dd>${escapeHtml(group.ordineGruppo)}</dd></div><div><dt>Stato</dt><dd>${group.enabled === false ? "Disabilitato" : "Abilitato"}</dd></div><div><dt>Menu</dt><dd>${group.menus.length}</dd></div></dl>`;
 }
 function directGrantEditor(groups, grants) {
-  return `<form id="grants" class="user-editor-section grants-editor" data-user-panel="grants" role="tabpanel" aria-labelledby="user-tab-grants"><h3>Grant diretti</h3><p class="form-help">Abilitazioni assegnate direttamente all'utente, indipendenti dai ruoli. Seleziona <strong>nessuno</strong> per rimuoverle. Le voci disabilitate restano visibili per non perdere grant esistenti al salvataggio.</p><div class="grant-menu-groups">${groups.map((group) => `<fieldset class="grant-menu-group"><legend>${escapeHtml(group.descrizioneGruppo)}</legend>${groupMetadata(group)}<div class="grant-menu-options">${group.menus.map((menu) => {
+  return `<form id="grants" class="user-editor-section grants-editor" data-user-panel="grants" role="tabpanel" aria-labelledby="user-tab-grants"><h3>Grant diretti ${helpDot("grant-direct")}</h3><p class="form-help">Grant diretti, indipendenti dai ruoli. Seleziona <strong>nessuno</strong> per rimuoverli.</p><div class="grant-menu-groups">${groups.map((group) => `<fieldset class="grant-menu-group"><legend>${escapeHtml(group.descrizioneGruppo)}</legend>${groupMetadata(group)}<div class="grant-menu-options">${group.menus.map((menu) => {
     const grant = (grants ?? []).find((item) => item.codiceMenu === menu.codiceMenu);
-    return `<div class="grant-menu-option ${menu.enabled === false ? "is-disabled" : ""}"><div class="grant-menu-info"><strong>${escapeHtml(menu.descrizioneMenu)}</strong>${menuMetadata(menu)}</div><label class="grant-level">Livello di grant<select name="grant:${escapeHtml(menu.codiceMenu)}"><option value="">nessuno</option>${permissionSelectOptions(grant?.tipoAbilitazione)}</select></label></div>`;
+    return `<div class="grant-menu-option ${menu.enabled === false ? "is-disabled" : ""}"><div class="grant-menu-info"><strong>${escapeHtml(menu.descrizioneMenu)}</strong>${menuMetadata(menu)}</div><label class="grant-level">Livello di grant ${helpDot("grant-level")}<select name="grant:${escapeHtml(menu.codiceMenu)}"><option value="">nessuno</option>${permissionSelectOptions(grant?.tipoAbilitazione)}</select></label></div>`;
   }).join("") || '<p class="form-help">Nessun menu configurato in questo gruppo.</p>'}</div></fieldset>`).join("")}</div><button>Salva grant</button></form>`;
 }
 function permissionLevelLabel(value) {
@@ -504,7 +1900,7 @@ function rolePermissionLevel(value) {
 }
 function roleAssignmentEditor(roles, assignedRoles, groups) {
   const catalogMenus = new Map(groups.flatMap((group) => group.menus.map((menu) => [menu.codiceMenu, menu])));
-  return `<form id="roles" class="user-editor-section roles-editor" data-user-panel="roles" role="tabpanel" aria-labelledby="user-tab-roles"><h3>Ruoli</h3><p class="form-help">Ogni ruolo assegna i menu elencati sotto con il relativo livello. Salvare sostituisce la selezione dei ruoli dell'utente, non i grant diretti.</p><div class="role-assignment-list">${roles.map((role) => {
+  return `<form id="roles" class="user-editor-section roles-editor" data-user-panel="roles" role="tabpanel" aria-labelledby="user-tab-roles"><h3>Ruoli ${helpDot("role-assignment")}</h3><p class="form-help">Salvare sostituisce i ruoli dell'utente (non i grant diretti).</p><div class="role-assignment-list">${roles.map((role) => {
     const roleMenus = role.menu ?? [];
     const assigned = (assignedRoles ?? []).some((current) => current.codiceRuolo === role.codiceRuolo);
     const groupedMenus = groups.map((group) => ({ group, entries: group.menus.map((menu) => ({ menu, assignment: roleMenus.find((item) => item.codiceMenu === menu.codiceMenu) })).filter((entry) => entry.assignment) })).filter((entry) => entry.entries.length > 0);
@@ -514,24 +1910,43 @@ function roleAssignmentEditor(roles, assignedRoles, groups) {
 }
 function roleOverview(role, groups) {
   const roleMenus = role.menu ?? [];
-  const catalogMenus = new Map(groups.flatMap((group) => group.menus.map((menu) => [menu.codiceMenu, menu])));
-  const groupedMenus = groups.map((group) => ({ group, entries: group.menus.map((menu) => ({ menu, assignment: roleMenus.find((item) => item.codiceMenu === menu.codiceMenu) })).filter((entry) => entry.assignment) })).filter((entry) => entry.entries.length > 0);
-  const missingMenus = roleMenus.filter((item) => !catalogMenus.has(item.codiceMenu));
-  return `<article class="role-assignment-card role-overview-card"><details class="role-overview-details"><summary class="role-assignment-heading"><div class="role-identity"><span class="role-kind">Ruolo</span><strong>${escapeHtml(role.descrizioneRuolo)}</strong><span class="role-code">Codice ruolo: ${escapeHtml(role.codiceRuolo)}</span></div><div class="role-overview-actions"><span class="role-menu-count">${roleMenus.length} menu</span><span class="role-expand-hint"><span class="when-closed">Mostra menu</span><span class="when-open">Nascondi menu</span></span></div></summary><div class="role-permission-groups">${groupedMenus.map(({ group, entries }) => `<section class="role-permission-group"><div class="role-permission-group-heading"><div><span class="group-kind">Gruppo</span><strong>${escapeHtml(group.descrizioneGruppo)}</strong></div>${groupMetadata(group)}</div>${entries.map(({ menu, assignment }) => `<div class="role-permission-entry ${menu.enabled === false ? "is-disabled" : ""}"><div><span class="menu-kind">Menu</span><strong>${escapeHtml(menu.descrizioneMenu)}</strong>${menuMetadata(menu)}</div><span class="permission-level">${escapeHtml(rolePermissionLevel(assignment?.tipoAbilitazione))}</span></div>`).join("")}</section>`).join("") || '<p class="form-help">Questo ruolo non contiene menu attivi nel catalogo.</p>'}${missingMenus.length ? `<section class="role-permission-group missing-role-menus"><strong>Menu non pi\xF9 presenti nel catalogo</strong>${missingMenus.map((menu) => `<div class="role-permission-entry"><div><strong>${escapeHtml(menu.codiceMenu)}</strong><p class="entity-note">Il menu \xE8 ancora associato al ruolo ma non \xE8 disponibile nel catalogo corrente.</p></div><span class="permission-level">${escapeHtml(rolePermissionLevel(menu.tipoAbilitazione))}</span></div>`).join("")}</section>` : ""}</div></details><button type="button" class="role-edit-button" data-role="${escapeHtml(role.codiceRuolo)}">Modifica</button></article>`;
-}
-function menuGroupTable(group) {
-  return `<article class="menu-group-card ${group.enabled === false ? "is-disabled" : ""}"><div class="menu-group-header"><label class="check"><input type="checkbox" data-group="${escapeHtml(group.codiceGruppo)}" ${group.enabled !== false ? "checked" : ""}><span><strong>${escapeHtml(group.descrizioneGruppo)}</strong><small>Gruppo di menu</small></span></label>${groupMetadata(group)}</div><div class="menu-table-wrap"><table class="menu-table"><thead><tr><th>Stato</th><th>Menu</th><th>Codice</th><th>Ordine</th><th>Tipo</th><th>Pagina</th><th>Icona</th><th>Nota</th></tr></thead><tbody>${group.menus.map((menu) => `<tr class="${menu.enabled === false ? "is-disabled" : ""}"><td><label class="table-toggle"><input type="checkbox" data-menu="${escapeHtml(menu.codiceMenu)}" ${menu.enabled !== false ? "checked" : ""}><span>${menu.enabled === false ? "Disabilitato" : "Abilitato"}</span></label></td><td><strong>${escapeHtml(menu.descrizioneMenu)}</strong></td><td><code>${escapeHtml(menu.codiceMenu)}</code></td><td>${escapeHtml(menu.ordineMenu)}</td><td>${escapeHtml(menu.tipo || "Non indicato")}</td><td>${menu.pagina ? `<code>${escapeHtml(menu.pagina)}</code>` : '<span class="muted">Non indicata</span>'}</td><td>${menu.icona ? `<code>${escapeHtml(menu.icona)}</code>` : '<span class="muted">Non indicata</span>'}</td><td>${escapeHtml(menu.note || "Nessuna nota")}</td></tr>`).join("") || '<tr><td colspan="8" class="muted">Nessun menu configurato in questo gruppo.</td></tr>'}</tbody></table></div></article>`;
+  const assignments = new Map(roleMenus.map((item) => [item.codiceMenu, item]));
+  const knownMenus = new Set(groups.flatMap((group) => group.menus.map((menu) => menu.codiceMenu)));
+  const tree = groups.map((group) => ({ group, entries: group.menus.filter((menu) => assignments.has(menu.codiceMenu)) })).filter((node) => node.entries.length > 0);
+  const orphans = roleMenus.filter((item) => !knownMenus.has(item.codiceMenu));
+  const groupNodes = tree.map(({ group, entries }) => `<li class="role-tree-group ${group.enabled === false ? "is-disabled" : ""}"><div class="role-tree-group-head"><strong>${escapeHtml(group.descrizioneGruppo)}</strong><span class="role-tree-count">${entries.length}</span></div><ul class="role-tree-menus">${entries.map((menu) => `<li class="role-tree-menu ${menu.enabled === false ? "is-disabled" : ""}"><span class="role-tree-menu-name">${escapeHtml(menu.descrizioneMenu)}</span><span class="permission-level">${escapeHtml(rolePermissionLevel(assignments.get(menu.codiceMenu)?.tipoAbilitazione))}</span></li>`).join("")}</ul></li>`).join("");
+  const orphanNode = orphans.length ? `<li class="role-tree-group is-orphan"><div class="role-tree-group-head"><strong>Menu non pi\xF9 nel catalogo</strong><span class="role-tree-count">${orphans.length}</span></div><ul class="role-tree-menus">${orphans.map((item) => `<li class="role-tree-menu"><span class="role-tree-menu-name"><code>${escapeHtml(item.codiceMenu)}</code></span><span class="permission-level">${escapeHtml(rolePermissionLevel(item.tipoAbilitazione))}</span></li>`).join("")}</ul></li>` : "";
+  return `<article class="role-card">
+    <div class="role-card-head">
+      <div class="role-card-title">
+        <strong>${escapeHtml(role.descrizioneRuolo)}</strong>
+        <span class="role-card-meta">Codice ${escapeHtml(role.codiceRuolo)} &middot; ${roleMenus.length} menu</span>
+      </div>
+      <div class="role-card-actions">
+        <button type="button" class="secondary" data-role="${escapeHtml(role.codiceRuolo)}">Modifica</button>
+        <button type="button" class="danger-button" data-role-delete="${escapeHtml(role.codiceRuolo)}">Elimina</button>
+      </div>
+    </div>
+    ${roleMenus.length ? `<details class="role-card-menus"><summary>Abilitazioni per menu (${roleMenus.length})</summary><ul class="role-tree">${groupNodes}${orphanNode}</ul></details>` : '<p class="role-card-empty">Nessun menu assegnato.</p>'}
+  </article>`;
 }
 function roleMenuEditorTable(group, role) {
   const roleMenus = role?.menu ?? [];
-  return `<article class="role-menu-group ${group.enabled === false ? "is-disabled" : ""}"><div class="menu-group-header"><div><strong>${escapeHtml(group.descrizioneGruppo)}</strong><small>Gruppo di menu</small></div>${groupMetadata(group)}</div><div class="menu-table-wrap"><table class="menu-table role-menu-table"><thead><tr><th scope="col">Incluso</th><th scope="col">Menu</th><th scope="col">Codice</th><th scope="col">Ordine</th><th scope="col">Tipo</th><th scope="col">Pagina</th><th scope="col">Icona</th><th scope="col">Stato</th><th scope="col">Abilitazione</th><th scope="col">Nota</th></tr></thead><tbody>${group.menus.map((menu) => {
+  const options = group.menus.map((menu) => {
     const assignment = roleMenus.find((item) => item.codiceMenu === menu.codiceMenu);
     const level = assignment?.tipoAbilitazione ?? 10;
-    return `<tr class="${menu.enabled === false ? "is-disabled" : ""}"><td><label class="table-toggle"><input type="checkbox" name="menu" value="${escapeHtml(menu.codiceMenu)}" ${assignment ? "checked" : ""} aria-label="Includi ${escapeHtml(menu.descrizioneMenu)}"><span>${assignment ? "Incluso" : "Escluso"}</span></label></td><td><strong>${escapeHtml(menu.descrizioneMenu)}</strong></td><td><code>${escapeHtml(menu.codiceMenu)}</code></td><td>${escapeHtml(menu.ordineMenu)}</td><td>${escapeHtml(menu.tipo || "Non indicato")}</td><td>${menu.pagina ? `<code>${escapeHtml(menu.pagina)}</code>` : '<span class="muted">Non indicata</span>'}</td><td>${menu.icona ? `<code>${escapeHtml(menu.icona)}</code>` : '<span class="muted">Non indicata</span>'}</td><td><span class="status-label ${menu.enabled === false ? "status-disabled" : "status-enabled"}">${menu.enabled === false ? "Disabilitato" : "Abilitato"}</span></td><td><label class="table-select"><span class="sr-only">Abilitazione per ${escapeHtml(menu.descrizioneMenu)}</span><select name="menu-level:${escapeHtml(menu.codiceMenu)}" ${assignment ? "" : "disabled"}>${permissionSelectOptions(level)}</select></label></td><td>${escapeHtml(menu.note || "Nessuna nota")}</td></tr>`;
-  }).join("") || '<tr><td colspan="10" class="muted">Nessun menu configurato in questo gruppo.</td></tr>'}</tbody></table></div></article>`;
+    return `<li class="role-menu-option ${menu.enabled === false ? "is-disabled" : ""}"><label class="check"><input type="checkbox" name="menu" value="${escapeHtml(menu.codiceMenu)}" ${assignment ? "checked" : ""}><span>${escapeHtml(menu.descrizioneMenu)}</span></label><label class="role-menu-level"><span class="sr-only">Livello per ${escapeHtml(menu.descrizioneMenu)}</span><select name="menu-level:${escapeHtml(menu.codiceMenu)}" ${assignment ? "" : "disabled"}>${permissionSelectOptions(level)}</select></label></li>`;
+  }).join("");
+  return `<section class="role-menu-group ${group.enabled === false ? "is-disabled" : ""}">
+    <div class="role-menu-group-head"><strong>${escapeHtml(group.descrizioneGruppo)}</strong>${group.enabled === false ? '<span class="muted">Gruppo disabilitato</span>' : ""}</div>
+    <ul class="role-menu-options">${options || '<li class="role-menu-empty muted">Nessun menu in questo gruppo.</li>'}</ul>
+  </section>`;
 }
 function updateLoadingState(active) {
   pendingNetworkRequests = Math.max(0, pendingNetworkRequests + (active ? 1 : -1));
+  if (booting) {
+    return;
+  }
   const overlay = byId("loading-overlay");
   if (pendingNetworkRequests > 0) {
     if (loadingHideTimer !== void 0) {
@@ -566,6 +1981,14 @@ function updateLoadingState(active) {
     hide();
   }
 }
+function finishBoot(view) {
+  booting = false;
+  const overlay = byId("loading-overlay");
+  overlay.hidden = true;
+  byId("app").removeAttribute("aria-busy");
+  byId("login").hidden = view !== "login";
+  byId("console").hidden = view !== "console";
+}
 function errorMessage(error) {
   return error instanceof Error ? error.message : "Operazione non riuscita.";
 }
@@ -573,6 +1996,7 @@ function handleAction(action) {
   void action().catch((error) => showNotice(errorMessage(error), true));
 }
 function render(markup) {
+  closeHelp();
   byId("view").innerHTML = markup;
 }
 function setActiveNavigation(view) {
@@ -583,19 +2007,24 @@ function setActiveNavigation(view) {
       link.removeAttribute("aria-current");
     }
   });
+  document.querySelectorAll("#nav details[data-nav-group]").forEach((branch) => {
+    if (branch.querySelector(`[data-view="${view}"]`)) branch.open = true;
+  });
 }
 function routePath(view) {
   return `${consoleBasePath}/${routeSegment[view]}`;
 }
 function viewFromLocation() {
   const relativePath = window.location.pathname.slice(consoleBasePath.length).replace(/^\/+|\/+$/g, "");
-  return routeView[decodeURIComponent(relativePath)] ?? "users";
+  const decoded = decodeURIComponent(relativePath);
+  return routeView[decoded] ?? parentDefaultView[decoded] ?? "users";
 }
 async function navigate(view, replace = false) {
   const destination = routePath(view);
   if (window.location.pathname !== destination) {
     window.history[replace ? "replaceState" : "pushState"]({ view }, "", destination);
   }
+  if (view === "users") usersPage = 0;
   await show(view);
 }
 function requireAdmin() {
@@ -608,12 +2037,12 @@ function eventForm(event) {
   return event.currentTarget;
 }
 function federatedIdentityFields(providers) {
-  return `<label>Provider<select name="provider" required><option value="">Seleziona un provider</option>${providers.filter((provider) => provider.active).map((provider) => `<option value="${escapeHtml(provider.provider)}">${escapeHtml(provider.description)} (${escapeHtml(provider.provider)})</option>`).join("")}</select><span class="form-help">Catalogo Accessi dei sistemi SSO disponibili. La chiave selezionata deve corrispondere alla configurazione del backend; per Azure deve distinguere tenant e ambiente.</span></label>
-    <label>ID utente del provider (subject)<input name="subject" required><span class="form-help">Identifica in modo stabile la singola persona nel provider. Il backend lo estrae dopo la verifica: per esempio <code>oid</code> Azure, <code>sub</code> OpenID Connect/Google/Apple o <code>NameID</code> SAML persistente. \xC8 necessario perch\xE9 il provider da solo non identifica l'utente. Non usare l'email: pu\xF2 cambiare.</span></label>
-    <label>Nota<input name="note"><span class="form-help">Annotazione interna per gli amministratori. Non viene inviata al provider e non assegna autorizzazioni.</span></label>`;
+  return `<label>Provider ${helpDot("sso-provider")}<select name="provider" required><option value="">Seleziona un provider</option>${providers.filter((provider) => provider.active).map((provider) => `<option value="${escapeHtml(provider.provider)}">${escapeHtml(provider.description)} (${escapeHtml(provider.provider)})</option>`).join("")}</select><span class="form-help">Deve corrispondere alla configurazione del backend.</span></label>
+    <label>ID utente del provider (subject) ${helpDot("sso-subject")}<input name="subject" required><span class="form-help">Identificatore stabile (es. <code>oid</code> Azure, <code>sub</code> Google/OIDC, <code>NameID</code> SAML). Mai l'email: apri la guida.</span></label>
+    <label>Nota ${helpDot("sso-note")}<input name="note"><span class="form-help">Nota interna, non inviata al provider.</span></label>`;
 }
 function federatedIdentitySection(identities, providers) {
-  return `<section class="user-editor-section sso-identity-section" data-user-panel="sso" role="tabpanel" aria-labelledby="user-tab-sso"><div class="section-heading"><div><p class="eyebrow">Autenticazione esterna</p><h3>Identit\xE0 SSO</h3></div><span class="muted">Collegamenti verificati dal backend</span></div><p class="form-help">Ogni collegamento riconosce l'utente presso un provider. Disabilita conserva lo storico e blocca il login; elimina rimuove definitivamente il collegamento, senza eliminare l'utente Accessi.</p><div class="sso-identity-list">${identities.map((identity) => `<article class="sso-identity-item ${identity.active ? "" : "is-disabled"}"><div class="sso-identity-data"><strong>${escapeHtml(identity.provider)}</strong><dl class="entity-metadata"><div><dt>Subject</dt><dd>${escapeHtml(identity.subject)}</dd></div><div><dt>Stato</dt><dd>${identity.active ? "Abilitata" : "Disabilitata"}</dd></div></dl>${identity.note ? `<p class="entity-note"><strong>Nota</strong>${escapeHtml(identity.note)}</p>` : ""}</div><div class="sso-identity-actions"><button type="button" class="secondary" data-identity-toggle="${escapeHtml(identity.identityKey)}" data-active="${String(!identity.active)}">${identity.active ? "Disabilita" : "Abilita"}</button><button type="button" class="icon-button danger-button" data-identity-delete="${escapeHtml(identity.identityKey)}" aria-label="Elimina definitivamente il collegamento SSO ${escapeHtml(identity.provider)}" title="Elimina definitivamente il collegamento SSO"><span aria-hidden="true">&#128465;</span></button></div></article>`).join("") || '<p class="muted">Nessun collegamento SSO.</p>'}</div>${providers.some((provider) => provider.active) ? `<form id="link-sso" class="sso-link-form">${federatedIdentityFields(providers)}<button>Collega SSO verificato</button></form>` : '<p class="form-help">Non ci sono provider SSO attivi. Censiscine uno nella sezione SSO prima di creare collegamenti.</p>'}</section>`;
+  return `<section class="user-editor-section sso-identity-section" data-user-panel="sso" role="tabpanel" aria-labelledby="user-tab-sso"><div class="section-heading"><div><p class="eyebrow">Autenticazione esterna</p><h3>Identit\xE0 SSO</h3></div><span class="muted">Collegamenti verificati dal backend</span></div><p class="form-help">Disabilita conserva lo storico; elimina rimuove il collegamento (l'utente resta).</p><div class="sso-identity-list">${identities.map((identity) => `<article class="sso-identity-item ${identity.active ? "" : "is-disabled"}"><div class="sso-identity-data"><strong>${escapeHtml(identity.provider)}</strong><dl class="entity-metadata"><div><dt>Subject</dt><dd>${escapeHtml(identity.subject)}</dd></div><div><dt>Stato</dt><dd>${identity.active ? "Abilitata" : "Disabilitata"}</dd></div></dl>${identity.note ? `<p class="entity-note"><strong>Nota</strong>${escapeHtml(identity.note)}</p>` : ""}</div><div class="sso-identity-actions"><button type="button" class="secondary" data-identity-toggle="${escapeHtml(identity.identityKey)}" data-active="${String(!identity.active)}">${identity.active ? "Disabilita" : "Abilita"}</button><button type="button" class="icon-button danger-button" data-identity-delete="${escapeHtml(identity.identityKey)}" aria-label="Elimina definitivamente il collegamento SSO ${escapeHtml(identity.provider)}" title="Elimina definitivamente il collegamento SSO"><span aria-hidden="true">&#128465;</span></button></div></article>`).join("") || '<p class="muted">Nessun collegamento SSO.</p>'}</div>${providers.some((provider) => provider.active) ? `<form id="link-sso" class="sso-link-form">${federatedIdentityFields(providers)}<button>Collega SSO verificato</button></form>` : '<p class="form-help">Non ci sono provider SSO attivi. Censiscine uno nella sezione SSO prima di creare collegamenti.</p>'}</section>`;
 }
 function userDetailTabs(hasSso) {
   const tabs = [
@@ -643,6 +2072,79 @@ function selectedNumbers(form, name) {
 async function loadUsers() {
   return result(await getUsers({ includeGrants: true }));
 }
+async function loadUsersPage() {
+  const response = await getUsers({
+    includeGrants: true,
+    limit: USERS_PAGE_SIZE,
+    offset: usersPage * USERS_PAGE_SIZE
+  });
+  const users = result(response);
+  const headers = response.headers;
+  const totalHeader = headers?.get?.("X-Total-Count") ?? null;
+  const parsed = totalHeader !== null && totalHeader !== "" ? Number(totalHeader) : Number.NaN;
+  const total = Number.isFinite(parsed) ? parsed : usersPage * USERS_PAGE_SIZE + users.length;
+  return { users, total };
+}
+function pageNumbers(current, total) {
+  if (total <= 7) {
+    return Array.from({ length: total }, (_, index) => index + 1);
+  }
+  const wanted = /* @__PURE__ */ new Set([1, total, current, current - 1, current + 1]);
+  const sorted = Array.from(wanted).filter((page) => page >= 1 && page <= total).sort((a, b) => a - b);
+  const result2 = [];
+  let previous = 0;
+  for (const page of sorted) {
+    if (previous !== 0 && page - previous > 1) {
+      result2.push("gap");
+    }
+    result2.push(page);
+    previous = page;
+  }
+  return result2;
+}
+function pagerMarkup(totalPages) {
+  const context = `<span class="pager-context">${usersTotal} utent${usersTotal === 1 ? "e" : "i"}${totalPages > 1 ? ` \xB7 pagina ${usersPage + 1} di ${totalPages}` : ""}</span>`;
+  if (totalPages <= 1) {
+    return `<nav class="pager" aria-label="Paginazione utenti">${context}</nav>`;
+  }
+  const numbers = pageNumbers(usersPage + 1, totalPages).map((page) => page === "gap" ? '<span class="pager-gap" aria-hidden="true">&hellip;</span>' : `<button type="button" class="pager-item" data-goto="${page}"${page === usersPage + 1 ? ' aria-current="page"' : ""}>${page}</button>`).join("");
+  const controls = `<span class="pager-controls"><button type="button" class="pager-item pager-nav" data-goto="prev"${usersPage === 0 ? " disabled" : ""} aria-label="Pagina precedente">&lsaquo;</button>` + numbers + `<button type="button" class="pager-item pager-nav" data-goto="next"${usersPage >= totalPages - 1 ? " disabled" : ""} aria-label="Pagina successiva">&rsaquo;</button></span>`;
+  return `<nav class="pager" aria-label="Paginazione utenti">${controls}${context}</nav>`;
+}
+function rolesCell(codiceUtente, userGrants) {
+  const labels = (userGrants?.ruoli ?? []).map((role) => role.descrizioneRuolo?.trim() || (role.codiceRuolo ? `#${role.codiceRuolo}` : "")).filter((label) => label.length > 0);
+  if (labels.length === 0) {
+    return '<span class="muted">&mdash;</span>';
+  }
+  const limit = 2;
+  if (labels.length <= limit) {
+    return `<span class="roles-list">${labels.map(escapeHtml).join(", ")}</span>`;
+  }
+  const hiddenCount = labels.length - limit;
+  return `<span class="roles-cell" data-roles-cell="${codiceUtente}"><span class="roles-list" data-roles-collapsed>${labels.slice(0, limit).map(escapeHtml).join(", ")}</span><span class="roles-list" data-roles-full hidden>${labels.map(escapeHtml).join(", ")}</span><button type="button" class="link-button" data-roles-toggle="${codiceUtente}" data-roles-more="${hiddenCount}" aria-expanded="false">altre ${hiddenCount}</button></span>`;
+}
+function setRolesExpanded(cell, expanded) {
+  cell.querySelector("[data-roles-collapsed]")?.toggleAttribute("hidden", expanded);
+  cell.querySelector("[data-roles-full]")?.toggleAttribute("hidden", !expanded);
+  const button = cell.querySelector("[data-roles-toggle]");
+  if (button) {
+    button.setAttribute("aria-expanded", String(expanded));
+    button.textContent = expanded ? "mostra meno" : `altre ${button.dataset.rolesMore ?? ""}`;
+  }
+}
+function bindRolesToggles() {
+  document.querySelectorAll("[data-roles-toggle]").forEach((button) => {
+    button.onclick = () => {
+      const cell = button.closest("[data-roles-cell]");
+      if (!cell) return;
+      const willExpand = button.getAttribute("aria-expanded") !== "true";
+      document.querySelectorAll("[data-roles-cell]").forEach((other) => {
+        if (other !== cell) setRolesExpanded(other, false);
+      });
+      setRolesExpanded(cell, willExpand);
+    };
+  });
+}
 async function detectFederatedAuthentication() {
   if (!currentUser) return;
   try {
@@ -657,7 +2159,7 @@ async function loginView(event) {
   try {
     const values = formValues(event.currentTarget);
     byId("login-error").textContent = "";
-    const response = result(await login({ email: values.email, password: values.password || void 0 }));
+    const response = result(await login({ email: values.email ?? "", password: values.password || void 0 }));
     await completeLoginStep(response);
   } catch (error) {
     byId("login-error").textContent = error instanceof Error ? error.message : "Login non riuscito.";
@@ -732,10 +2234,9 @@ async function bootstrap() {
     currentUser = payload.userData;
     requireAdmin();
     await detectFederatedAuthentication();
-    byId("login").hidden = true;
-    byId("console").hidden = false;
     byId("who").textContent = `${currentUser.email} - superutente`;
     byId("sso-navigation").hidden = !federatedAuthenticationAvailable;
+    finishBoot("console");
     await navigate(viewFromLocation(), window.location.pathname === consoleBasePath);
   } catch (error) {
     token = null;
@@ -743,35 +2244,48 @@ async function bootstrap() {
     setAccessiConsoleToken(null);
     federatedAuthenticationAvailable = false;
     sessionStorage.removeItem("accessi-console-token");
-    byId("login").hidden = false;
-    byId("console").hidden = true;
+    finishBoot("login");
     byId("login-error").textContent = error instanceof Error ? error.message : "Sessione non valida.";
   }
 }
 async function showUsers() {
-  const users = await loadUsers();
+  const { users, total } = await loadUsersPage();
+  usersTotal = total;
+  const totalPages = Math.max(1, Math.ceil(total / USERS_PAGE_SIZE));
+  if (usersPage >= totalPages) usersPage = totalPages - 1;
   render(`<div class="toolbar"><button id="new-local">Nuovo utente locale</button>${federatedAuthenticationAvailable ? '<button id="new-sso">Nuovo utente SSO</button>' : ""}<button id="reload-users" class="secondary">Aggiorna</button></div>
-    <h2>Utenti</h2><table><thead><tr><th>Utente</th><th>Stato</th><th>Accesso</th><th>2FA</th><th>Ruoli</th><th></th></tr></thead><tbody>
-    ${users.map(({ utente, userGrants }) => `<tr><td>${escapeHtml(utente.email)}<br><span class="muted">${escapeHtml(utente.nome)} ${escapeHtml(utente.cognome)}</span></td><td>${escapeHtml(utente.statoRegistrazione)}</td><td>${utente.passwordlessLoginEnabled ? "codice email" : utente.passwordLoginEnabled === false ? "solo SSO" : "password"}</td><td>${utente.flagDueFattori ? "Attiva" : "Disattiva"}</td><td>${(userGrants?.ruoli ?? []).map((role) => role.codiceRuolo).join(", ")}</td><td><button data-user="${utente.codiceUtente}">Gestisci</button></td></tr>`).join("")}
-    </tbody></table>`);
+    <div class="pager-row pager-row-top">${pagerMarkup(totalPages)}</div>
+    <table><thead><tr><th>Utente</th><th>Stato</th><th>Accesso</th><th>2FA</th><th>Ruoli</th><th></th></tr></thead><tbody>
+    ${users.map(({ utente, userGrants }) => `<tr><td>${escapeHtml(utente.email)}<br><span class="muted">${escapeHtml(utente.nome)} ${escapeHtml(utente.cognome)}</span></td><td>${escapeHtml(utente.statoRegistrazione)}</td><td>${utente.passwordlessLoginEnabled ? "codice email" : utente.passwordLoginEnabled === false ? "solo SSO" : "password"}</td><td>${utente.flagDueFattori ? "Attiva" : "Disattiva"}</td><td class="roles-col">${rolesCell(utente.codiceUtente, userGrants)}</td><td><button data-user="${utente.codiceUtente}">Gestisci</button></td></tr>`).join("") || '<tr><td colspan="6" class="muted">Nessun utente.</td></tr>'}
+    </tbody></table><div class="pager-row pager-row-bottom">${pagerMarkup(totalPages)}</div>`);
   byId("new-local").onclick = () => showLocalUserForm();
   if (federatedAuthenticationAvailable) byId("new-sso").onclick = () => handleAction(showSsoUserForm);
   byId("reload-users").onclick = () => handleAction(() => show("users"));
+  document.querySelectorAll("[data-goto]").forEach((button) => {
+    button.onclick = () => handleAction(async () => {
+      const target = button.dataset.goto;
+      const nextPage = target === "prev" ? usersPage - 1 : target === "next" ? usersPage + 1 : Number(target) - 1;
+      if (!Number.isInteger(nextPage) || nextPage < 0 || nextPage >= totalPages || nextPage === usersPage) return;
+      usersPage = nextPage;
+      await show("users");
+    });
+  });
   document.querySelectorAll("[data-user]").forEach((button) => {
     button.onclick = () => handleAction(() => showUser(button.dataset.user ?? ""));
   });
+  bindRolesToggles();
 }
 function authenticationPolicyFields(user) {
   return `<fieldset><legend>Verifica dell'accesso (opzionale)</legend>
-    <label class="check"><input name="flagDueFattori" type="checkbox" ${user.flagDueFattori ? "checked" : ""}> Richiedi un codice via email (2FA)</label>
-    <p class="form-help">Disattiva per impostazione predefinita. Se attiva, il codice viene richiesto dopo la password o dopo l'accesso SSO.</p>
-    <label class="check"><input name="passwordlessLoginEnabled" type="checkbox" ${user.passwordlessLoginEnabled ? "checked" : ""} ${user.flagDueFattori ? "" : "disabled"}> Consenti accesso con il solo codice email</label>
-    <p class="form-help">Permette di accedere senza password. Richiede il codice email attivo; i collegamenti SSO restano disponibili. Questo accesso usa il solo possesso della casella email.</p>
+    <label class="check"><input name="flagDueFattori" type="checkbox" ${user.flagDueFattori ? "checked" : ""}> Richiedi un codice via email (2FA) ${helpDot("user-2fa")}</label>
+    <p class="form-help">Se attiva, il codice \xE8 richiesto dopo password o SSO.</p>
+    <label class="check"><input name="passwordlessLoginEnabled" type="checkbox" ${user.passwordlessLoginEnabled ? "checked" : ""} ${user.flagDueFattori ? "" : "disabled"}> Consenti accesso con il solo codice email ${helpDot("user-passwordless")}</label>
+    <p class="form-help">Accesso senza password (richiede il codice email).</p>
     </fieldset>`;
 }
 function showLocalUserForm() {
   render(`<button id="back">Indietro</button><h2>Nuovo utente locale</h2><p class="muted">Viene inviata l'e-mail per impostare la password.</p>
-    <form id="local-user"><label>Email<input name="email" type="email" required><span class="form-help">Sar\xE0 l'identificativo di accesso dell'utente e ricever\xE0 il messaggio per impostare la password.</span></label><label>Nome<input name="nome"></label><label>Cognome<input name="cognome"></label><button>Crea utente</button></form>`);
+    <form id="local-user"><label>Email ${helpDot("user-email")}<input name="email" type="email" required><span class="form-help">Identificativo di accesso; ricever\xE0 l'email per la password.</span></label><label>Nome ${helpDot("user-name")}<input name="nome"></label><label>Cognome ${helpDot("user-name")}<input name="cognome"></label><button>Crea utente</button></form>`);
   byId("back").onclick = () => show("users");
   const localUserForm = document.getElementById("local-user");
   if (localUserForm) localUserForm.onsubmit = (event) => {
@@ -788,9 +2302,9 @@ async function showSsoUserForm() {
   if (!providers.some((provider) => provider.active)) {
     throw new Error("Prima di creare un utente SSO, censisci e abilita almeno un provider SSO.");
   }
-  render(`<button id="back">Indietro</button><h2>Nuovo utente SSO</h2><p class="muted">La console salva solo un collegamento gi\xE0 verificato dal backend; non accetta e non verifica token esterni.</p>
-    <form id="sso-user"><label>Email<input name="email" type="email" required><span class="form-help">Email di contatto e identificativo Accessi dell'utente.</span></label><label>Nome<input name="nome"></label><label>Cognome<input name="cognome"></label>${federatedIdentityFields(providers)}<label class="check"><input name="passwordLoginEnabled" type="checkbox"> Abilita anche la password locale</label><span class="form-help">Se non selezionato, l'utente acceder\xE0 esclusivamente con una delle identit\xE0 SSO attive.</span><button>Crea utente SSO</button></form>`);
-  byId("back").onclick = () => show("users");
+  render(`<button id="back">Indietro</button><h2>Nuovo utente SSO</h2><p class="muted">Salva solo collegamenti gi\xE0 verificati dal backend.</p>
+    <form id="sso-user"><label>Email ${helpDot("user-email")}<input name="email" type="email" required><span class="form-help">Email di contatto e identificativo Accessi dell'utente.</span></label><label>Nome ${helpDot("user-name")}<input name="nome"></label><label>Cognome ${helpDot("user-name")}<input name="cognome"></label>${federatedIdentityFields(providers)}<label class="check"><input name="passwordLoginEnabled" type="checkbox"> Abilita anche la password locale ${helpDot("user-password-login")}</label><span class="form-help">Se disattivato, l'utente accede solo via SSO.</span><button>Crea utente SSO</button></form>`);
+  byId("back").onclick = () => show("ssoUsers");
   const ssoUserForm = document.getElementById("sso-user");
   if (ssoUserForm) ssoUserForm.onsubmit = (event) => {
     event.preventDefault();
@@ -798,36 +2312,55 @@ async function showSsoUserForm() {
       const form = eventForm(event);
       const values = formValues(form);
       const request = {
-        provider: values.provider,
-        subject: values.subject,
+        provider: values.provider ?? "",
+        subject: values.subject ?? "",
         note: values.note || void 0,
         passwordLoginEnabled: new FormData(form).has("passwordLoginEnabled"),
-        user: { email: values.email, nome: values.nome || void 0, cognome: values.cognome || void 0 }
+        user: { email: values.email ?? "", nome: values.nome || void 0, cognome: values.cognome || void 0 }
       };
       await createFederatedUser(request);
       showNotice("Utente SSO creato e collegamento registrato.");
-      await show("users");
+      await show("ssoUsers");
     });
   };
 }
-async function showSso() {
+async function showSsoProviders() {
   if (!federatedAuthenticationAvailable) throw new Error("SSO non \xE8 abilitato in questa istanza Accessi.");
-  const [users, providers] = await Promise.all([loadUsers(), getFederatedProviders()]);
-  const providerList = result(providers);
-  render(`<div class="toolbar"><button id="new-sso">Nuovo utente SSO</button><button id="new-provider" class="secondary">Nuovo provider</button></div><h2>Configurazione SSO</h2><p class="muted">Il catalogo definisce le chiavi provider ammesse da Accessi. La validazione dei token, issuer, audience e segreti restano nel backend.</p><h3>Provider censiti</h3><table><thead><tr><th>Provider</th><th>Descrizione</th><th>Stato</th><th></th></tr></thead><tbody>${providerList.map((provider) => `<tr><td><code>${escapeHtml(provider.provider)}</code></td><td>${escapeHtml(provider.description)}</td><td>${provider.active ? "Attivo" : "Disabilitato"}</td><td><button data-provider="${escapeHtml(provider.provider)}">Gestisci</button></td></tr>`).join("") || '<tr><td colspan="4">Nessun provider censito.</td></tr>'}</tbody></table><h3>Utenti e identit\xE0</h3><table><thead><tr><th>Utente</th><th>Identit\xE0 collegate</th><th></th></tr></thead><tbody>${users.map(({ utente }) => `<tr><td>${escapeHtml(utente.email)}</td><td>${utente.passwordLoginEnabled === false ? "solo SSO" : "password e SSO"}</td><td><button data-sso-user="${utente.codiceUtente}">Gestisci identit\xE0</button></td></tr>`).join("")}</tbody></table>`);
-  byId("new-sso").onclick = () => handleAction(showSsoUserForm);
+  const providerList = result(await getFederatedProviders());
+  render(`<div class="toolbar"><button id="new-provider">Nuovo provider</button><button id="reload-providers" class="secondary">Aggiorna</button></div>
+    <h2>Provider SSO</h2><p class="muted">La validazione di token, issuer e segreti resta nel backend. Un provider si elimina solo se nessuna identit\xE0 \xE8 collegata.</p>
+    <div class="menu-table-wrap"><table><thead><tr><th>Provider</th><th>Descrizione</th><th>Stato</th><th></th></tr></thead><tbody>${providerList.map((provider) => `<tr class="${provider.active ? "" : "is-disabled"}"><td><code>${escapeHtml(provider.provider)}</code></td><td>${escapeHtml(provider.description)}</td><td>${provider.active ? "Attivo" : "Disabilitato"}</td><td class="row-actions"><button data-provider="${escapeHtml(provider.provider)}">Gestisci</button></td></tr>`).join("") || '<tr><td colspan="4" class="muted">Nessun provider censito.</td></tr>'}</tbody></table></div>`);
   byId("new-provider").onclick = () => showProviderForm();
+  byId("reload-providers").onclick = () => handleAction(showSsoProviders);
   document.querySelectorAll("[data-provider]").forEach((button) => {
     button.onclick = () => showProviderForm(providerList.find((provider) => provider.provider === button.dataset.provider));
   });
+}
+async function showSsoUsers() {
+  if (!federatedAuthenticationAvailable) throw new Error("SSO non \xE8 abilitato in questa istanza Accessi.");
+  const users = await loadUsers();
+  render(`<div class="toolbar"><button id="new-sso">Nuovo utente SSO</button><button id="reload-sso-users" class="secondary">Aggiorna</button></div>
+    <h2>Utenti e identit\xE0 SSO</h2><p class="muted">Gestisci i collegamenti provider/subject gi\xE0 verificati dal backend.</p>
+    <div class="menu-table-wrap"><table><thead><tr><th>Utente</th><th>Accesso</th><th></th></tr></thead><tbody>${users.map(({ utente }) => `<tr><td>${escapeHtml(utente.email)}</td><td>${utente.passwordLoginEnabled === false ? "solo SSO" : "password e SSO"}</td><td class="row-actions"><button data-sso-user="${utente.codiceUtente}">Gestisci identit\xE0</button></td></tr>`).join("") || '<tr><td colspan="3" class="muted">Nessun utente.</td></tr>'}</tbody></table></div>`);
+  byId("new-sso").onclick = () => handleAction(showSsoUserForm);
+  byId("reload-sso-users").onclick = () => handleAction(showSsoUsers);
   document.querySelectorAll("[data-sso-user]").forEach((button) => {
     button.onclick = () => handleAction(() => showUser(button.dataset.ssoUser ?? ""));
   });
 }
 function showProviderForm(provider) {
   const isExisting = provider !== void 0;
-  render(`<button id="back" type="button">Indietro</button><div class="page-header"><div><p class="eyebrow">Catalogo SSO</p><h2>${isExisting ? "Gestisci provider" : "Nuovo provider"}</h2></div><span class="muted">Le configurazioni tecniche restano nel backend</span></div><form id="provider-form"><label>Chiave provider<input name="provider" value="${escapeHtml(provider?.provider)}" ${isExisting ? "readonly" : ""} required><span class="form-help">Chiave stabile usata dal backend nel payload SSO. Per Azure includi tenant e ambiente, ad esempio <code>azure-ad-acme-produzione</code>. Non \xE8 modificabile dopo il censimento.</span></label><label>Descrizione<input name="description" value="${escapeHtml(provider?.description)}" required><span class="form-help">Nome leggibile per gli amministratori della console.</span></label><label>Nota<input name="note" value="${escapeHtml(provider?.note)}"><span class="form-help">Annotazione interna. Non inserire segreti, issuer, token o dati personali non necessari.</span></label>${isExisting ? `<label class="check"><input name="active" type="checkbox" ${provider.active ? "checked" : ""}> Provider attivo</label><span class="form-help">Disabilitare il provider blocca nuovi login SSO e nuovi collegamenti, ma conserva lo storico delle identit\xE0.</span>` : ""}<button>${isExisting ? "Salva provider" : "Censisci provider"}</button></form>`);
-  byId("back").onclick = () => show("sso");
+  render(`<button id="back" type="button">Indietro</button><div class="page-header"><div><p class="eyebrow">Catalogo SSO</p><h2>${isExisting ? "Gestisci provider" : "Nuovo provider"}</h2></div><span class="muted">Le configurazioni tecniche restano nel backend</span></div><form id="provider-form"><label>Chiave provider ${helpDot("provider-key")}<input name="provider" value="${escapeHtml(provider?.provider)}" ${isExisting ? "readonly" : ""} required><span class="form-help">Chiave usata dal backend nel payload SSO (es. <code>azure-ad-acme-prod</code>). Non modificabile dopo il censimento.</span></label><label>Descrizione ${helpDot("provider-description")}<input name="description" value="${escapeHtml(provider?.description)}" required><span class="form-help">Nome leggibile per gli amministratori.</span></label><label>Nota ${helpDot("provider-note")}<input name="note" value="${escapeHtml(provider?.note)}"><span class="form-help">Non inserire segreti o dati personali.</span></label>${isExisting ? `<label class="check"><input name="active" type="checkbox" ${provider.active ? "checked" : ""}> Provider attivo ${helpDot("provider-active")}</label><span class="form-help">Blocca nuovi login e collegamenti; lo storico resta.</span>` : ""}<button>${isExisting ? "Salva provider" : "Censisci provider"}</button>${isExisting ? '<button type="button" id="delete-provider" class="danger-button">Elimina provider</button>' : ""}</form>`);
+  byId("back").onclick = () => show("ssoProviders");
+  const deleteProviderButton = document.getElementById("delete-provider");
+  if (deleteProviderButton && provider) {
+    deleteProviderButton.onclick = () => handleAction(async () => {
+      if (!window.confirm(`Eliminare il provider ${provider.provider}? Operazione possibile solo se nessuna identita e collegata.`)) return;
+      await deleteFederatedProvider(provider.provider);
+      showNotice("Provider SSO eliminato.");
+      await show("ssoProviders");
+    });
+  }
   const providerForm = document.getElementById("provider-form");
   if (providerForm) providerForm.onsubmit = (event) => {
     event.preventDefault();
@@ -843,17 +2376,29 @@ function showProviderForm(provider) {
         await updateFederatedProvider(provider.provider, request);
       } else {
         const request = {
-          provider: values.provider,
-          description: values.description,
+          provider: values.provider ?? "",
+          description: values.description ?? "",
           note: values.note || void 0
         };
         await createFederatedProvider(request);
       }
       showNotice(isExisting ? "Provider SSO aggiornato." : "Provider SSO censito.");
-      await show("sso");
+      await show("ssoProviders");
     });
   };
 }
+function registrationStateOptions(current) {
+  const states = [
+    [0, "Non definito"],
+    [5, "Inserito"],
+    [10, "Invitato"],
+    [20, "Confermato"],
+    [50, "Eliminato"],
+    [99, "Bloccato"]
+  ];
+  const currentValue = Number(current);
+  return states.map(([value, label]) => `<option value="${value}" ${currentValue === value ? "selected" : ""}>${label} (${value})</option>`).join("");
+}
 async function showUser(rawCode) {
   const codiceUtente = Number(rawCode);
   const [users, roles, grants, groups, providers] = await Promise.all([
@@ -863,7 +2408,9 @@ async function showUser(rawCode) {
     getGroupsWithMenus({ includeDisabled: true }),
     federatedAuthenticationAvailable ? getFederatedProviders() : Promise.resolve(null)
   ]);
-  const user = result(users)[0].utente;
+  const userRow = result(users)[0];
+  if (!userRow?.utente) throw new Error("Utente non trovato.");
+  const user = userRow.utente;
   const allRoles = result(roles);
   const userGrants = result(grants);
   const menuGroups = result(groups);
@@ -871,9 +2418,9 @@ async function showUser(rawCode) {
   const linked = federatedAuthenticationAvailable ? result(await getFederatedIdentities(codiceUtente)) : [];
   const identitySection = federatedAuthenticationAvailable ? federatedIdentitySection(linked, providerList) : "";
   const defaultUserTab = federatedAuthenticationAvailable ? "sso" : "profile";
-  render(`<div class="user-action-bar"><button id="back" type="button" class="secondary">Indietro</button><button id="disable-user" type="button" class="danger-button">Imposta stato eliminato</button></div><div class="page-header"><div><p class="eyebrow">Utente ${codiceUtente}</p><h2>${escapeHtml(user.email)}</h2></div><span class="muted">Gestione profilo, ruoli e autorizzazioni</span></div>${userDetailTabs(federatedAuthenticationAvailable)}<div class="user-editor">
+  render(`<div class="user-action-bar"><button id="back" type="button" class="secondary">Indietro</button><label class="inline-field">Stato registrazione ${helpDot("user-state")}<select id="user-state">${registrationStateOptions(user.statoRegistrazione)}</select></label><button id="save-state" type="button" class="secondary">Aggiorna stato</button><button id="disable-user" type="button" class="danger-button">Imposta stato eliminato</button>${helpDot("user-delete")}</div><div class="page-header"><div><p class="eyebrow">Utente ${codiceUtente}</p><h2>${escapeHtml(user.email)}</h2></div><span class="muted">Gestione profilo, ruoli e autorizzazioni</span></div>${userDetailTabs(federatedAuthenticationAvailable)}<div class="user-editor">
     ${identitySection}
-    <form id="profile" data-user-panel="profile" role="tabpanel" aria-labelledby="user-tab-profile"><h3>Profilo e accesso</h3><label>Nome<input name="nome" value="${escapeHtml(user.nome)}"></label><label>Cognome<input name="cognome" value="${escapeHtml(user.cognome)}"></label><label>Email<input name="email" type="email" value="${escapeHtml(user.email)}" required><span class="form-help">Identificativo di accesso locale e recapito per le comunicazioni Accessi.</span></label>${federatedAuthenticationAvailable ? `<label class="check"><input name="passwordLoginEnabled" type="checkbox" ${user.passwordLoginEnabled !== false ? "checked" : ""}> Login con password</label><span class="form-help">Se disabilitato, il login con email e password restituisce un errore esplicito; restano valide le identit\xE0 SSO attive.</span>` : ""}${authenticationPolicyFields(user)}<button>Salva</button></form>
+    <form id="profile" data-user-panel="profile" role="tabpanel" aria-labelledby="user-tab-profile"><h3>Profilo e accesso</h3><label>Nome ${helpDot("user-name")}<input name="nome" value="${escapeHtml(user.nome)}"></label><label>Cognome ${helpDot("user-name")}<input name="cognome" value="${escapeHtml(user.cognome)}"></label><label>Email ${helpDot("user-email")}<input name="email" type="email" value="${escapeHtml(user.email)}" required><span class="form-help">Identificativo di accesso e recapito.</span></label>${federatedAuthenticationAvailable ? `<label class="check"><input name="passwordLoginEnabled" type="checkbox" ${user.passwordLoginEnabled !== false ? "checked" : ""}> Login con password ${helpDot("user-password-login")}</label><span class="form-help">Se disabilitato, il login con email e password restituisce un errore esplicito; restano valide le identit\xE0 SSO attive.</span>` : ""}${authenticationPolicyFields(user)}<button>Salva</button></form>
     ${roleAssignmentEditor(allRoles, userGrants.ruoli, menuGroups)}
     ${directGrantEditor(menuGroups, userGrants.abilitazioni)}
     </div>`);
@@ -885,8 +2432,10 @@ async function showUser(rawCode) {
       const targetIndex = event.key === "ArrowRight" ? (index + 1) % userTabButtons.length : event.key === "ArrowLeft" ? (index - 1 + userTabButtons.length) % userTabButtons.length : event.key === "Home" ? 0 : event.key === "End" ? userTabButtons.length - 1 : -1;
       if (targetIndex < 0) return;
       event.preventDefault();
-      userTabButtons[targetIndex].focus();
-      activateUserTab(userTabButtons[targetIndex].dataset.userTab);
+      const targetTab = userTabButtons[targetIndex];
+      if (!targetTab) return;
+      targetTab.focus();
+      activateUserTab(targetTab.dataset.userTab);
     };
   });
   activateUserTab(defaultUserTab);
@@ -905,7 +2454,7 @@ async function showUser(rawCode) {
         const fields = new FormData(eventForm(event));
         await updateUtente(codiceUtente, {
           codiceUtente,
-          email: values.email,
+          email: values.email ?? "",
           nome: values.nome || void 0,
           cognome: values.cognome || void 0,
           flagDueFattori: fields.has("flagDueFattori"),
@@ -953,7 +2502,7 @@ async function showUser(rawCode) {
       event.preventDefault();
       handleAction(async () => {
         const values = formValues(eventForm(event));
-        await linkFederatedIdentity(codiceUtente, { provider: values.provider, subject: values.subject, note: values.note || void 0 });
+        await linkFederatedIdentity(codiceUtente, { provider: values.provider ?? "", subject: values.subject ?? "", note: values.note || void 0 });
         await showUser(String(codiceUtente));
       });
     };
@@ -972,6 +2521,13 @@ async function showUser(rawCode) {
       });
     });
   }
+  byId("save-state").onclick = () => handleAction(async () => {
+    const stateSelect = document.getElementById("user-state");
+    const statoRegistrazione = Number(stateSelect?.value ?? 0);
+    await setStatoRegistrazione({ codiceUtente, statoRegistrazione });
+    showNotice("Stato registrazione aggiornato.");
+    await showUser(String(codiceUtente));
+  });
   byId("disable-user").onclick = () => handleAction(async () => {
     await deleteUser(codiceUtente);
     showNotice("Utente impostato come eliminato.");
@@ -982,16 +2538,14 @@ async function showRoles() {
   const [rolesResponse, groupsResponse] = await Promise.all([getRoles(), getGroupsWithMenus({ includeDisabled: true })]);
   const roles = result(rolesResponse);
   const groups = result(groupsResponse);
-  render(`<div class="toolbar"><button id="new-role">Nuovo ruolo</button></div><h2>Ruoli e grant</h2><p class="form-help">Panoramica completa dei menu inclusi in ogni ruolo. Il livello indica l'abilitazione assegnata dal ruolo per quello specifico menu.</p><div class="role-overview-list">${roles.map((role) => roleOverview(role, groups)).join("") || '<p class="muted">Nessun ruolo configurato.</p>'}</div>`);
+  render(`<div class="toolbar"><button id="new-role">Nuovo ruolo</button></div><h2>Ruoli</h2><p class="form-help">Definisci i ruoli e i menu che concedono. L'assegnazione agli utenti si gestisce dalla scheda utente.</p><div class="role-overview-list">${roles.map((role) => roleOverview(role, groups)).join("") || '<p class="muted">Nessun ruolo configurato.</p>'}</div>`);
   const roleForm = (role) => {
-    render(`<button id="back" type="button">Indietro</button><h2>${role ? "Modifica" : "Nuovo"} ruolo</h2><form id="role-form"><label>Descrizione<input name="descrizione" value="${escapeHtml(role?.descrizioneRuolo)}" required><span class="form-help">Nome mostrato agli amministratori per identificare questo insieme di autorizzazioni.</span></label><p class="form-help">Ogni gruppo presenta una riga per menu. Seleziona i menu da includere e imposta il livello di abilitazione. Il salvataggio sostituisce integralmente la configurazione corrente del ruolo.</p><div class="role-menu-groups">${groups.map((group) => roleMenuEditorTable(group, role)).join("")}</div><button>Salva ruolo</button></form>`);
+    render(`<button id="back" type="button">Indietro</button><h2>${role ? "Modifica" : "Nuovo"} ruolo</h2><form id="role-form"><label>Descrizione ${helpDot("role-description")}<input name="descrizione" value="${escapeHtml(role?.descrizioneRuolo)}" required><span class="form-help">Nome del ruolo.</span></label><p class="form-help">Seleziona i menu e il livello ${helpDot("role-level")}; il salvataggio sostituisce la configurazione del ruolo.</p><div class="role-menu-groups">${groups.map((group) => roleMenuEditorTable(group, role)).join("")}</div><button>Salva ruolo</button></form>`);
     byId("back").onclick = () => show("roles");
     document.querySelectorAll('#role-form input[name="menu"]').forEach((checkbox) => {
       checkbox.onchange = () => {
-        const row = checkbox.closest("tr");
-        const status = checkbox.parentElement?.querySelector("span");
-        const level = row?.querySelector('select[name^="menu-level:"]');
-        if (status) status.textContent = checkbox.checked ? "Incluso" : "Escluso";
+        const option = checkbox.closest("li");
+        const level = option?.querySelector('select[name^="menu-level:"]');
         if (level) level.disabled = !checkbox.checked;
       };
     });
@@ -1000,7 +2554,7 @@ async function showRoles() {
       event.preventDefault();
       const form = eventForm(event);
       const data = new FormData(form);
-      const request = { descrizioneRuolo: formValues(form).descrizione, menu: Array.from(data.getAll("menu"), (codiceMenu) => ({ codiceMenu: String(codiceMenu), tipoAbilitazione: Number(data.get(`menu-level:${codiceMenu}`) ?? 10) })) };
+      const request = { descrizioneRuolo: formValues(form).descrizione ?? "", menu: Array.from(data.getAll("menu"), (codiceMenu) => ({ codiceMenu: String(codiceMenu), tipoAbilitazione: Number(data.get(`menu-level:${codiceMenu}`) ?? 10) })) };
       if (role?.codiceRuolo) await updateRole(role.codiceRuolo, request);
       else await createRole(request);
       await show("roles");
@@ -1008,44 +2562,462 @@ async function showRoles() {
   };
   byId("new-role").onclick = () => roleForm();
   document.querySelectorAll("[data-role]").forEach((button) => button.onclick = () => roleForm(roles.find((role) => role.codiceRuolo === Number(button.dataset.role))));
+  document.querySelectorAll("[data-role-delete]").forEach((button) => button.onclick = () => handleAction(async () => {
+    if (!window.confirm("Eliminare definitivamente questo ruolo? Le assegnazioni agli utenti verranno rimosse.")) return;
+    await deleteRole(Number(button.dataset.roleDelete));
+    showNotice("Ruolo eliminato.");
+    await show("roles");
+  }));
 }
-async function showMenus() {
+function menuGroupsTable(groups) {
+  return `<div class="menu-table-wrap"><table><thead><tr><th>Codice</th><th>Descrizione</th><th>Ordine</th><th>Menu</th><th>Stato</th><th></th></tr></thead><tbody>${groups.map((group) => `<tr class="${group.enabled === false ? "is-disabled" : ""}"><td><code>${escapeHtml(group.codiceGruppo)}</code></td><td><strong>${escapeHtml(group.descrizioneGruppo)}</strong></td><td>${escapeHtml(group.ordineGruppo)}</td><td>${group.menus.length}</td><td><label class="table-toggle"><input type="checkbox" data-group="${escapeHtml(group.codiceGruppo)}" ${group.enabled !== false ? "checked" : ""}><span>${group.enabled === false ? "Disabilitato" : "Abilitato"}</span></label></td><td class="row-actions"><button type="button" data-group-edit="${escapeHtml(group.codiceGruppo)}">Modifica</button><button type="button" class="danger-button" data-group-delete="${escapeHtml(group.codiceGruppo)}">Elimina</button></td></tr>`).join("") || '<tr><td colspan="6" class="muted">Nessun gruppo configurato.</td></tr>'}</tbody></table></div>`;
+}
+function menusTable(entries, menuTypes) {
+  const typeLabel = (codice) => {
+    if (!codice) return "Non indicato";
+    return menuTypes.find((type) => type.codiceTipo === codice)?.descrizioneTipo || codice;
+  };
+  return `<div class="menu-table-wrap"><table><thead><tr><th>Stato</th><th>Menu</th><th>Codice</th><th>Gruppo</th><th>Ordine</th><th>Tipo</th><th>Pagina</th><th></th></tr></thead><tbody>${entries.map(({ menu, group }) => `<tr class="${menu.enabled === false ? "is-disabled" : ""}" data-menu-group="${escapeHtml(group.codiceGruppo)}"><td><label class="table-toggle"><input type="checkbox" data-menu="${escapeHtml(menu.codiceMenu)}" ${menu.enabled !== false ? "checked" : ""}><span>${menu.enabled === false ? "Disabilitato" : "Abilitato"}</span></label></td><td><strong>${escapeHtml(menu.descrizioneMenu)}</strong>${menu.note ? `<br><span class="muted">${escapeHtml(menu.note)}</span>` : ""}</td><td><code>${escapeHtml(menu.codiceMenu)}</code></td><td>${escapeHtml(group.descrizioneGruppo)}</td><td>${escapeHtml(menu.ordineMenu)}</td><td>${escapeHtml(typeLabel(menu.tipo))}</td><td>${menu.pagina ? `<code>${escapeHtml(menu.pagina)}</code>` : '<span class="muted">Non indicata</span>'}</td><td class="row-actions"><button type="button" data-menu-edit="${escapeHtml(menu.codiceMenu)}">Modifica</button><button type="button" class="danger-button" data-menu-delete="${escapeHtml(menu.codiceMenu)}">Elimina</button></td></tr>`).join("") || '<tr><td colspan="8" class="muted">Nessun menu configurato.</td></tr>'}</tbody></table></div>`;
+}
+function menuTypeTable(types) {
+  return `<div class="menu-table-wrap"><table><thead><tr><th>Codice</th><th>Descrizione</th><th></th></tr></thead><tbody>${types.map((type) => `<tr><td><code>${escapeHtml(type.codiceTipo)}</code></td><td>${escapeHtml(type.descrizioneTipo || "\u2014")}</td><td class="row-actions"><button type="button" data-type-edit="${escapeHtml(type.codiceTipo)}">Modifica</button><button type="button" class="danger-button" data-type-delete="${escapeHtml(type.codiceTipo)}">Elimina</button></td></tr>`).join("") || '<tr><td colspan="3" class="muted">Nessun tipo menu.</td></tr>'}</tbody></table></div>`;
+}
+async function showMenuGroups() {
   const groups = result(await getGroupsWithMenus({ includeDisabled: true }));
-  render(`<h2>Menu e gruppi</h2><p class="form-help">Attiva o disattiva gruppi e menu. Ogni riga riporta i dati necessari per individuare l'uso tecnico del menu.</p><div class="menu-group-list">${groups.map(menuGroupTable).join("")}</div>`);
-  document.querySelectorAll("[data-group]").forEach((input) => input.onchange = async () => {
-    await setGroupEnabled(input.dataset.group ?? "", { enabled: input.checked });
-    showNotice("Gruppo aggiornato.");
+  render(`<div class="toolbar"><button id="new-group">Nuovo gruppo</button><button id="reload-groups" class="secondary">Aggiorna</button></div>
+    <h2>Gruppi di menu</h2><p class="form-help">Raggruppano i menu nella navigazione e ne definiscono l'ordine. Un gruppo si elimina solo se non contiene menu.</p>
+    ${menuGroupsTable(groups)}`);
+  byId("new-group").onclick = () => showMenuGroupForm();
+  byId("reload-groups").onclick = () => handleAction(showMenuGroups);
+  document.querySelectorAll("[data-group]").forEach((input) => {
+    input.onchange = () => handleAction(async () => {
+      await setGroupEnabled(input.dataset.group ?? "", { enabled: input.checked });
+      showNotice("Gruppo aggiornato.");
+    });
   });
-  document.querySelectorAll("[data-menu]").forEach((input) => input.onchange = async () => {
-    await setMenuEnabled(input.dataset.menu ?? "", { enabled: input.checked });
-    showNotice("Menu aggiornato.");
+  document.querySelectorAll("[data-group-edit]").forEach((button) => {
+    button.onclick = () => showMenuGroupForm(groups.find((group) => group.codiceGruppo === button.dataset.groupEdit));
+  });
+  document.querySelectorAll("[data-group-delete]").forEach((button) => {
+    button.onclick = () => handleAction(async () => {
+      if (!window.confirm(`Eliminare il gruppo ${button.dataset.groupDelete}? Operazione possibile solo se non contiene menu.`)) return;
+      await deleteMenuGroup(button.dataset.groupDelete ?? "");
+      showNotice("Gruppo eliminato.");
+      await showMenuGroups();
+    });
   });
 }
+async function showMenuItems() {
+  const [groupsResponse, typesResponse] = await Promise.all([
+    getGroupsWithMenus({ includeDisabled: true }),
+    getMenuTypes()
+  ]);
+  const groups = result(groupsResponse);
+  const menuTypes = result(typesResponse);
+  const entries = groups.flatMap((group) => group.menus.map((menu) => ({ menu, group })));
+  render(`<div class="toolbar"><button id="new-menu">Nuovo menu</button><button id="reload-menus" class="secondary">Aggiorna</button><label class="inline-field">Filtra per gruppo<select id="menu-group-filter"><option value="">Tutti i gruppi</option>${groups.map((group) => `<option value="${escapeHtml(group.codiceGruppo)}">${escapeHtml(group.descrizioneGruppo)}</option>`).join("")}</select></label></div>
+    <h2>Menu</h2><p class="form-help">Voci di navigazione. L'eliminazione rimuove anche i grant utente e le associazioni ai ruoli.</p>
+    ${menusTable(entries, menuTypes)}`);
+  byId("new-menu").onclick = () => showMenuForm(void 0, groups, menuTypes);
+  byId("reload-menus").onclick = () => handleAction(showMenuItems);
+  const groupFilter = document.getElementById("menu-group-filter");
+  if (groupFilter) {
+    groupFilter.onchange = () => {
+      const selected = groupFilter.value;
+      document.querySelectorAll("[data-menu-group]").forEach((row) => {
+        row.hidden = selected !== "" && row.dataset.menuGroup !== selected;
+      });
+    };
+  }
+  document.querySelectorAll("[data-menu]").forEach((input) => {
+    input.onchange = () => handleAction(async () => {
+      await setMenuEnabled(input.dataset.menu ?? "", { enabled: input.checked });
+      showNotice("Menu aggiornato.");
+    });
+  });
+  document.querySelectorAll("[data-menu-edit]").forEach((button) => {
+    button.onclick = () => showMenuForm(entries.find((entry) => entry.menu.codiceMenu === button.dataset.menuEdit)?.menu, groups, menuTypes);
+  });
+  document.querySelectorAll("[data-menu-delete]").forEach((button) => {
+    button.onclick = () => handleAction(async () => {
+      if (!window.confirm(`Eliminare il menu ${button.dataset.menuDelete}? Verranno rimossi anche i grant utente e le associazioni ai ruoli.`)) return;
+      await deleteMenu(button.dataset.menuDelete ?? "");
+      showNotice("Menu eliminato.");
+      await showMenuItems();
+    });
+  });
+}
+async function showMenuTypes() {
+  const menuTypes = result(await getMenuTypes());
+  render(`<div class="toolbar"><button id="new-menu-type">Nuovo tipo menu</button><button id="reload-menu-types" class="secondary">Aggiorna</button></div>
+    <h2>Tipi menu</h2><p class="form-help">Classificano i menu (es. amministrazione, operativit\xE0). Un tipo si elimina solo se non \xE8 usato da alcun menu.</p>
+    ${menuTypeTable(menuTypes)}`);
+  byId("new-menu-type").onclick = () => showMenuTypeForm();
+  byId("reload-menu-types").onclick = () => handleAction(showMenuTypes);
+  document.querySelectorAll("[data-type-edit]").forEach((button) => {
+    button.onclick = () => showMenuTypeForm(menuTypes.find((type) => type.codiceTipo === button.dataset.typeEdit));
+  });
+  document.querySelectorAll("[data-type-delete]").forEach((button) => {
+    button.onclick = () => handleAction(async () => {
+      if (!window.confirm(`Eliminare il tipo menu ${button.dataset.typeDelete}? Operazione possibile solo se nessun menu lo utilizza.`)) return;
+      await deleteMenuType(button.dataset.typeDelete ?? "");
+      showNotice("Tipo menu eliminato.");
+      await showMenuTypes();
+    });
+  });
+}
+function showMenuGroupForm(group) {
+  const isExisting = group !== void 0;
+  render(`<button id="back" type="button">Indietro</button><h2>${isExisting ? "Modifica" : "Nuovo"} gruppo menu</h2>
+    <form id="group-form">
+      <label>Codice gruppo ${helpDot("menu-group-code")}<input name="codiceGruppo" maxlength="1" value="${escapeHtml(group?.codiceGruppo)}" ${isExisting ? "readonly" : ""} required><span class="form-help">Un solo carattere, es. <code>A</code>. Immutabile dopo la creazione.</span></label>
+      <label>Descrizione<input name="descrizioneGruppo" maxlength="100" value="${escapeHtml(group?.descrizioneGruppo)}" required></label>
+      <label>Ordine ${helpDot("menu-group-order")}<input name="ordineGruppo" type="number" value="${group?.ordineGruppo ?? ""}"><span class="form-help">Usato per ordinare i gruppi nella navigazione.</span></label>
+      <label class="check"><input name="enabled" type="checkbox" ${group?.enabled !== false ? "checked" : ""}> Gruppo abilitato ${helpDot("menu-group-enabled")}</label>
+      <button>${isExisting ? "Salva gruppo" : "Crea gruppo"}</button>
+    </form>`);
+  byId("back").onclick = () => handleAction(showMenuGroups);
+  const form = document.getElementById("group-form");
+  if (form) {
+    form.onsubmit = (event) => {
+      event.preventDefault();
+      handleAction(async () => {
+        const values = formValues(eventForm(event));
+        const payload = {
+          descrizioneGruppo: values.descrizioneGruppo || void 0,
+          ordineGruppo: values.ordineGruppo ? Number(values.ordineGruppo) : void 0,
+          enabled: new FormData(eventForm(event)).has("enabled")
+        };
+        if (isExisting) await updateMenuGroup(group.codiceGruppo, payload);
+        else await createMenuGroup({ codiceGruppo: values.codiceGruppo ?? "", ...payload });
+        showNotice(isExisting ? "Gruppo aggiornato." : "Gruppo creato.");
+        await showMenuGroups();
+      });
+    };
+  }
+}
+function showMenuForm(menu, groups, menuTypes) {
+  const isExisting = menu !== void 0;
+  const groupOptions = groups.map((group) => `<option value="${escapeHtml(group.codiceGruppo)}" ${menu?.codiceGruppo === group.codiceGruppo ? "selected" : ""}>${escapeHtml(group.codiceGruppo)} \u2013 ${escapeHtml(group.descrizioneGruppo)}</option>`).join("");
+  const typeOptions = `<option value="">Nessun tipo</option>${menuTypes.map((type) => `<option value="${escapeHtml(type.codiceTipo)}" ${menu?.tipo === type.codiceTipo ? "selected" : ""}>${escapeHtml(type.codiceTipo)} \u2013 ${escapeHtml(type.descrizioneTipo || "")}</option>`).join("")}`;
+  render(`<button id="back" type="button">Indietro</button><h2>${isExisting ? "Modifica" : "Nuovo"} menu</h2>
+    <form id="menu-form">
+      <label>Codice menu ${helpDot("menu-code")}<input name="codiceMenu" maxlength="20" value="${escapeHtml(menu?.codiceMenu)}" ${isExisting ? "readonly" : ""} required><span class="form-help">Chiave tecnica, es. <code>MNU001</code>. Immutabile dopo la creazione.</span></label>
+      <label>Descrizione<input name="descrizioneMenu" maxlength="100" value="${escapeHtml(menu?.descrizioneMenu)}" required></label>
+      <label>Gruppo ${helpDot("menu-group-select")}<select name="codiceGruppo" required>${groupOptions}</select><span class="form-help">Crea prima un gruppo se non ne esistono.</span></label>
+      <label>Tipo menu ${helpDot("menu-type-select")}<select name="tipo">${typeOptions}</select></label>
+      <label>Icona ${helpDot("menu-icon")}<input name="icona" maxlength="50" value="${escapeHtml(menu?.icona)}"><span class="form-help">Identificatore icona usato dalla UI host.</span></label>
+      <label>Pagina ${helpDot("menu-page")}<input name="pagina" maxlength="50" value="${escapeHtml(menu?.pagina)}"><span class="form-help">Percorso o pagina associata al menu.</span></label>
+      <label>Ordine ${helpDot("menu-order")}<input name="ordineMenu" type="number" value="${menu?.ordineMenu ?? ""}"></label>
+      <label>Menu di riferimento ${helpDot("menu-rifmenu")}<input name="rifMenu" maxlength="20" value="${escapeHtml(menu?.rifMenu)}"><span class="form-help">Codice di un menu padre, opzionale.</span></label>
+      <label>Nota ${helpDot("menu-note")}<textarea name="note" rows="3" maxlength="1000">${escapeHtml(menu?.note)}</textarea></label>
+      <label class="check"><input name="enabled" type="checkbox" ${menu?.enabled !== false ? "checked" : ""}> Menu abilitato ${helpDot("menu-enabled")}</label>
+      <button>${isExisting ? "Salva menu" : "Crea menu"}</button>
+    </form>`);
+  byId("back").onclick = () => handleAction(showMenuItems);
+  const form = document.getElementById("menu-form");
+  if (form) {
+    form.onsubmit = (event) => {
+      event.preventDefault();
+      handleAction(async () => {
+        const values = formValues(eventForm(event));
+        const payload = {
+          descrizioneMenu: values.descrizioneMenu || void 0,
+          codiceGruppo: values.codiceGruppo ?? "",
+          tipo: values.tipo || void 0,
+          icona: values.icona || void 0,
+          pagina: values.pagina || void 0,
+          ordineMenu: values.ordineMenu ? Number(values.ordineMenu) : void 0,
+          rifMenu: values.rifMenu || void 0,
+          note: values.note || void 0,
+          enabled: new FormData(eventForm(event)).has("enabled")
+        };
+        if (isExisting) await updateMenu(menu.codiceMenu, payload);
+        else await createMenu({ codiceMenu: values.codiceMenu ?? "", ...payload });
+        showNotice(isExisting ? "Menu aggiornato." : "Menu creato.");
+        await showMenuItems();
+      });
+    };
+  }
+}
+function showMenuTypeForm(type) {
+  const isExisting = type !== void 0;
+  render(`<button id="back" type="button">Indietro</button><h2>${isExisting ? "Modifica" : "Nuovo"} tipo menu</h2>
+    <form id="menu-type-form">
+      <label>Codice tipo ${helpDot("menu-type-code")}<input name="codiceTipo" maxlength="1" value="${escapeHtml(type?.codiceTipo)}" ${isExisting ? "readonly" : ""} required><span class="form-help">Un solo carattere, es. <code>A</code>. Immutabile dopo la creazione.</span></label>
+      <label>Descrizione<input name="descrizioneTipo" maxlength="20" value="${escapeHtml(type?.descrizioneTipo)}"></label>
+      <button>${isExisting ? "Salva tipo" : "Crea tipo"}</button>
+    </form>`);
+  byId("back").onclick = () => handleAction(showMenuTypes);
+  const form = document.getElementById("menu-type-form");
+  if (form) {
+    form.onsubmit = (event) => {
+      event.preventDefault();
+      handleAction(async () => {
+        const values = formValues(eventForm(event));
+        if (isExisting) await updateMenuType(type.codiceTipo, { descrizioneTipo: values.descrizioneTipo || void 0 });
+        else await createMenuType({ codiceTipo: values.codiceTipo ?? "", descrizioneTipo: values.descrizioneTipo || void 0 });
+        showNotice(isExisting ? "Tipo menu aggiornato." : "Tipo menu creato.");
+        await showMenuTypes();
+      });
+    };
+  }
+}
+function filterTypeRows(types) {
+  return `<div class="menu-table-wrap"><table><thead><tr><th>Codice</th><th>Descrizione</th><th>Campo</th><th>Abilitato</th><th></th></tr></thead><tbody>${types.map((type) => `<tr class="${type.flgEnabled === 0 ? "is-disabled" : ""}"><td><code>${escapeHtml(type.tipFil)}</code></td><td>${escapeHtml(type.desFil || "\u2014")}</td><td>${escapeHtml(type.fldFil || "\u2014")}</td><td>${type.flgEnabled === 0 ? "No" : "Si"}</td><td class="row-actions"><button type="button" data-filter-type-edit="${escapeHtml(type.tipFil)}">Modifica</button><button type="button" class="danger-button" data-filter-type-delete="${escapeHtml(type.tipFil)}">Elimina</button></td></tr>`).join("") || '<tr><td colspan="5" class="muted">Nessun tipo filtro.</td></tr>'}</tbody></table></div>`;
+}
 async function showFilters() {
   const users = await loadUsers();
-  render(`<h2>Filtri utente</h2><form id="filters"><label>Utente<select name="codUte">${users.map(({ utente }) => `<option value="${utente.codiceUtente}">${escapeHtml(utente.email)}</option>`).join("")}</select><span class="form-help">I filtri vengono letti e salvati esclusivamente per l'utente selezionato.</span></label><label>Filtro JSON<textarea name="json" rows="12">{}</textarea><span class="form-help">Configurazione tecnica del filtro. Usa Carica per partire dalla struttura esistente e mantieni il JSON valido prima di salvare.</span></label><button name="action" value="load">Carica</button><button name="action" value="save">Salva</button></form>`);
+  render(`<h2>Filtri utente</h2><p class="form-help">Filtri applicativi salvati per singolo utente.</p><form id="filters"><label>Utente ${helpDot("filters-user")}<select name="codUte">${users.map(({ utente }) => `<option value="${utente.codiceUtente}">${escapeHtml(utente.email)}</option>`).join("")}</select><span class="form-help">Salvati per l'utente selezionato.</span></label><label>Filtro JSON ${helpDot("filters-json")}<textarea name="json" rows="12">{}</textarea><span class="form-help">Usa Carica per partire dalla struttura esistente.</span></label><button name="action" value="load">Carica</button><button name="action" value="save">Salva</button></form>`);
   const filtersForm = document.getElementById("filters");
   if (filtersForm) filtersForm.onsubmit = async (event) => {
     event.preventDefault();
     const form = eventForm(event);
     const action = event.submitter?.value;
-    const code = Number(formValues(form).codUte);
+    const code3 = Number(formValues(form).codUte);
     if (action === "load") {
-      const filters = result(await getFiltriUtente({ codUte: code }));
-      form.elements.namedItem("json").value = JSON.stringify(filters[0] ?? { codUte: code }, null, 2);
+      const filters = result(await getFiltriUtente({ codUte: code3 }));
+      form.elements.namedItem("json").value = JSON.stringify(filters[0] ?? { codUte: code3 }, null, 2);
     } else {
-      const parsed = JSON.parse(formValues(form).json);
-      await saveFiltriUtente({ ...parsed, codUte: code });
+      const parsed = JSON.parse(formValues(form).json ?? "{}");
+      await saveFiltriUtente({ ...parsed, codUte: code3 });
       showNotice("Filtri salvati.");
     }
   };
 }
+async function showFilterTypes() {
+  const filterTypes = result(await getTipiFiltro());
+  render(`<div class="toolbar"><button id="new-filter-type">Nuovo tipo filtro</button><button id="reload-filter-types" class="secondary">Aggiorna</button></div>
+    <h2>Tipi filtro</h2><p class="form-help">Catalogo dei tipi usati dai filtri utente. Un tipo si elimina solo se nessun filtro lo utilizza.</p>
+    ${filterTypeRows(filterTypes)}`);
+  byId("new-filter-type").onclick = () => showFilterTypeForm();
+  byId("reload-filter-types").onclick = () => handleAction(showFilterTypes);
+  document.querySelectorAll("[data-filter-type-edit]").forEach((button) => button.onclick = () => showFilterTypeForm(filterTypes.find((type) => String(type.tipFil) === button.dataset.filterTypeEdit)));
+  document.querySelectorAll("[data-filter-type-delete]").forEach((button) => button.onclick = () => handleAction(async () => {
+    if (!window.confirm(`Eliminare il tipo filtro ${button.dataset.filterTypeDelete}? Operazione possibile solo se nessun filtro lo utilizza.`)) return;
+    await deleteTipoFiltro(Number(button.dataset.filterTypeDelete));
+    showNotice("Tipo filtro eliminato.");
+    await showFilterTypes();
+  }));
+}
+function showFilterTypeForm(type) {
+  const isExisting = type !== void 0;
+  render(`<button id="back" type="button">Indietro</button><h2>${isExisting ? "Modifica" : "Nuovo"} tipo filtro</h2>
+    <form id="filter-type-form">
+      <label>Codice ${helpDot("filter-type-code")}<input name="tipFil" type="number" value="${escapeHtml(type?.tipFil)}" ${isExisting ? "readonly" : ""} required><span class="form-help">Identificativo numerico. Immutabile dopo la creazione.</span></label>
+      <label>Descrizione<input name="desFil" maxlength="20" value="${escapeHtml(type?.desFil)}"></label>
+      <label>Campo ${helpDot("filter-type-field")}<input name="fldFil" maxlength="20" value="${escapeHtml(type?.fldFil)}"><span class="form-help">Nome del campo applicativo associato al filtro.</span></label>
+      <label class="check"><input name="flgEnabled" type="checkbox" ${type?.flgEnabled !== 0 ? "checked" : ""}> Abilitato ${helpDot("filter-type-enabled")}</label>
+      <button>${isExisting ? "Salva tipo" : "Crea tipo"}</button>
+    </form>`);
+  byId("back").onclick = () => handleAction(showFilterTypes);
+  const form = document.getElementById("filter-type-form");
+  if (form) {
+    form.onsubmit = (event) => {
+      event.preventDefault();
+      handleAction(async () => {
+        const values = formValues(eventForm(event));
+        const payload = {
+          desFil: values.desFil || void 0,
+          fldFil: values.fldFil || void 0,
+          flgEnabled: new FormData(eventForm(event)).has("flgEnabled") ? 1 : 0
+        };
+        if (isExisting) await updateTipoFiltro(type.tipFil, payload);
+        else await createTipoFiltro({ tipFil: Number(values.tipFil), ...payload });
+        showNotice(isExisting ? "Tipo filtro aggiornato." : "Tipo filtro creato.");
+        await showFilterTypes();
+      });
+    };
+  }
+}
+function scopeList(scopes) {
+  return (scopes ?? []).join(", ") || "nessuno";
+}
+function serviceTokenExpiry(token2) {
+  if (!token2.expiresAt) return "nessuna";
+  const date = new Date(token2.expiresAt);
+  const days = Math.ceil((date.getTime() - Date.now()) / 864e5);
+  const label = escapeHtml(date.toLocaleString());
+  if (days < 0) return `${label}<br><span class="error">scaduto</span>`;
+  if (days <= 7) return `${label}<br><span class="error">scade tra ${days} g</span>`;
+  return label;
+}
+function serviceTokenRows(tokens, includeRevoked) {
+  const lastUsed = (token2) => token2.lastUsedAt ? `<span title="${escapeHtml(token2.lastUsedIp ?? "")}">${escapeHtml(new Date(token2.lastUsedAt).toLocaleString())}</span>${token2.lastUsedIp ? `<br><span class="muted">${escapeHtml(token2.lastUsedIp)}</span>` : ""}` : "mai";
+  const status = (token2) => token2.revoked ? `Revocato${token2.revokedBy ? ` da #${escapeHtml(token2.revokedBy)}` : ""}${token2.revokedAt ? `<br><span class="muted">${escapeHtml(new Date(token2.revokedAt).toLocaleString())}</span>` : ""}` : "Attivo";
+  return tokens.map((token2) => `<tr class="${token2.revoked ? "is-disabled" : ""}"><td><strong>${escapeHtml(token2.label)}</strong><br><code>${escapeHtml(token2.tokenId)}</code></td><td>${escapeHtml(scopeList(token2.scopes))}</td><td>${escapeHtml(token2.createdAt ? new Date(token2.createdAt).toLocaleString() : "")}</td><td>${serviceTokenExpiry(token2)}</td><td>${lastUsed(token2)}</td><td>${status(token2)}</td><td>${token2.revoked ? "" : `<button type="button" data-rotate="${escapeHtml(token2.tokenId)}">Ruota</button> <button type="button" class="danger-button" data-revoke="${escapeHtml(token2.tokenId)}">Revoca</button>`}</td></tr>`).join("") || `<tr><td colspan="7">Nessun token ${includeRevoked ? "" : "attivo"}.</td></tr>`;
+}
+async function showServiceTokens(includeRevoked = false) {
+  const tokens = result(await getServiceTokens({ includeRevoked }));
+  render(`<div class="toolbar"><button id="new-token">Nuovo token</button><button id="toggle-revoked" class="secondary">${includeRevoked ? "Nascondi revocati" : "Mostra revocati"}</button></div><h2>Token di servizio</h2><p class="form-help">Credenziali macchina-a-macchina per chiamate tecniche, non legate a un utente. Il segreto e mostrato <strong>una sola volta</strong> alla creazione: conservalo come variabile d'ambiente/secret. Autenticazione: <code>Authorization: Bearer &lt;token&gt;</code>.</p><table><thead><tr><th>Token</th><th>Scope</th><th>Creato</th><th>Scade</th><th>Ultimo uso</th><th>Stato</th><th></th></tr></thead><tbody>${serviceTokenRows(tokens, includeRevoked)}</tbody></table>`);
+  byId("new-token").onclick = () => showServiceTokenForm();
+  byId("toggle-revoked").onclick = () => handleAction(() => showServiceTokens(!includeRevoked));
+  document.querySelectorAll("[data-revoke]").forEach((button) => {
+    button.onclick = () => handleAction(async () => {
+      if (!window.confirm("Revocare definitivamente questo token? Le integrazioni che lo usano smetteranno di funzionare.")) return;
+      await revokeServiceToken(button.dataset.revoke ?? "");
+      showNotice("Token di servizio revocato.");
+      await showServiceTokens(includeRevoked);
+    });
+  });
+  document.querySelectorAll("[data-rotate]").forEach((button) => {
+    button.onclick = () => handleAction(async () => {
+      const issued = result(await rotateServiceToken(button.dataset.rotate ?? ""));
+      showIssuedServiceToken(issued);
+    });
+  });
+}
+function showServiceTokenForm() {
+  render(`<button id="back" type="button" class="secondary">Indietro</button><h2>Nuovo token di servizio</h2><form id="token-form"><label>Descrizione ${helpDot("token-label")}<input name="label" required maxlength="100"><span class="form-help">Identifica l'integrazione, ad esempio "IA - produzione".</span></label><label>Scope ${helpDot("token-scopes")}<input name="scopes" placeholder="ia, chat"><span class="form-help">Separati da virgola (lettere, numeri, ':', '_', '-'). Definiscono cosa pu\xF2 fare il token.</span></label><label>Durata in giorni ${helpDot("token-ttl")}<input name="ttlDays" type="number" min="1" step="1"><span class="form-help">Opzionale. Lascia vuoto per un token senza scadenza.</span></label><button>Crea token</button></form>`);
+  byId("back").onclick = () => void show("tokens");
+  const form = document.getElementById("token-form");
+  if (form) form.onsubmit = (event) => {
+    event.preventDefault();
+    handleAction(async () => {
+      const values = formValues(eventForm(event));
+      const scopes = (values.scopes ?? "").split(",").map((scope) => scope.trim()).filter(Boolean);
+      const ttlDays = values.ttlDays ? Number(values.ttlDays) : void 0;
+      const issued = result(await createServiceToken({
+        label: values.label ?? "",
+        scopes: scopes.length ? scopes : void 0,
+        ttlDays: Number.isFinite(ttlDays) ? ttlDays : void 0
+      }));
+      showIssuedServiceToken(issued);
+    });
+  };
+}
+function showIssuedServiceToken(issued) {
+  render(`<h2>Token creato</h2><p class="form-help">Copia ora il token: <strong>non sara piu mostrato</strong>. Salvalo come variabile d'ambiente/secret del servizio chiamante e non inserirlo nel body delle richieste.</p><div class="token-reveal"><code id="issued-token">${escapeHtml(issued.token)}</code><button id="copy-token" type="button">Copia</button></div><dl class="entity-metadata"><div><dt>Descrizione</dt><dd>${escapeHtml(issued.label)}</dd></div><div><dt>Scope</dt><dd>${escapeHtml(scopeList(issued.scopes))}</dd></div><div><dt>Scade</dt><dd>${issued.expiresAt ? escapeHtml(new Date(issued.expiresAt).toLocaleString()) : "nessuna"}</dd></div></dl><button id="done-token">Ho copiato, chiudi</button>`);
+  byId("copy-token").onclick = () => handleAction(async () => {
+    await navigator.clipboard.writeText(issued.token);
+    showNotice("Token copiato negli appunti.");
+  });
+  byId("done-token").onclick = () => void show("tokens");
+}
+function renderWikiBlock(block) {
+  switch (block.kind) {
+    case "p":
+      return `<p>${escapeHtml(block.text)}</p>`;
+    case "h":
+      return `<h3>${escapeHtml(block.text)}</h3>`;
+    case "list": {
+      const tag = block.ordered ? "ol" : "ul";
+      return `<${tag}>${block.items.map((item) => `<li>${escapeHtml(item)}</li>`).join("")}</${tag}>`;
+    }
+    case "code": {
+      const variant = block.variant ? ` is-${block.variant}` : "";
+      const title = block.title ? `<span class="wiki-code-title">${escapeHtml(block.title)}</span>` : "";
+      return `<figure class="wiki-code${variant}"><figcaption class="wiki-code-head">${title}<span class="wiki-code-lang">${escapeHtml(block.language)}</span><button type="button" class="wiki-copy" data-wiki-copy aria-label="Copia il codice">Copia</button></figcaption><pre><code>${escapeHtml(block.code)}</code></pre></figure>`;
+    }
+    case "callout":
+      return `<div class="wiki-callout is-${block.tone}">${block.title ? `<strong>${escapeHtml(block.title)}</strong>` : ""}<p>${escapeHtml(block.text)}</p></div>`;
+    case "table":
+      return `<div class="wiki-table-wrap"><table><thead><tr>${block.head.map((cell) => `<th>${escapeHtml(cell)}</th>`).join("")}</tr></thead><tbody>${block.rows.map((row) => `<tr>${row.map((cell) => `<td>${escapeHtml(cell)}</td>`).join("")}</tr>`).join("")}</tbody></table></div>`;
+    default:
+      return "";
+  }
+}
+function bindCopyButtons(root) {
+  root.querySelectorAll("[data-wiki-copy]").forEach((button) => {
+    button.onclick = () => handleAction(async () => {
+      const codeEl = button.closest(".wiki-code")?.querySelector("code");
+      await navigator.clipboard.writeText(codeEl?.textContent ?? "");
+      showNotice("Codice copiato negli appunti.");
+    });
+  });
+}
+function helpDot(key) {
+  return `<button type="button" class="help-dot" data-help="${escapeHtml(key)}" aria-label="Aiuto: ${escapeHtml(HELP[key]?.title ?? key)}">i</button>`;
+}
+var helpPopover = null;
+var helpAnchor = null;
+function ensureHelpPopover() {
+  if (!helpPopover) {
+    helpPopover = document.createElement("div");
+    helpPopover.className = "help-popover";
+    helpPopover.hidden = true;
+    helpPopover.setAttribute("role", "dialog");
+    document.body.appendChild(helpPopover);
+  }
+  return helpPopover;
+}
+function closeHelp() {
+  if (helpPopover) helpPopover.hidden = true;
+  helpAnchor = null;
+}
+function positionHelp() {
+  if (!helpPopover || !helpAnchor || helpPopover.hidden) return;
+  const rect = helpAnchor.getBoundingClientRect();
+  const width = helpPopover.offsetWidth;
+  const height = helpPopover.offsetHeight;
+  const left = Math.max(8, Math.min(rect.right - width, window.innerWidth - width - 8));
+  let top = rect.bottom + 6;
+  if (top + height > window.innerHeight - 8) top = Math.max(8, rect.top - height - 6);
+  helpPopover.style.left = `${left}px`;
+  helpPopover.style.top = `${top}px`;
+}
+function openHelp(anchor) {
+  const entry = HELP[anchor.dataset.help ?? ""];
+  if (!entry) return;
+  const popover = ensureHelpPopover();
+  popover.innerHTML = `<div class="help-popover-head"><h4>${escapeHtml(entry.title)}</h4><button type="button" class="help-close" data-help-close aria-label="Chiudi">&times;</button></div><div class="help-popover-body">${entry.blocks.map(renderWikiBlock).join("")}</div>`;
+  popover.hidden = false;
+  helpAnchor = anchor;
+  bindCopyButtons(popover);
+  positionHelp();
+}
+function wikiIndexMarkup(selectedId) {
+  return wikiGroups().map(({ group, sections }) => `<div class="wiki-index-group"><span class="wiki-index-group-title">${escapeHtml(group)}</span><ul>${sections.map((section) => `<li><a href="#wiki-${escapeHtml(section.id)}" data-wiki="${escapeHtml(section.id)}"${section.id === selectedId ? ' aria-current="page"' : ""}>${escapeHtml(section.title)}</a></li>`).join("")}</ul></div>`).join("");
+}
+async function showWiki(sectionId) {
+  const hashId = /^#wiki-([a-z0-9-]+)$/.exec(window.location.hash)?.[1];
+  const requested = sectionId ?? hashId;
+  const selected = WIKI_SECTIONS.find((section) => section.id === requested) ?? WIKI_SECTIONS[0];
+  if (!selected) return;
+  render(`<div class="wiki">
+    <aside class="wiki-index">
+      <div class="wiki-index-head"><strong>Indice</strong><button type="button" id="wiki-copy-ai">Copia per AI</button></div>
+      ${wikiIndexMarkup(selected.id)}
+    </aside>
+    <article class="wiki-content">
+      <header class="wiki-section-head"><h2>${escapeHtml(selected.title)}</h2><p>${escapeHtml(selected.summary)}</p></header>
+      ${selected.blocks.map(renderWikiBlock).join("")}
+    </article>
+  </div>`);
+  document.querySelectorAll("[data-wiki]").forEach((link) => {
+    link.onclick = (event) => {
+      event.preventDefault();
+      const id = link.dataset.wiki ?? "";
+      window.history.replaceState(null, "", `${routePath("wiki")}#wiki-${id}`);
+      showWiki(id);
+    };
+  });
+  bindCopyButtons(document);
+  byId("wiki-copy-ai").onclick = () => handleAction(async () => {
+    await navigator.clipboard.writeText(buildAiDigest());
+    showNotice("Documentazione per AI copiata negli appunti.");
+  });
+}
 async function show(view) {
   try {
     showNotice("");
-    const views = { users: showUsers, roles: showRoles, menus: showMenus, filters: showFilters, sso: showSso };
+    const views = {
+      users: showUsers,
+      roles: showRoles,
+      menuGroups: showMenuGroups,
+      menuItems: showMenuItems,
+      menuTypes: showMenuTypes,
+      filterUser: showFilters,
+      filterTypes: showFilterTypes,
+      ssoProviders: showSsoProviders,
+      ssoUsers: showSsoUsers,
+      tokens: showServiceTokens,
+      wiki: showWiki
+    };
     setActiveNavigation(view);
-    await views[view]();
+    const renderView = views[view];
+    if (!renderView) throw new Error("Sezione console non valida.");
+    await renderView();
   } catch (error) {
     render("");
     showNotice(error instanceof Error ? error.message : "Operazione non riuscita.", true);
@@ -1060,7 +3032,7 @@ byId("two-factor-form").onsubmit = async (event) => {
   try {
     byId("login-error").textContent = "";
     const values = formValues(event.currentTarget);
-    await completeLoginStep(result(await verifyTwoFactor({ challengeId: pendingChallenge, code: values.code })));
+    await completeLoginStep(result(await verifyTwoFactor({ challengeId: pendingChallenge, code: values.code ?? "" })));
   } catch (error) {
     byId("login-error").textContent = error instanceof Error ? error.message : "Verifica non riuscita.";
   }
@@ -1095,11 +3067,35 @@ window.addEventListener("popstate", () => {
 window.addEventListener("accessi-console-network", (event) => {
   updateLoadingState(event.detail.active);
 });
+document.addEventListener("click", (event) => {
+  const target = event.target;
+  const dot = target.closest("[data-help]");
+  if (dot) {
+    event.preventDefault();
+    openHelp(dot);
+    return;
+  }
+  if (target.closest("[data-help-close]")) {
+    closeHelp();
+    return;
+  }
+  if (helpPopover && !helpPopover.hidden && !target.closest(".help-popover")) closeHelp();
+});
+window.addEventListener("keydown", (event) => {
+  if (event.key === "Escape") closeHelp();
+});
+window.addEventListener("resize", positionHelp);
+window.addEventListener("scroll", positionHelp, true);
 var ssoChallenge = /^#two-factor=([a-f0-9]{64})$/.exec(window.location.hash)?.[1];
 if (ssoChallenge) {
   token = null;
   setAccessiConsoleToken(null);
   sessionStorage.removeItem("accessi-console-token");
   window.history.replaceState(null, "", window.location.pathname);
+  finishBoot("login");
   showTwoFactor({ challengeId: ssoChallenge, resendAfterSeconds: 60 });
-} else if (token) void bootstrap();
+} else if (token) {
+  void bootstrap();
+} else {
+  finishBoot("login");
+}