emilsoftware-utilities 2.0.0-dev.4 → 2.0.0-dev.40

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

@@ -0,0 +1,3351 @@
+// src/accessi-module/Console/accessiFetch.ts
+var accessToken = null;
+var loadingEventName = "accessi-console-network";
+function notifyNetworkActivity(active) {
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(new CustomEvent(loadingEventName, { detail: { active } }));
+  }
+}
+function setAccessiConsoleToken(token2) {
+  accessToken = token2;
+}
+async function accessiFetch(url, options) {
+  const headers = new Headers(options.headers);
+  headers.set("Accept", "application/json");
+  if (options.body !== void 0 && !headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json");
+  }
+  if (accessToken) headers.set("Authorization", `Bearer ${accessToken}`);
+  notifyNetworkActivity(true);
+  try {
+    const response = await fetch(url, { ...options, headers });
+    const payload = await response.json().catch(() => void 0);
+    if (!response.ok) {
+      const message = payload?.message ?? payload?.error ?? `Errore HTTP ${response.status}`;
+      throw new Error(message);
+    }
+    return {
+      data: payload,
+      status: response.status,
+      headers: response.headers
+    };
+  } finally {
+    notifyNetworkActivity(false);
+  }
+}
+
+// src/accessi-module/Console/generated/accessiApi.ts
+var getGetUserByTokenUrl = () => {
+  return `/api/accessi/auth/get-user-by-token`;
+};
+var getUserByToken = async (getUserByTokenRequest, options) => {
+  return accessiFetch(
+    getGetUserByTokenUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        getUserByTokenRequest
+      )
+    }
+  );
+};
+var getLoginUrl = () => {
+  return `/api/accessi/auth/login`;
+};
+var login = async (loginRequest, options) => {
+  return accessiFetch(
+    getLoginUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        loginRequest
+      )
+    }
+  );
+};
+var getVerifyTwoFactorUrl = () => {
+  return `/api/accessi/auth/two-factor/verify`;
+};
+var verifyTwoFactor = async (verifyTwoFactorRequest, options) => {
+  return accessiFetch(
+    getVerifyTwoFactorUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        verifyTwoFactorRequest
+      )
+    }
+  );
+};
+var getResendTwoFactorUrl = () => {
+  return `/api/accessi/auth/two-factor/resend`;
+};
+var resendTwoFactor = async (resendTwoFactorRequest, options) => {
+  return accessiFetch(
+    getResendTwoFactorUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        resendTwoFactorRequest
+      )
+    }
+  );
+};
+var getBootstrapAdminUrl = () => {
+  return `/api/accessi/auth/bootstrap-admin`;
+};
+var bootstrapAdmin = async (bootstrapAdminRequest, options) => {
+  return accessiFetch(
+    getBootstrapAdminUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        bootstrapAdminRequest
+      )
+    }
+  );
+};
+var getGetRolesUrl = () => {
+  return `/api/accessi/permission/roles`;
+};
+var getRoles = async (options) => {
+  return accessiFetch(
+    getGetRolesUrl(),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getUpdateRoleUrl = (codiceRuolo) => {
+  return `/api/accessi/permission/update-role/${codiceRuolo}`;
+};
+var updateRole = async (codiceRuolo, role, options) => {
+  return accessiFetch(
+    getUpdateRoleUrl(codiceRuolo),
+    {
+      ...options,
+      method: "PUT",
+      body: JSON.stringify(
+        role
+      )
+    }
+  );
+};
+var getCreateRoleUrl = () => {
+  return `/api/accessi/permission/create-role`;
+};
+var createRole = async (role, options) => {
+  return accessiFetch(
+    getCreateRoleUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        role
+      )
+    }
+  );
+};
+var getAssignRolesToUserUrl = (codiceUtente) => {
+  return `/api/accessi/permission/assign-roles/${codiceUtente}`;
+};
+var assignRolesToUser = async (codiceUtente, assignRolesToUserRequest, options) => {
+  return accessiFetch(
+    getAssignRolesToUserUrl(codiceUtente),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        assignRolesToUserRequest
+      )
+    }
+  );
+};
+var getAssignPermissionsToUserUrl = (codiceUtente) => {
+  return `/api/accessi/permission/assign-permissions/${codiceUtente}`;
+};
+var assignPermissionsToUser = async (codiceUtente, assignPermissionsToUserRequest, options) => {
+  return accessiFetch(
+    getAssignPermissionsToUserUrl(codiceUtente),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        assignPermissionsToUserRequest
+      )
+    }
+  );
+};
+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]) => {
+    if (value === null) {
+      normalizedParams.append(key, "null");
+    } else if (value !== void 0) {
+      normalizedParams.append(key, value.toString());
+    }
+  });
+  return `/api/accessi/permission/groups-with-menus?${normalizedParams.toString()}`;
+};
+var getGroupsWithMenus = async (params, options) => {
+  return accessiFetch(
+    getGetGroupsWithMenusUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+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}`;
+};
+var getUserRolesAndGrants = async (codiceUtente, options) => {
+  return accessiFetch(
+    getGetUserRolesAndGrantsUrl(codiceUtente),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetUsersUrl = (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/user/get-users?${normalizedParams.toString()}`;
+};
+var getUsers = async (params, options) => {
+  return accessiFetch(
+    getGetUsersUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getDeleteUserUrl = (codiceUtente) => {
+  return `/api/accessi/user/delete-user/${codiceUtente}`;
+};
+var deleteUser = async (codiceUtente, options) => {
+  return accessiFetch(
+    getDeleteUserUrl(codiceUtente),
+    {
+      ...options,
+      method: "DELETE"
+    }
+  );
+};
+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`;
+};
+var createManagedUser = async (registerRequest, options) => {
+  return accessiFetch(
+    getCreateManagedUserUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        registerRequest
+      )
+    }
+  );
+};
+var getUpdateUtenteUrl = (codiceUtente) => {
+  return `/api/accessi/user/update-user/${codiceUtente}`;
+};
+var updateUtente = async (codiceUtente, userDto, options) => {
+  return accessiFetch(
+    getUpdateUtenteUrl(codiceUtente),
+    {
+      ...options,
+      method: "PUT",
+      body: JSON.stringify(
+        userDto
+      )
+    }
+  );
+};
+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]) => {
+    if (value === null) {
+      normalizedParams.append(key, "null");
+    } else if (value !== void 0) {
+      normalizedParams.append(key, value.toString());
+    }
+  });
+  return `/api/accessi/filtri/utente?${normalizedParams.toString()}`;
+};
+var getFiltriUtente = async (params, options) => {
+  return accessiFetch(
+    getGetFiltriUtenteUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getSaveFiltriUtenteUrl = () => {
+  return `/api/accessi/filtri/utente`;
+};
+var saveFiltriUtente = async (filtriUtente, options) => {
+  return accessiFetch(
+    getSaveFiltriUtenteUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        filtriUtente
+      )
+    }
+  );
+};
+var getSetMenuEnabledUrl = (codiceMenu) => {
+  return `/api/accessi/configurator/menus/${codiceMenu}/enabled`;
+};
+var setMenuEnabled = async (codiceMenu, updateEnabledStatusRequest, options) => {
+  return accessiFetch(
+    getSetMenuEnabledUrl(codiceMenu),
+    {
+      ...options,
+      method: "PATCH",
+      body: JSON.stringify(
+        updateEnabledStatusRequest
+      )
+    }
+  );
+};
+var getSetGroupEnabledUrl = (codiceGruppo) => {
+  return `/api/accessi/configurator/groups/${codiceGruppo}/enabled`;
+};
+var setGroupEnabled = async (codiceGruppo, updateEnabledStatusRequest, options) => {
+  return accessiFetch(
+    getSetGroupEnabledUrl(codiceGruppo),
+    {
+      ...options,
+      method: "PATCH",
+      body: JSON.stringify(
+        updateEnabledStatusRequest
+      )
+    }
+  );
+};
+var getGetFederatedProvidersUrl = () => {
+  return `/api/accessi/federated-auth/providers`;
+};
+var getFederatedProviders = async (options) => {
+  return accessiFetch(
+    getGetFederatedProvidersUrl(),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getCreateFederatedProviderUrl = () => {
+  return `/api/accessi/federated-auth/providers`;
+};
+var createFederatedProvider = async (createFederatedProviderRequest, options) => {
+  return accessiFetch(
+    getCreateFederatedProviderUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        createFederatedProviderRequest
+      )
+    }
+  );
+};
+var getUpdateFederatedProviderUrl = (provider) => {
+  return `/api/accessi/federated-auth/providers/${provider}`;
+};
+var updateFederatedProvider = async (provider, updateFederatedProviderRequest, options) => {
+  return accessiFetch(
+    getUpdateFederatedProviderUrl(provider),
+    {
+      ...options,
+      method: "PATCH",
+      body: JSON.stringify(
+        updateFederatedProviderRequest
+      )
+    }
+  );
+};
+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`;
+};
+var getFederatedIdentities = async (codiceUtente, options) => {
+  return accessiFetch(
+    getGetFederatedIdentitiesUrl(codiceUtente),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getLinkFederatedIdentityUrl = (codiceUtente) => {
+  return `/api/accessi/federated-auth/users/${codiceUtente}/identities`;
+};
+var linkFederatedIdentity = async (codiceUtente, createFederatedIdentityRequest, options) => {
+  return accessiFetch(
+    getLinkFederatedIdentityUrl(codiceUtente),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        createFederatedIdentityRequest
+      )
+    }
+  );
+};
+var getCreateFederatedUserUrl = () => {
+  return `/api/accessi/federated-auth/users`;
+};
+var createFederatedUser = async (createFederatedUserRequest, options) => {
+  return accessiFetch(
+    getCreateFederatedUserUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        createFederatedUserRequest
+      )
+    }
+  );
+};
+var getUpdateFederatedIdentityUrl = (identityKey) => {
+  return `/api/accessi/federated-auth/identities/${identityKey}`;
+};
+var updateFederatedIdentity = async (identityKey, updateFederatedIdentityRequest, options) => {
+  return accessiFetch(
+    getUpdateFederatedIdentityUrl(identityKey),
+    {
+      ...options,
+      method: "PATCH",
+      body: JSON.stringify(
+        updateFederatedIdentityRequest
+      )
+    }
+  );
+};
+var getDeleteFederatedIdentityPermanentlyUrl = (codiceUtente, identityKey) => {
+  return `/api/accessi/federated-auth/users/${codiceUtente}/identities/${identityKey}`;
+};
+var deleteFederatedIdentityPermanently = async (codiceUtente, identityKey, options) => {
+  return accessiFetch(
+    getDeleteFederatedIdentityPermanentlyUrl(codiceUtente, identityKey),
+    {
+      ...options,
+      method: "DELETE"
+    }
+  );
+};
+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"
+    }
+  );
+};
+var getGetSchemaUrl = () => {
+  return `/api/accessi/schema`;
+};
+var getSchema = async (options) => {
+  return accessiFetch(
+    getGetSchemaUrl(),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+
+// 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."],
+          ["catalogScripts", "{ enabled, folder, ... }", "no", "Catalog migrations SQL eseguite dopo la riconciliazione dello schema."],
+          ["adminBootstrap", "{ enabled, superUser }", "no", "Token casuale a ogni avvio per creare il primo admin dalla console."],
+          ["publicBaseUrl", "string", "no", "Base URL usata solo per loggare console/swagger/API."]
+        ]
+      ),
+      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, ACCESSI_CATALOG_SCRIPT`
+      ]),
+      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: "catalog-migrations",
+    group: "Configurazione",
+    title: "Catalog migrations SQL",
+    summary: "Allinea menu, ruoli e cataloghi su piu database in modo idempotente.",
+    blocks: [
+      p(`Gli script SQL applicativi (menu, ruoli, tipi, cataloghi) restano nel repository del backend ospitante e Accessi li esegue dopo la riconciliazione dello schema. Ogni script viene tracciato nella tabella ACCESSI_CATALOG_SCRIPT (nome + checksum), quindi viene applicato una sola volta per database.`),
+      h(`Configurazione`),
+      good("ts", [
+        "catalogScripts: {",
+        "  enabled: true,",
+        "  folder: './db/accessi-catalog', // versionata nel repo del backend",
+        "  onChecksumMismatch: 'error',     // 'error' (default) | 'warn' | 'reapply'",
+        "  stopOnError: true,",
+        "}"
+      ].join("\n"), "AccessiOptions"),
+      list([
+        "Gli script sono ordinati per percorso (usa prefissi numerici: 0001_, 0002_, ...).",
+        "Devono essere idempotenti e ripetibili: UPDATE OR INSERT ... MATCHING, MERGE, DELETE+INSERT mirati.",
+        "Non includere utenti: le catalog migrations allineano solo catalogo e configurazione.",
+        "Supportati stringhe, commenti e statement multipli; SET TERM non serve perch\xE9 gli script sono solo DML."
+      ]),
+      note("danger", `Solo righe (DML)`, `Vincolo tassativo: uno script puo eseguire solo INSERT, UPDATE, DELETE, MERGE, SELECT, EXECUTE. Qualunque DDL (CREATE/ALTER/DROP, trigger, procedure, GRANT, transazioni) viene rifiutato. Lo schema si aggiorna solo con db:update:accessi.`),
+      note("info", `File non conformi`, `Un file con statement non consentiti non viene applicato ne registrato nel ledger; il run prosegue con gli altri e il report riporta una voce per ogni file con i relativi messaggi di errore (visibili anche con db:catalog:accessi:check).`),
+      note("info", `allowDdl`, `Disattivato di default. Impostarlo a true disabilita la validazione e permette DDL: usarlo solo consapevolmente e mai come sostituto dell'updater dello schema.`),
+      code("bash", `# Applica (schema + catalog migrations) su un database
+ACCESSI_CATALOG_FOLDER=./db/accessi-catalog npm run db:catalog:accessi
+
+# Elenca solo quelle da applicare / modificate
+ACCESSI_CATALOG_FOLDER=./db/accessi-catalog npm run db:catalog:accessi:check`, "CLI catalog migrations"),
+      note("info", `Idempotenza`, `Uno script gia applicato con lo stesso checksum viene saltato. Se il file cambia dopo l'applicazione, con policy error il run si interrompe: non modificare uno script applicato, aggiungine uno nuovo.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    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 di dominio`, `UTENTI_CONFIG contiene i campi di dominio Accessi: FLGSUPER, FLGADMIN, FLG2FATT (2FA), FLGPWDLESS (passwordless), FLGPASSWORD (login locale), CODLINGUA, CELLULARE, PAGDEF (pagina di default) e JSON_METADATA. I flag/colonne applicativi (FLGMOP, FLGPIANA, FLGADDETTI, FLGOSPITI, FLGPIANARFID, FLGCONTA, FLGCUBI, FLGCICLPASS, FLGDIPENDENTI, FLGINVENTARI, CAUMOV, NUMMAC, RAGSOCCLI, ENABLEIA, CELLUTE e NOMECAMPO) sono stati rimossi: i backend devono gestirli in tabelle proprie. Il telefono canonico e UTENTI_CONFIG.CELLULARE.`),
+      note("info", `Autorizzazioni`, `I gruppi/menu si abilitano tramite ABILITAZIONI, RUOLI_MNU e UTENTI_RUOLI. Il vecchio meccanismo NOMECAMPO (flag applicativo su UTENTI_CONFIG) e stato rimosso.`),
+      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. 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.`,
+        `Wiki e Changelog: documentazione e novit\xE0 della libreria.`,
+        `SQL: esporta il DDL delle entit\xE0 Accessi (tabelle, generatori, FK, indici, check, trigger) per replicare il database.`
+      ]),
+      note("info", `Superutente (FLGSUPER)`, `Riceve TUTTE le abilitazioni al livello massimo (30) dopo il login. In console vede solo la sezione Utenti e gestisce utenti, ruoli e grant.`),
+      note("info", `Admin (FLGADMIN)`, `Accede a tutta la console (catalogo, token, SSO, utenti) ma NON conferisce abilitazioni: i menu restano quelli assegnati via ABILITAZIONI/RUOLI_MNU.`),
+      note("info", `Accesso`, `Apri /api/accessi/console e accedi con un utente con FLGSUPER o FLGADMIN. Le sezioni sono raggiungibili anche tramite deep link (per esempio /api/accessi/console/menu-e-gruppi/menu).`),
+      note("info", `Bootstrap admin`, `Con adminBootstrap.enabled il backend stampa a ogni avvio un token casuale (monouso, valido fino al riavvio). Nella schermata di login della console trovi "Crea utente admin": incolla il token e crea il primo admin senza email di conferma. La password \xE8 opzionale: se assente viene generata e mostrata una sola volta.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    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"],
+          ["Schema", "GET schema (DDL completo + entit\xE0 presenti, solo admin)"],
+          ["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/changelog.md
+var changelog_default = "# Changelog Accessi\n\nNovit\xE0 e modifiche rilevanti della libreria `emilsoftware-utilities` (modulo Accessi).\n\n## 2.0.0-dev.33\n\n### Cambiamenti\n- Rimosse le logiche applicative residue dallo schema Accessi:\n  - `MENU_GRP.NOMECAMPO`\n  - `UTENTI.ENABLEIA`\n  - `UTENTI_CONFIG.PAGDEF`\n  - `UTENTI.CELLUTE`\n- Telefono canonico: `UTENTI_CONFIG.CELLULARE` (allargato a `VARCHAR(30)`).\n- Migrazione automatica: copia `UTENTI.CELLUTE` \u2192 `UTENTI_CONFIG.CELLULARE`, poi `DROP` delle colonne obsolete.\n- Ruoli chiariti:\n  - `FLGSUPER`: superutente, riceve **tutte** le abilitazioni al livello massimo (30) dopo il login; in console vede **solo** la sezione **Utenti**.\n  - `FLGADMIN`: accede a **tutta** la console (catalogo, token, SSO, utenti) ma **non** influisce sulle abilitazioni.\n- Aggiunta la sezione **Changelog** in console (sotto la Wiki).\n\n### Note\n- `FILTRI` e `FILTRI_TIPO` restano invariati (piano di migrazione futuro).\n- I backend che usavano i campi rimossi devono gestirli in tabelle proprie.\n\n## 2.0.0-dev.32\n\n### Cambiamenti\n- Rimosso il supporto ai flag applicativi in `UTENTI_CONFIG`: `FLGMOP`, `FLGPIANA`, `FLGADDETTI`, `FLGOSPITI`, `FLGPIANARFID`, `FLGCONTA`, `FLGCUBI`, `FLGCICLPASS`, `FLGDIPENDENTI`, `FLGINVENTARI`, `CAUMOV`, `NUMMAC`, `RAGSOCCLI`.\n- Rinominata la colonna `FLGADMINCONFIG` in `FLGADMIN` (con copia dei valori e `DROP`).\n\n## 2.0.0-dev.31\n\n### Aggiunte\n- Esposizione dei servizi Accessi all'host Express (`getAccessiModuleServices`) per delegare login, SSO e token senza reimplementarli.\n\n### Correzioni\n- `UserService.getUsers`: filtri estesi (`codiceUtente[]`, `numRep[]`, `codDipendente`, `cellulare`, `tipFil`, `flagSuper`).\n\n## 2.0.0-dev.24\n\n### Cambiamenti (breaking)\n- Chiavi JWT derivate per scopo (`access`, `reset`, `2fa`) e claim `typ` obbligatorio: gli access token precedenti non sono pi\xF9 validi.\n- Endpoint Allegati protetti di default.\n- Pool di connessioni attivo di default (`poolSize` 5).\n\n### Aggiunte\n- Service token macchina-a-macchina (gestione, guard, console).\n- CRUD completo dei cataloghi dalla console Accessi.\n- Supporto Firebird 2.5 nel migrator e nei test di integrazione.\n";
+
+// 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-default-page": {
+    title: "Pagina di default",
+    blocks: [
+      p2(`Percorso o codice della pagina verso cui indirizzare l'utente dopo il login. Esempio: /dashboard oppure la chiave di una pagina gestita dal frontend.`),
+      p2(`E una stringa libera (massimo 50 caratteri): la libreria la conserva e la restituisce nel profilo; l'instradamento effettivo lo decide il frontend.`)
+    ]
+  },
+  "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",
+  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",
+  changelog: "changelog",
+  sql: "sql"
+};
+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;
+var loaderVisibleSince = 0;
+var byId = (id) => document.getElementById(id);
+var escapeHtml = (value) => String(value ?? "").replace(/[&<>"']/g, (char) => ({
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+})[char]);
+function result(response) {
+  const body = response.data;
+  if (body.Result === void 0) throw new Error(body.message ?? "Risposta Accessi priva di dati.");
+  return body.Result;
+}
+function showNotice(message, isError = false) {
+  byId("notice").innerHTML = message ? `<span class="${isError ? "error" : ""}">${escapeHtml(message)}</span>` : "";
+}
+function menuMetadata(menu) {
+  const details = [
+    ["Codice", menu.codiceMenu],
+    ["Ordine", String(menu.ordineMenu)],
+    ["Tipo", menu.tipo],
+    ["Pagina", menu.pagina],
+    ["Icona", menu.icona],
+    ["Stato", menu.enabled === false ? "Disabilitato" : "Abilitato"]
+  ].filter(([, value]) => value);
+  return `<dl class="entity-metadata">${details.map(([label, value]) => `<div><dt>${escapeHtml(label)}</dt><dd>${escapeHtml(value)}</dd></div>`).join("")}</dl>${menu.note ? `<p class="entity-note"><strong>Nota</strong>${escapeHtml(menu.note)}</p>` : ""}`;
+}
+function permissionSelectOptions(currentLevel) {
+  return `<option value="10" ${currentLevel === 10 ? "selected" : ""}>Lettura</option><option value="20" ${currentLevel === 20 ? "selected" : ""}>Scrittura</option>${currentLevel === 30 ? '<option value="30" selected>Valore legacy (30)</option>' : ""}`;
+}
+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 ${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 ${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) {
+  return value === 10 ? "Lettura" : value === 20 ? "Scrittura" : value === 30 ? "Valore legacy (30)" : `Livello ${value ?? "non definito"}`;
+}
+function rolePermissionLevel(value) {
+  return value === void 0 || value === null || value === "" ? permissionLevelLabel(void 0) : permissionLevelLabel(Number(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 ${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);
+    const missingMenus = roleMenus.filter((item) => !catalogMenus.has(item.codiceMenu));
+    return `<article class="role-assignment-card"><div class="role-assignment-heading"><label class="check"><input type="checkbox" name="role" value="${escapeHtml(role.codiceRuolo)}" ${assigned ? "checked" : ""}><span><strong>${escapeHtml(role.descrizioneRuolo)}</strong><small>Codice ruolo: ${escapeHtml(role.codiceRuolo)}</small></span></label><span class="role-menu-count">${roleMenus.length} menu</span></div><div class="role-permission-groups">${groupedMenus.map(({ group, entries }) => `<section class="role-permission-group"><div class="role-permission-group-heading"><strong>${escapeHtml(group.descrizioneGruppo)}</strong>${groupMetadata(group)}</div>${entries.map(({ menu, assignment }) => `<div class="role-permission-entry ${menu.enabled === false ? "is-disabled" : ""}"><div><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\xC3\xB9 presenti nel catalogo</strong>${missingMenus.map((menu) => `<div class="role-permission-entry"><div><strong>${escapeHtml(menu.codiceMenu)}</strong><p class="entity-note">Il menu \xC3\xA8 ancora associato al ruolo ma non \xC3\xA8 disponibile nel catalogo corrente.</p></div><span class="permission-level">${escapeHtml(rolePermissionLevel(menu.tipoAbilitazione))}</span></div>`).join("")}</section>` : ""}</div></article>`;
+  }).join("")}</div><button>Salva ruoli</button></form>`;
+}
+function roleOverview(role, groups) {
+  const roleMenus = role.menu ?? [];
+  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\xC3\xB9 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 ?? [];
+  const options = group.menus.map((menu) => {
+    const assignment = roleMenus.find((item) => item.codiceMenu === menu.codiceMenu);
+    const level = assignment?.tipoAbilitazione ?? 10;
+    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) {
+      window.clearTimeout(loadingHideTimer);
+      loadingHideTimer = void 0;
+    }
+    if (loadingRevealTimer === void 0 && overlay.hidden) {
+      loadingRevealTimer = window.setTimeout(() => {
+        loadingRevealTimer = void 0;
+        if (pendingNetworkRequests > 0) {
+          overlay.hidden = false;
+          loaderVisibleSince = Date.now();
+          byId("app").setAttribute("aria-busy", "true");
+        }
+      }, 140);
+    }
+    return;
+  }
+  if (loadingRevealTimer !== void 0) {
+    window.clearTimeout(loadingRevealTimer);
+    loadingRevealTimer = void 0;
+  }
+  const hide = () => {
+    loadingHideTimer = void 0;
+    overlay.hidden = true;
+    byId("app").removeAttribute("aria-busy");
+  };
+  const remainingVisibleMs = 280 - (Date.now() - loaderVisibleSince);
+  if (!overlay.hidden && remainingVisibleMs > 0) {
+    loadingHideTimer = window.setTimeout(hide, remainingVisibleMs);
+  } else {
+    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.";
+}
+function handleAction(action) {
+  void action().catch((error) => showNotice(errorMessage(error), true));
+}
+function render(markup) {
+  closeHelp(false);
+  byId("view").innerHTML = markup;
+}
+function setActiveNavigation(view) {
+  document.querySelectorAll("#nav [data-view]").forEach((link) => {
+    if (link.dataset.view === view) {
+      link.setAttribute("aria-current", "page");
+    } else {
+      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, "");
+  const decoded = decodeURIComponent(relativePath);
+  return routeView[decoded] ?? parentDefaultView[decoded] ?? "users";
+}
+async function navigate(view, replace = false) {
+  if (!isViewAllowed(view)) {
+    view = "users";
+    replace = true;
+  }
+  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 requireConsoleAccess() {
+  if (!currentUser?.flagSuper && !currentUser?.flagAdmin) {
+    throw new Error("La console richiede un superutente o un admin Accessi.");
+  }
+}
+function isViewAllowed(view) {
+  if (!currentUser) return false;
+  if (currentUser.flagAdmin) return true;
+  return view === "users";
+}
+function applyRoleNavigation() {
+  document.querySelectorAll("#nav [data-view]").forEach((link) => {
+    const view = link.dataset.view;
+    const item = link.closest("li") ?? link;
+    item.hidden = !isViewAllowed(view);
+  });
+  document.querySelectorAll("#nav details[data-nav-group]").forEach((branch) => {
+    const hasVisible = Array.from(branch.querySelectorAll("[data-view]")).some((link) => !link.closest("li").hidden);
+    branch.hidden = !hasVisible;
+  });
+}
+function formValues(form) {
+  return Object.fromEntries(new FormData(form).entries());
+}
+function eventForm(event) {
+  return event.currentTarget;
+}
+function federatedIdentityFields(providers) {
+  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\xC3\xA0 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 = [
+    ...hasSso ? [{ id: "sso", label: "Identit\xC3\xA0 SSO" }] : [],
+    { id: "profile", label: "Profilo e accesso" },
+    { id: "roles", label: "Ruoli" },
+    { id: "grants", label: "Grant diretti" }
+  ];
+  return `<div class="user-tabs" role="tablist" aria-label="Sezioni utente">${tabs.map((tab) => `<button id="user-tab-${tab.id}" type="button" role="tab" aria-controls="user-panel-${tab.id}" data-user-tab="${tab.id}">${tab.label}</button>`).join("")}</div>`;
+}
+function activateUserTab(tab) {
+  document.querySelectorAll("[data-user-tab]").forEach((button) => {
+    const selected = button.dataset.userTab === tab;
+    button.setAttribute("aria-selected", String(selected));
+    button.tabIndex = selected ? 0 : -1;
+  });
+  document.querySelectorAll("[data-user-panel]").forEach((panel) => {
+    const selected = panel.dataset.userPanel === tab;
+    panel.hidden = !selected;
+    if (!panel.id) panel.id = `user-panel-${panel.dataset.userPanel}`;
+    document.querySelector(`[data-user-tab="${panel.dataset.userPanel}"]`)?.setAttribute("aria-controls", panel.id);
+  });
+}
+function selectedNumbers(form, name) {
+  return Array.from(new FormData(form).getAll(name), (value) => Number(value));
+}
+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 ? ` \xC2\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 {
+    await getFederatedIdentities(currentUser.codiceUtente);
+    federatedAuthenticationAvailable = true;
+  } catch {
+    federatedAuthenticationAvailable = false;
+  }
+}
+async function loginView(event) {
+  event.preventDefault();
+  try {
+    const values = formValues(event.currentTarget);
+    byId("login-error").textContent = "";
+    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.";
+  }
+}
+var pendingChallenge = null;
+var resendTimer;
+function resetLogin() {
+  pendingChallenge = null;
+  if (resendTimer) clearInterval(resendTimer);
+  byId("login-form").reset();
+  byId("two-factor-form").reset();
+  byId("login-form").hidden = false;
+  byId("two-factor-form").hidden = true;
+  byId("password-field").hidden = true;
+  byId("password-field").querySelector("input").disabled = true;
+  byId("restart-login").hidden = true;
+  byId("login-submit").textContent = "Continua";
+  byId("login-error").textContent = "";
+}
+function showTwoFactor(challenge) {
+  pendingChallenge = challenge.challengeId;
+  byId("login-form").hidden = true;
+  const password = byId("password-field").querySelector("input");
+  password.value = "";
+  password.disabled = true;
+  byId("two-factor-form").hidden = false;
+  byId("restart-login").hidden = false;
+  byId("two-factor-form").reset();
+  byId("two-factor-form").querySelector("input").focus();
+  const expires = challenge.expiresAt ? new Date(challenge.expiresAt).toLocaleTimeString() : "";
+  byId("two-factor-status").textContent = expires ? `Codice inviato. Scade alle ${expires}.` : "Codice inviato. Controlla la tua email.";
+  if (resendTimer) clearInterval(resendTimer);
+  const availableAt = Date.now() + challenge.resendAfterSeconds * 1e3;
+  const update = () => {
+    const seconds = Math.max(0, Math.ceil((availableAt - Date.now()) / 1e3));
+    const button = byId("resend-code");
+    button.disabled = seconds > 0;
+    button.textContent = seconds ? `Reinvia tra ${seconds}s` : "Invia un nuovo codice";
+    if (!seconds && resendTimer) clearInterval(resendTimer);
+  };
+  update();
+  resendTimer = setInterval(update, 1e3);
+}
+async function completeLoginStep(response) {
+  if (response.challenge) {
+    showTwoFactor(response.challenge);
+    return;
+  }
+  if (response.passwordRequired) {
+    byId("password-field").hidden = false;
+    const input = byId("password-field").querySelector("input");
+    input.disabled = false;
+    input.required = true;
+    input.focus();
+    byId("restart-login").hidden = false;
+    byId("login-submit").textContent = "Accedi";
+    return;
+  }
+  if (!response.token?.value) throw new Error("Risposta di autenticazione incompleta.");
+  token = response.token.value;
+  sessionStorage.setItem("accessi-console-token", token);
+  setAccessiConsoleToken(token);
+  resetLogin();
+  await bootstrap();
+}
+async function bootstrap() {
+  try {
+    setAccessiConsoleToken(token);
+    if (!token) throw new Error("Inserisci le credenziali amministrative.");
+    const payload = result(await getUserByToken({ token }));
+    currentUser = payload.userData;
+    requireConsoleAccess();
+    applyRoleNavigation();
+    await detectFederatedAuthentication();
+    const roleLabel = currentUser.flagSuper && currentUser.flagAdmin ? "super + admin" : currentUser.flagAdmin ? "admin" : "superutente";
+    byId("who").textContent = `${currentUser.email} - ${roleLabel}`;
+    byId("sso-navigation").hidden = !federatedAuthenticationAvailable;
+    finishBoot("console");
+    await navigate(viewFromLocation(), window.location.pathname === consoleBasePath);
+  } catch (error) {
+    token = null;
+    currentUser = null;
+    setAccessiConsoleToken(null);
+    federatedAuthenticationAvailable = false;
+    sessionStorage.removeItem("accessi-console-token");
+    finishBoot("login");
+    byId("login-error").textContent = error instanceof Error ? error.message : "Sessione non valida.";
+  }
+}
+async function showUsers() {
+  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>
+    <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) ${helpDot("user-2fa")}</label>
+    <p class="form-help">Se attiva, il codice \xC3\xA8 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 ${helpDot("user-email")}<input name="email" type="email" required><span class="form-help">Identificativo di accesso; ricever\xC3\xA0 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) => {
+    event.preventDefault();
+    handleAction(async () => {
+      await createManagedUser(formValues(eventForm(event)));
+      showNotice("Utente creato; inviata la procedura di impostazione password.");
+      await show("users");
+    });
+  };
+}
+async function showSsoUserForm() {
+  const providers = result(await getFederatedProviders());
+  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">Salva solo collegamenti gi\xC3\xA0 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();
+    handleAction(async () => {
+      const form = eventForm(event);
+      const values = formValues(form);
+      const request = {
+        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 }
+      };
+      await createFederatedUser(request);
+      showNotice("Utente SSO creato e collegamento registrato.");
+      await show("ssoUsers");
+    });
+  };
+}
+async function showSsoProviders() {
+  if (!federatedAuthenticationAvailable) throw new Error("SSO non \xC3\xA8 abilitato in questa istanza Accessi.");
+  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\xC3\xA0 \xC3\xA8 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 \xC3\xA8 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\xC3\xA0 SSO</h2><p class="muted">Gestisci i collegamenti provider/subject gi\xC3\xA0 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\xC3\xA0</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 ${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();
+    handleAction(async () => {
+      const form = eventForm(event);
+      const values = formValues(form);
+      if (provider) {
+        const request = {
+          description: values.description,
+          note: values.note || void 0,
+          active: new FormData(form).has("active")
+        };
+        await updateFederatedProvider(provider.provider, request);
+      } else {
+        const request = {
+          provider: values.provider ?? "",
+          description: values.description ?? "",
+          note: values.note || void 0
+        };
+        await createFederatedProvider(request);
+      }
+      showNotice(isExisting ? "Provider SSO aggiornato." : "Provider SSO censito.");
+      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([
+    getUsers({ codiceUtente, includeGrants: true }),
+    getRoles(),
+    getUserRolesAndGrants(codiceUtente),
+    getGroupsWithMenus({ includeDisabled: true }),
+    federatedAuthenticationAvailable ? getFederatedProviders() : Promise.resolve(null)
+  ]);
+  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);
+  const providerList = providers ? result(providers) : [];
+  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><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 ${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><label>Pagina di default ${helpDot("user-default-page")}<input name="paginaDefault" maxlength="50" value="${escapeHtml(user.paginaDefault)}"><span class="form-help">Pagina mostrata dopo il login (percorso o codice pagina).</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\xC3\xA0 SSO attive.</span>` : ""}${authenticationPolicyFields(user)}<button>Salva</button></form>
+    ${roleAssignmentEditor(allRoles, userGrants.ruoli, menuGroups)}
+    ${directGrantEditor(menuGroups, userGrants.abilitazioni)}
+    </div>`);
+  byId("back").onclick = () => show("users");
+  const userTabButtons = Array.from(document.querySelectorAll("[data-user-tab]"));
+  userTabButtons.forEach((button, index) => {
+    button.onclick = () => activateUserTab(button.dataset.userTab);
+    button.onkeydown = (event) => {
+      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();
+      const targetTab = userTabButtons[targetIndex];
+      if (!targetTab) return;
+      targetTab.focus();
+      activateUserTab(targetTab.dataset.userTab);
+    };
+  });
+  activateUserTab(defaultUserTab);
+  const profileForm = document.getElementById("profile");
+  if (profileForm) {
+    const twoFactor = profileForm.elements.namedItem("flagDueFattori");
+    const passwordless = profileForm.elements.namedItem("passwordlessLoginEnabled");
+    twoFactor.onchange = () => {
+      passwordless.disabled = !twoFactor.checked;
+      if (!twoFactor.checked) passwordless.checked = false;
+    };
+    profileForm.onsubmit = (event) => {
+      event.preventDefault();
+      handleAction(async () => {
+        const values = formValues(eventForm(event));
+        const fields = new FormData(eventForm(event));
+        await updateUtente(codiceUtente, {
+          codiceUtente,
+          email: values.email ?? "",
+          nome: values.nome || void 0,
+          cognome: values.cognome || void 0,
+          paginaDefault: values.paginaDefault || void 0,
+          flagDueFattori: fields.has("flagDueFattori"),
+          passwordlessLoginEnabled: fields.has("passwordlessLoginEnabled"),
+          ...federatedAuthenticationAvailable ? { passwordLoginEnabled: fields.has("passwordLoginEnabled") } : {}
+        });
+        if (codiceUtente === currentUser?.codiceUtente && (fields.has("flagDueFattori") !== Boolean(user.flagDueFattori) || fields.has("passwordlessLoginEnabled") !== Boolean(user.passwordlessLoginEnabled))) {
+          token = null;
+          sessionStorage.removeItem("accessi-console-token");
+          setAccessiConsoleToken(null);
+          resetLogin();
+          await bootstrap();
+          byId("login-error").textContent = "Policy aggiornata. Accedi di nuovo con la nuova configurazione.";
+          return;
+        }
+        await showUser(String(codiceUtente));
+        activateUserTab("profile");
+        showNotice("Profilo e policy aggiornati.");
+      });
+    };
+  }
+  const rolesForm = document.getElementById("roles");
+  if (rolesForm) rolesForm.onsubmit = (event) => {
+    event.preventDefault();
+    handleAction(async () => {
+      await assignRolesToUser(codiceUtente, { roles: selectedNumbers(eventForm(event), "role") });
+      showNotice("Ruoli aggiornati.");
+    });
+  };
+  const grantsForm = document.getElementById("grants");
+  if (grantsForm) grantsForm.onsubmit = (event) => {
+    event.preventDefault();
+    handleAction(async () => {
+      const permissions = [];
+      new FormData(eventForm(event)).forEach((value, key) => {
+        if (key.startsWith("grant:") && value) permissions.push({ codiceMenu: key.slice(6), tipoAbilitazione: Number(value) });
+      });
+      await assignPermissionsToUser(codiceUtente, { permissions });
+      showNotice("Grant aggiornati.");
+    });
+  };
+  if (federatedAuthenticationAvailable) {
+    const linkForm = document.getElementById("link-sso");
+    if (linkForm) linkForm.onsubmit = (event) => {
+      event.preventDefault();
+      handleAction(async () => {
+        const values = formValues(eventForm(event));
+        await linkFederatedIdentity(codiceUtente, { provider: values.provider ?? "", subject: values.subject ?? "", note: values.note || void 0 });
+        await showUser(String(codiceUtente));
+      });
+    };
+    document.querySelectorAll("[data-identity-toggle]").forEach((button) => {
+      button.onclick = () => handleAction(async () => {
+        await updateFederatedIdentity(button.dataset.identityToggle ?? "", { active: button.dataset.active === "true" });
+        await showUser(String(codiceUtente));
+      });
+    });
+    document.querySelectorAll("[data-identity-delete]").forEach((button) => {
+      button.onclick = () => handleAction(async () => {
+        if (!window.confirm("Eliminare definitivamente questo collegamento SSO? L\xE2\u20AC\u2122utente Accessi non verr\xC3\xA0 eliminato.")) return;
+        await deleteFederatedIdentityPermanently(codiceUtente, button.dataset.identityDelete ?? "");
+        showNotice("Collegamento SSO eliminato definitivamente.");
+        await showUser(String(codiceUtente));
+      });
+    });
+  }
+  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.");
+    await show("users");
+  });
+}
+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</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 ${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 option = checkbox.closest("li");
+        const level = option?.querySelector('select[name^="menu-level:"]');
+        if (level) level.disabled = !checkbox.checked;
+      };
+    });
+    const roleFormElement = document.getElementById("role-form");
+    if (roleFormElement) roleFormElement.onsubmit = async (event) => {
+      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) })) };
+      if (role?.codiceRuolo) await updateRole(role.codiceRuolo, request);
+      else await createRole(request);
+      await show("roles");
+    };
+  };
+  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");
+  }));
+}
+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(`<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-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\xC3\xA0). Un tipo si elimina solo se non \xC3\xA8 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><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 code3 = Number(formValues(form).codUte);
+    if (action === "load") {
+      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: 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\xC3\xB2 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) {
+  const title = HELP[key]?.title ?? key;
+  return `<button type="button" class="help-dot" data-help="${escapeHtml(key)}" aria-haspopup="dialog" aria-expanded="false" aria-controls="accessi-help-popover" aria-label="Informazioni: ${escapeHtml(title)}" title="Informazioni">i</button>`;
+}
+var helpPopover = null;
+var helpAnchor = null;
+function ensureHelpPopover() {
+  if (!helpPopover) {
+    helpPopover = document.createElement("div");
+    helpPopover.className = "help-popover";
+    helpPopover.id = "accessi-help-popover";
+    helpPopover.hidden = true;
+    helpPopover.setAttribute("role", "dialog");
+    helpPopover.setAttribute("aria-modal", "false");
+    helpPopover.tabIndex = -1;
+    document.body.appendChild(helpPopover);
+  }
+  return helpPopover;
+}
+function closeHelp(restoreFocus = true) {
+  if (!helpPopover) return;
+  const wasOpen = !helpPopover.hidden;
+  helpPopover.hidden = true;
+  const anchor = helpAnchor;
+  if (anchor) anchor.setAttribute("aria-expanded", "false");
+  helpAnchor = null;
+  if (restoreFocus && wasOpen && anchor && document.contains(anchor)) anchor.focus();
+}
+function positionHelp() {
+  if (!helpPopover || !helpAnchor || helpPopover.hidden) return;
+  const rect = helpAnchor.getBoundingClientRect();
+  const width = helpPopover.offsetWidth;
+  const height = helpPopover.offsetHeight;
+  const margin = 8;
+  const left = Math.max(margin, Math.min(rect.right - width, window.innerWidth - width - margin));
+  let top = rect.bottom + 6;
+  if (top + height > window.innerHeight - margin) {
+    const above = rect.top - height - 6;
+    top = above >= margin ? above : Math.max(margin, window.innerHeight - height - margin);
+  }
+  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();
+  if (helpAnchor && helpAnchor !== anchor) helpAnchor.setAttribute("aria-expanded", "false");
+  popover.innerHTML = `<div class="help-popover-head"><h4 id="accessi-help-title">${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.setAttribute("aria-labelledby", "accessi-help-title");
+  popover.hidden = false;
+  helpAnchor = anchor;
+  anchor.setAttribute("aria-expanded", "true");
+  bindCopyButtons(popover);
+  positionHelp();
+  (popover.querySelector(".help-close") ?? popover).focus();
+}
+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.");
+  });
+}
+function inlineMarkdown(text) {
+  return escapeHtml(text).replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>").replace(/`([^`]+)`/g, "<code>$1</code>");
+}
+function renderMarkdown(markdown) {
+  const lines = markdown.replace(/\r\n/g, "\n").split("\n");
+  const html = [];
+  let inList = false;
+  let inCode = false;
+  const closeList = () => {
+    if (inList) {
+      html.push("</ul>");
+      inList = false;
+    }
+  };
+  for (const line of lines) {
+    if (line.startsWith("```")) {
+      closeList();
+      html.push(inCode ? "</code></pre>" : '<pre class="markdown-code"><code>');
+      inCode = !inCode;
+      continue;
+    }
+    if (inCode) {
+      html.push(escapeHtml(line));
+      continue;
+    }
+    const heading = /^(#{1,4})\s+(.*)$/.exec(line);
+    if (heading) {
+      closeList();
+      const level = (heading[1] ?? "").length;
+      html.push(`<h${level}>${inlineMarkdown(heading[2] ?? "")}</h${level}>`);
+      continue;
+    }
+    const bullet = /^\s*[-*]\s+(.*)$/.exec(line);
+    if (bullet) {
+      if (!inList) {
+        html.push("<ul>");
+        inList = true;
+      }
+      html.push(`<li>${inlineMarkdown(bullet[1] ?? "")}</li>`);
+      continue;
+    }
+    if (line.trim() === "") {
+      closeList();
+      continue;
+    }
+    closeList();
+    html.push(`<p>${inlineMarkdown(line)}</p>`);
+  }
+  if (inCode) html.push("</code></pre>");
+  closeList();
+  return html.join("");
+}
+async function showChangelog() {
+  render(`<div class="wiki"><article class="wiki-content markdown-body">
+    <header class="wiki-section-head"><h2>Changelog</h2><p>Novita e modifiche rilevanti del modulo Accessi.</p></header>
+    ${renderMarkdown(changelog_default)}
+  </article></div>`);
+}
+function downloadTextFile(fileName, content) {
+  const blob = new Blob([content], { type: "text/plain;charset=utf-8" });
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  anchor.download = fileName;
+  document.body.appendChild(anchor);
+  anchor.click();
+  anchor.remove();
+  URL.revokeObjectURL(url);
+}
+async function showSql() {
+  const schema = result(await getSchema());
+  const copy = (text, notice) => () => handleAction(async () => {
+    await navigator.clipboard.writeText(text);
+    showNotice(notice);
+  });
+  render(`<div class="toolbar"><button id="sql-copy-all">Copia tutto</button><button id="sql-download" class="secondary">Scarica .sql</button><button id="sql-reload" class="secondary">Aggiorna</button></div>
+    <h2>SQL dello schema</h2>
+    <p class="form-help">DDL generato dallo schema Accessi <strong>${escapeHtml(schema.version)}</strong>. Usalo per creare le entita su una nuova installazione (database vuoto).</p>
+    <div class="entity-summary">
+      <span><strong>${schema.presentTables.length}</strong> tabelle presenti</span>
+      <span><strong>${schema.presentGenerators.length}</strong> generatori</span>
+      <span><strong>${schema.extraTables.length}</strong> tabelle extra fuori schema Accessi</span>
+    </div>
+    ${schema.extraTables.length ? `<p class="form-help">Tabelle presenti non gestite da Accessi: <code>${schema.extraTables.map((name) => escapeHtml(name)).join(", ")}</code></p>` : ""}
+    ${schema.sections.map((section) => `<section class="sql-section"><div class="sql-section-head"><h3>${escapeHtml(section.title)}</h3><button type="button" class="secondary" data-sql-copy="${escapeHtml(section.id)}">Copia sezione</button></div><pre class="markdown-code"><code>${escapeHtml(section.sql)}</code></pre></section>`).join("")}`);
+  byId("sql-copy-all").onclick = copy(schema.script, "Script SQL completo copiato.");
+  byId("sql-download").onclick = () => downloadTextFile(`accessi-schema-${schema.version}.sql`, schema.script);
+  byId("sql-reload").onclick = () => handleAction(showSql);
+  document.querySelectorAll("[data-sql-copy]").forEach((button) => {
+    const section = schema.sections.find((entry) => entry.id === button.dataset.sqlCopy);
+    if (section) button.onclick = copy(section.sql, `Sezione "${section.title}" copiata.`);
+  });
+}
+async function show(view) {
+  try {
+    showNotice("");
+    const views = {
+      users: showUsers,
+      roles: showRoles,
+      menuGroups: showMenuGroups,
+      menuItems: showMenuItems,
+      menuTypes: showMenuTypes,
+      filterUser: showFilters,
+      filterTypes: showFilterTypes,
+      ssoProviders: showSsoProviders,
+      ssoUsers: showSsoUsers,
+      tokens: showServiceTokens,
+      wiki: showWiki,
+      changelog: showChangelog,
+      sql: showSql
+    };
+    setActiveNavigation(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);
+  }
+}
+var loginForm = document.getElementById("login-form");
+if (loginForm) loginForm.onsubmit = loginView;
+byId("restart-login").onclick = resetLogin;
+var bootstrapAdminForm = document.getElementById("bootstrap-admin-form");
+if (bootstrapAdminForm) {
+  bootstrapAdminForm.onsubmit = async (event) => {
+    event.preventDefault();
+    const status = document.getElementById("bootstrap-admin-status");
+    try {
+      if (status) status.textContent = "";
+      const values = formValues(bootstrapAdminForm);
+      const fields = new FormData(bootstrapAdminForm);
+      const created = result(await bootstrapAdmin({
+        token: values.token ?? "",
+        email: values.email ?? "",
+        nome: values.nome || void 0,
+        cognome: values.cognome || void 0,
+        password: values.password || void 0,
+        superUser: fields.has("superUser")
+      }));
+      const generated = created.password ? ` Password generata (copiala ora): ${created.password}` : "";
+      if (status) status.textContent = `Utente admin creato: ${created.email}.${generated} Ora accedi dal form principale.`;
+      bootstrapAdminForm.reset();
+    } catch (error) {
+      if (status) status.textContent = error instanceof Error ? error.message : "Creazione non riuscita.";
+    }
+  };
+}
+byId("two-factor-form").onsubmit = async (event) => {
+  event.preventDefault();
+  if (!pendingChallenge) return;
+  try {
+    byId("login-error").textContent = "";
+    const values = formValues(event.currentTarget);
+    await completeLoginStep(result(await verifyTwoFactor({ challengeId: pendingChallenge, code: values.code ?? "" })));
+  } catch (error) {
+    byId("login-error").textContent = error instanceof Error ? error.message : "Verifica non riuscita.";
+  }
+};
+byId("resend-code").onclick = async () => {
+  if (!pendingChallenge) return;
+  try {
+    byId("login-error").textContent = "";
+    await completeLoginStep(result(await resendTwoFactor({ challengeId: pendingChallenge })));
+  } catch (error) {
+    byId("login-error").textContent = error instanceof Error ? error.message : "Reinvio non riuscito.";
+  }
+};
+byId("logout").onclick = () => {
+  resetLogin();
+  token = null;
+  currentUser = null;
+  setAccessiConsoleToken(null);
+  sessionStorage.removeItem("accessi-console-token");
+  window.history.replaceState(null, "", consoleBasePath);
+  void bootstrap();
+};
+byId("nav").onclick = (event) => {
+  const link = event.target.closest("a[data-view]");
+  if (!link) return;
+  event.preventDefault();
+  handleAction(() => navigate(link.dataset.view));
+};
+window.addEventListener("popstate", () => {
+  if (token && currentUser) handleAction(() => show(viewFromLocation()));
+});
+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();
+    if (helpAnchor === dot && helpPopover && !helpPopover.hidden) {
+      closeHelp();
+    } else {
+      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 {
+  finishBoot("login");
+}