emilsoftware-utilities 2.0.0-dev.8 → 2.0.0-dev.80

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

@@ -0,0 +1,4173 @@
+// src/accessi-module/Console/accessiFetch.ts
+var accessToken = null;
+var baseUrl = null;
+var tokenProvider = null;
+var scopedConfig = null;
+var loadingEventName = "accessi-console-network";
+var ACCESSI_UNAUTHORIZED_EVENT = "accessi-console-unauthorized";
+var AccessiRequestError = class extends Error {
+  constructor(message, status, code3, details) {
+    super(message);
+    this.status = status;
+    this.code = code3;
+    this.details = details;
+    this.name = "AccessiRequestError";
+  }
+};
+function notifyNetworkActivity(active) {
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(new CustomEvent(loadingEventName, { detail: { active } }));
+  }
+}
+function setAccessiConsoleToken(token2) {
+  accessToken = token2;
+}
+function payloadString(payload, key) {
+  if (!payload || typeof payload !== "object") return void 0;
+  const value = payload[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readBrowserCookie(name) {
+  if (typeof document === "undefined" || !document.cookie) return null;
+  for (const part of document.cookie.split(";")) {
+    const separator = part.indexOf("=");
+    if (separator < 0) continue;
+    if (part.slice(0, separator).trim() !== name) continue;
+    try {
+      return decodeURIComponent(part.slice(separator + 1).trim());
+    } catch {
+      return part.slice(separator + 1).trim();
+    }
+  }
+  return null;
+}
+function isCookieAuthMode() {
+  return typeof window !== "undefined" && window.__ACCESSI_AUTH_COOKIE__ === true;
+}
+var UNSAFE_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+async function accessiFetch(url, options) {
+  const config = scopedConfig;
+  const cookieMode2 = isCookieAuthMode();
+  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 (cookieMode2) {
+    const method = (options.method ?? "GET").toUpperCase();
+    if (UNSAFE_METHODS.has(method)) {
+      const csrfCookie = window.__ACCESSI_CSRF_COOKIE_NAME__ ?? "accessi_csrf";
+      const csrfHeader = window.__ACCESSI_CSRF_HEADER_NAME__ ?? "x-csrf-token";
+      const csrfToken = readBrowserCookie(csrfCookie);
+      if (csrfToken) headers.set(csrfHeader, csrfToken);
+    }
+  }
+  const resolvedToken = config ? config.getToken ? await config.getToken() : config.token ?? null : tokenProvider ? await tokenProvider() : accessToken;
+  const isAuthEntryRequest = /\/(?:auth\/(?:login|refresh|two-factor\/(?:verify|resend))|console\/entry\/exchange)\b/.test(url);
+  const authenticatedRequest = !isAuthEntryRequest && (cookieMode2 || resolvedToken !== null && resolvedToken !== void 0);
+  if (resolvedToken) headers.set("Authorization", `Bearer ${resolvedToken}`);
+  const runtimeBaseUrl = config?.baseUrl !== void 0 ? config.baseUrl : baseUrl ?? (typeof window !== "undefined" ? window.__ACCESSI_API_BASE_URL__ ?? null : null);
+  const requestUrl = runtimeBaseUrl && url.startsWith("/") ? `${runtimeBaseUrl.replace(/\/+$/, "")}${url}` : url;
+  notifyNetworkActivity(true);
+  try {
+    const response = await fetch(requestUrl, {
+      ...options,
+      headers,
+      ...cookieMode2 ? { credentials: "include" } : {}
+    });
+    const payload = await response.json().catch(() => void 0);
+    if (!response.ok) {
+      const message = payloadString(payload, "message") ?? payloadString(payload, "error") ?? `Errore HTTP ${response.status}`;
+      const rawDetails = payload && typeof payload === "object" ? payload.details : void 0;
+      const details = Array.isArray(rawDetails) ? rawDetails.map((item) => String(item)) : void 0;
+      if (response.status === 401 && authenticatedRequest && typeof window !== "undefined") {
+        window.dispatchEvent(new CustomEvent(ACCESSI_UNAUTHORIZED_EVENT));
+      }
+      throw new AccessiRequestError(message, response.status, payloadString(payload, "code") ?? payloadString(payload, "error"), details);
+    }
+    return {
+      data: payload,
+      status: response.status,
+      headers: response.headers
+    };
+  } finally {
+    notifyNetworkActivity(false);
+  }
+}
+
+// src/accessi-module/Console/generated/emilsoftware-utilities.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 getRevokeTokenUrl = () => {
+  return `/api/accessi/auth/revoke-token`;
+};
+var revokeToken = async (revokeTokenRequest, options) => {
+  return accessiFetch(
+    getRevokeTokenUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        revokeTokenRequest
+      )
+    }
+  );
+};
+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 getGetAdminBootstrapStatusUrl = () => {
+  return `/api/accessi/auth/bootstrap-admin/status`;
+};
+var getAdminBootstrapStatus = async (options) => {
+  return accessiFetch(
+    getGetAdminBootstrapStatusUrl(),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+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, 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/grants/${codiceUtente}?${normalizedParams.toString()}`;
+};
+var getUserRolesAndGrants = async (codiceUtente, params, options) => {
+  return accessiFetch(
+    getGetUserRolesAndGrantsUrl(codiceUtente, params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetScopesUrl = () => {
+  return `/api/accessi/permission/scopes`;
+};
+var getScopes = async (options) => {
+  return accessiFetch(
+    getGetScopesUrl(),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getCreateScopeUrl = () => {
+  return `/api/accessi/permission/scopes`;
+};
+var createScope = async (createScopeRequest, options) => {
+  return accessiFetch(
+    getCreateScopeUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        createScopeRequest
+      )
+    }
+  );
+};
+var getUpdateScopeUrl = (codiceScope) => {
+  return `/api/accessi/permission/scopes/${codiceScope}`;
+};
+var updateScope = async (codiceScope, updateScopeRequest, options) => {
+  return accessiFetch(
+    getUpdateScopeUrl(codiceScope),
+    {
+      ...options,
+      method: "PUT",
+      body: JSON.stringify(
+        updateScopeRequest
+      )
+    }
+  );
+};
+var getDeleteScopeUrl = (codiceScope) => {
+  return `/api/accessi/permission/scopes/${codiceScope}`;
+};
+var deleteScope = async (codiceScope, options) => {
+  return accessiFetch(
+    getDeleteScopeUrl(codiceScope),
+    {
+      ...options,
+      method: "DELETE"
+    }
+  );
+};
+var getGetMenuScopesUrl = (codiceMenu) => {
+  return `/api/accessi/permission/menus/${codiceMenu}/scopes`;
+};
+var getMenuScopes = async (codiceMenu, options) => {
+  return accessiFetch(
+    getGetMenuScopesUrl(codiceMenu),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getSetScopeMenusUrl = (codiceScope) => {
+  return `/api/accessi/permission/scopes/${codiceScope}/menus`;
+};
+var setScopeMenus = async (codiceScope, setScopeMenusRequest, options) => {
+  return accessiFetch(
+    getSetScopeMenusUrl(codiceScope),
+    {
+      ...options,
+      method: "PUT",
+      body: JSON.stringify(
+        setScopeMenusRequest
+      )
+    }
+  );
+};
+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 getDeleteUserPermanentlyUrl = (codiceUtente) => {
+  return `/api/accessi/user/delete-user-permanent/${codiceUtente}`;
+};
+var deleteUserPermanently = async (codiceUtente, options) => {
+  return accessiFetch(
+    getDeleteUserPermanentlyUrl(codiceUtente),
+    {
+      ...options,
+      method: "DELETE"
+    }
+  );
+};
+var getForcePasswordResetLegacyUrl = () => {
+  return `/api/accessi/user/force-password-reset-legacy`;
+};
+var forcePasswordResetLegacy = async (options) => {
+  return accessiFetch(
+    getForcePasswordResetLegacyUrl(),
+    {
+      ...options,
+      method: "POST"
+    }
+  );
+};
+var getCreateLoginAsUrlUrl = (codiceUtente) => {
+  return `/api/accessi/user/login-as/${codiceUtente}`;
+};
+var createLoginAsUrl = async (codiceUtente, loginAsRequest, options) => {
+  return accessiFetch(
+    getCreateLoginAsUrlUrl(codiceUtente),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        loginAsRequest
+      )
+    }
+  );
+};
+var getSetUserPasswordUrl = (codiceUtente) => {
+  return `/api/accessi/user/set-password/${codiceUtente}`;
+};
+var setUserPassword = async (codiceUtente, setUserPasswordRequest, options) => {
+  return accessiFetch(
+    getSetUserPasswordUrl(codiceUtente),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        setUserPasswordRequest
+      )
+    }
+  );
+};
+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 getSetGdprUrl = (codiceUtente) => {
+  return `/api/accessi/user/set-gdpr/${codiceUtente}`;
+};
+var setGdpr = async (codiceUtente, options) => {
+  return accessiFetch(
+    getSetGdprUrl(codiceUtente),
+    {
+      ...options,
+      method: "PATCH"
+    }
+  );
+};
+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 getExchangeConsoleEntryTicketUrl = () => {
+  return `/api/accessi/console/entry/exchange`;
+};
+var exchangeConsoleEntryTicket = async (consoleEntryExchangeRequest, options) => {
+  return accessiFetch(
+    getExchangeConsoleEntryTicketUrl(),
+    {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(
+        consoleEntryExchangeRequest
+      )
+    }
+  );
+};
+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, 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.`),
+      p(`Il pacchetto \xE8 pubblicato in CommonJS con export map esplicita per ogni entry point (accessi/server, accessi/resource-server/*, accessi/client/*, accessi/contracts*, accessi/openapi, accessi/console, accessi/ui): gli import ESM funzionano tramite interop Node. sideEffects elenca solo root barrel, firebird-compat e bundle console, cos\xEC il resto \xE8 tree-shakable.`),
+      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/* e i path OpenAPI configurati (default /accessi/openapi* e /accessi/openapi.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. Per health e readiness usare createAccessiHealthModule({ accessiOptions }): espone /health/live e /health/ready con lo stesso contratto del servizio standalone (bootstrap, database, store Redis e check aggiuntivi).`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "distribuzione",
+    group: "Per iniziare",
+    title: "Distribuzione multi-app e package entry point",
+    summary: "Come usare Accessi come servizio centrale, come resource server o solo come contratti.",
+    blocks: [
+      p(`Accessi non va montato per forza in ogni backend. La distribuzione consigliata separa il servizio che possiede il database e la console dai backend fratelli che devono solo autenticare le richieste.`),
+      table(
+        ["Entry point", "Uso", "Dipendenze server"],
+        [
+          ["accessi/server", "Bootstrap completo: DB, SMTP, migrazioni, console, API.", "s\xEC"],
+          ["accessi/resource-server", "Guard/middleware per backend fratelli: verifica JWT e autorizzazione remota.", "no"],
+          ["accessi/client", "Client OpenAPI generato per chiamare Accessi Service.", "no"],
+          ["accessi/client/public", "Solo API pubbliche (login, refresh, 2FA, reset password, registrazione, ticket console).", "no"],
+          ["accessi/client/admin", "Solo API amministrative (utenti, ruoli, menu, filtri, provider federati, schema).", "no"],
+          ["accessi/client/service", "Solo API service-to-service (service token e introspezione), mai nei frontend.", "no"],
+          ["accessi/contracts", "Tipi, enum e helper puri browser-safe.", "no"],
+          ["accessi/contracts/dtos", "DTO Nest con class-validator e decoratori OpenAPI.", "no"],
+          ["accessi/openapi", "setupOpenApi e merge del documento OpenAPI.", "no"],
+          ["accessi/console", "Helper per URL console, ticket e 2FA handoff.", "no"],
+          ["accessi/ui", "Percorsi degli asset Web Component frameworkless.", "no"]
+        ]
+      ),
+      p(`Topologia consigliata: un solo Accessi Service possiede database, encryptionKey, SMTP, chiavi JWT e console. Gli altri backend usano resource-server e client, senza credenziali del database Accessi.`),
+      p(`Multi-tenancy: un database per tenant, configurato in una cartella di file <id>.env. Il database resta invariato (nessuna colonna tenant); ogni tenant gira in un processo separato con chiavi, issuer e store propri. Validazione e avvio con npm run accessi:tenants; dettagli in docs/multi-tenancy.md.`),
+      note("warn", `Root barrel legacy`, `Il root barrel e i deep import restano supportati fino alla prossima major. I nuovi consumer devono usare gli entry point della tabella; la mappa di migrazione e in docs/import-migration.md.`),
+      p(`Per avviare Accessi come servizio autonomo usare startAccessiService: espone /health/live, /health/ready, /health/metrics, valida la configurazione e gestisce SIGTERM/SIGINT.`),
+      p(`Per parlare con piu Accessi Service o tenant dallo stesso processo usare createAccessiClient: ogni istanza ha base URL e token propri, isolati anche tra richieste concorrenti. configureAccessiClient resta il default globale per le funzioni esportate dal package.`),
+      good("ts", [
+        "// Backend che ospita Accessi",
+        "import { initializeAccessiModule } from 'emilsoftware-utilities/accessi/server';",
+        "",
+        "// Backend fratello: nessun AccessiModule, nessun DB Accessi",
+        "import { createAccessiAuthMiddleware } from 'emilsoftware-utilities/accessi/resource-server';",
+        "import { createAccessiClient } from 'emilsoftware-utilities/accessi/client';",
+        "",
+        "const milano = createAccessiClient({ baseUrl: 'https://accessi-milano.example.com', getToken });",
+        "const roma = createAccessiClient({ baseUrl: 'https://accessi-roma.example.com', token: tokenRoma });",
+        "const [utentiMilano, utentiRoma] = await Promise.all([milano.getUsers(), roma.getUsers()]);"
+      ].join("\n"), "Import corretti per ruolo"),
+      note("warn", `Un solo proprietario`, `Non montare AccessiModule in due backend puntati allo stesso database: migrazioni, bootstrap admin, ticket console e rate limit diventano ambigui.`),
+      note("info", `Client per scope`, `Usare accessi/client/public nei frontend pubblici, accessi/client/admin nella console e nei tool amministrativi, accessi/client/service solo nei backend fratelli. Gli scope partizionano il client completo e condividono gli stessi tipi; il client completo resta disponibile per compatibilita.`),
+      note("info", `Split in pacchetti`, `Il package resta unico con entry point per scope: decisione, soglie per rivalutarla e piano di migrazione sono nell'ADR docs/adr/0001-split-package.md.`),
+      note("info", `IP reali dietro proxy`, `Imposta http.trustProxy sul numero di proxy davanti al servizio (1 per Nginx/Traefik/ALB, 2 con Cloudflare + ingress) e lascialo false se il servizio e esposto direttamente. Rate limit e audit usano req.ip: dettagli in docs/proxy-ip.md.`),
+      note("info", `Prompt di integrazione`, `Il file integration-prompt.md nella root del repository contiene il contesto completo per frontend, backend e agenti AI.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    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, refreshExpiresIn, algorithm, issuer, audience, privateKey, publicKey, keyId, jwksPath, previousPublicKeys, onUnknownKeyId }", "s\xEC", "Firma, durata, refresh token, JWKS e rotazione chiavi. Default HS256; RS/ES consigliati per resource server multi-servizio."],
+          ["emailOptions", "EmailOptions", "s\xEC", "SMTP per reset e codici email."],
+          ["publicAuthRateLimit", "PublicAuthRateLimitOptions", "no", "Limiti per endpoint pubblici; store condiviso opzionale (Redis) per il cluster."],
+          ["edgeRateLimit", "AccessiEdgeRateLimitOptions", "no", "Limite grossolano per IP davanti alle rotte Accessi; opzionale, store condiviso supportato."],
+          ["http", "{ cors, trustProxy, securityHeaders }", "no", "CORS, IP reali dietro proxy e header di sicurezza con CSP a nonce per la console e direttive configurabili."],
+          ["authCookie", "{ enabled, secure, sameSite, csrf, ... }", "no", "Cookie HttpOnly e CSRF double-submit al posto del Bearer. Default disattivato."],
+          ["metrics", "{ enabled, sink, prefix }", "no", "Metriche Prometheus di dominio (login, 2FA, refresh, rate limit, store) e sink esterno opzionale."],
+          ["audit", "{ enabled, sinks, store, retentionDays, redact }", "no", "Audit persistente redatto, retention e query/export admin. Default: solo log strutturato."],
+          ["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, rateLimitStore }", "no", "Token macchina-a-macchina, abilitati per impostazione predefinita; rate limit condiviso opzionale."],
+          ["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/OpenAPI/API."],
+          ["consoleApiBaseUrl", "string", "no", "Base URL API per la console quando UI e API sono su domini diversi."],
+          ["openapi", "OpenApiSetupOptions", "no", "Path, titolo, descrizione e enabled della documentazione OpenAPI. Default invariati."],
+          ["consoleEntry", "{ ttlMs, store }", "no", "TTL e store condiviso dei ticket console (Redis per multi-istanza). Default in memoria."],
+          ["sessionRevocation", "{ enabled, store, ttlMs }", "no", "Revoca sessioni per utente tramite store memory/Redis; abilita POST /api/accessi/auth/revoke-sessions."],
+          ["accessTokenRevocation", "{ enabled, store, ttlMs }", "no", "Revoca dei singoli access token tramite jti (memory/Redis); abilita POST /api/accessi/auth/revoke-token."],
+          ["refreshTokenRotation", "{ enabled, store, reuseGraceMs, revokeUserSessionsOnReuse }", "no", "Refresh token monouso tramite store memory/Redis; al riuso oltre la finestra di grazia revoca la famiglia di token. Consigliato in multi-istanza."],
+          ["logger", "LoggerService", "no", "Logger Nest del sotto-app; se assente Nest usa il proprio logger."],
+          ["bufferLogs", "boolean", "no", "Buffer dei log di bootstrap del sotto-app. Default true."]
+        ]
+      ),
+      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',",
+        "    issuer: 'accessi',",
+        "    audience: 'backend-app',",
+        "  },",
+        "  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"),
+      p(`options.openapi personalizza path, titolo e descrizione della documentazione OpenAPI. Con enabled: false UI e JSON non vengono montati, ma le API /api/accessi restano attive. initializeAccessiModule restituisce { nestApp, document } per mergiare il contratto nel documento OpenAPI unico dell'host.`),
+      good("ts", [
+        "const { document } = await initializeAccessiModule(app, {",
+        "  ...options,",
+        "  openapi: { openApiPath: 'auth/docs', openApiJsonPath: 'auth/docs.json', title: 'Auth API' },",
+        "});",
+        "// document.paths e document.components.schemas sono pronti per il merge"
+      ].join("\n"), "OpenAPI personalizzato"),
+      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.`),
+      note("info", `Schema esatto`, `La riconciliazione allinea le tabelle Accessi a "niente in piu, niente in meno": le colonne non previste vengono segnalate come incompatibili e rimosse automaticamente (dopo rename e copie dei dati legacy). Gli indici, i trigger e i CHECK extra non previsti non vengono tolti, ma un indice non previsto su una tabella Accessi viene riportato come avviso senza bloccare l'avvio.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    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 e permessi. Se l'account \xE8 passwordless, ometti la password: il server risponde con un challenge via email (vedi la sezione su 2FA e passwordless).`),
+      note("info", `Scadenza del token`, `Result.token.expiresIn e sempre espresso in secondi (per esempio 86400 per 24h), indipendentemente dal formato usato in jwtOptions.expiresIn.`),
+      note("info", `Autorizzazioni lato client`, `La fonte autorevole \xE8 Result.userGrants.grants: contiene i grant effettivi (ruoli + permessi diretti, livello massimo). Non leggere i permessi dal JWT e non usare Result.utente.permissions: non sono popolati. Per i superutenti grants contiene tutti i menu attivi al livello 30.`),
+      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("warn", `Policy password (solo quando si imposta)`, `Reset, set-password admin e bootstrap richiedono almeno 8 caratteri con maiuscola, minuscola, cifra e carattere speciale, senza spazi e non comuni. Se non conforme l'API risponde 400 con code ACCESSI_WEAK_PASSWORD e l'elenco dei requisiti in details. La policy NON si applica al login: le password preesistenti eventualmente deboli continuano ad autenticare e vengono migrate senza blocco.`),
+      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: "resource-server",
+    group: "Autorizzazione",
+    title: "Resource server e introspection",
+    summary: "Proteggere un backend fratello senza accedere al database Accessi.",
+    blocks: [
+      p(`Un backend che non possiede Accessi usa resource-server. La verifica puo essere locale (JWT) oppure delegata all'introspection di Accessi Service. La policy di autorizzazione usa gli stessi accessiRequirement del middleware storico.`),
+      good("ts", [
+        "import { createAccessiAuthMiddleware } from 'emilsoftware-utilities/accessi/resource-server';",
+        "",
+        "app.use(createAccessiAuthMiddleware({",
+        "  jwt: {",
+        "    // In una topologia multi-servizio preferire RS256/JWKS:",
+        "    // publicKey: process.env.ACCESSI_JWT_PUBLIC_KEY,",
+        '    // algorithms: ["RS256"],',
+        "    serverSecret: process.env.ACCESSI_JWT_SECRET, // HS256: deriva la chiave access",
+        '    issuer: "accessi",',
+        '    audience: "backend-a",',
+        "  },",
+        "  introspection: {",
+        '    url: "https://accessi.example.com/api/accessi/auth/introspect",',
+        "    serviceToken: process.env.ACCESSI_SERVICE_TOKEN!,",
+        "  },",
+        "}));"
+      ].join("\n"), "Express resource server"),
+      good("ts", [
+        "import { createAccessiAuthGuard } from 'emilsoftware-utilities/accessi/resource-server';",
+        "",
+        "@UseGuards(createAccessiAuthGuard({",
+        '  jwt: { publicKey: process.env.ACCESSI_JWT_PUBLIC_KEY, algorithms: ["RS256"] },',
+        "  introspection: { url: process.env.ACCESSI_INTROSPECT_URL!, serviceToken: process.env.ACCESSI_SERVICE_TOKEN! },",
+        '  authorization: { requirements: [{ menuCode: "ORDINI", minPermissionLevel: 20 }] },',
+        "}))",
+        '@Get("ordini")',
+        "list(@Req() req: Request) { return req.user; }"
+      ].join("\n"), "Guard Nest"),
+      table(
+        ["Campo", "Obbligo", "Note"],
+        [
+          ["jwt.serverSecret", "HS256", "Segreto grezzo Accessi; il resource server applica la KDF access."],
+          ["jwt.publicKey / jwt.jwks", "RS/ES", "Consigliato in multi-servizio. JWKS ha cache e timeout."],
+          ["jwt.issuer / jwt.audience", "no", "Consigliati per evitare token di altri ambienti."],
+          ["introspection.url", "se servono grant", "Endpoint service-to-service protetto da service token."],
+          ["introspection.serviceToken", "se introspection", "Scope richiesto: accessi:introspect."],
+          ["authorization", "no", "Policy accessiRequirement; senza introspection i grant sono obbligatori."]
+        ]
+      ),
+      note("warn", `Fail closed`, `Se introspection e configurata ma non raggiungibile, il resource server risponde 503. Non autorizza la richiesta.`),
+      note("info", `Introspection`, `POST /api/accessi/auth/introspect restituisce active=false per token invalido, scaduto o utente disabilitato. I risultati attivi sono cachati lato resource server per 30 secondi per default.`),
+      note("info", `JWKS`, `Con RS256/ES256 Accessi pubblica la JWKS su /accessi/.well-known/jwks.json (configurabile con jwtOptions.jwksPath). Il resource server puo usare jwks.url e ruotare le chiavi con previousPublicKeys.`),
+      note("info", `Revoca`, `revocation.store applica la revoca per utente; revocation.accessTokenStore rifiuta i singoli jti revocati e revocation.familyStore invalida le famiglie di refresh token revocate per riuso sospetto.`),
+      note("info", `Audit`, `I fallimenti di autenticazione del resource server, i blocchi edge, il riuso dei refresh token e le revoche di sessione producono eventi strutturati tramite auditAccessi; i token e i segreti vengono redatti dal Logger.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    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 e GDPR.",
+    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. Admin o superutente."],
+          ["DELETE", "/api/accessi/user/delete-user-permanent/:codiceUtente", "Eliminazione definitiva: rimuove utente e record collegati. Solo admin."],
+          ["POST", "/api/accessi/user/set-password/:codiceUtente", "Imposta direttamente la password: hash lato backend e scadenza secondo policy, nessuna email."],
+          ["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."]
+        ]
+      ),
+      note("warn", `Eliminazione: soft o definitiva`, `Il soft delete (STAREG=DELETE) \xE8 disponibile per admin e superutenti ed \xE8 reversibile. L'eliminazione definitiva rimuove utente e record collegati in transazione ed \xE8 riservata agli admin; il superutente senza flag Admin pu\xF2 solo flaggare l'utente come eliminato. Se l'utente ha dati collegati in altre tabelle (per esempio campi estesi del backend) l'eliminazione definitiva fallisce con code ACCESSI_USER_DELETE_HAS_REFERENCES e messaggio esplicito: usa allora il soft delete.`),
+      note("ok", `Creazione con invito atomica`, `La creazione utente con invio email \xE8 atomica: se SMTP non \xE8 configurato si fallisce prima di scrivere, e se l'invio fallisce l'utente creato viene annullato (codice ACCESSI_USER_INVITE_EMAIL_FAILED). Non restano utenti senza password. In alternativa un admin crea l'utente e imposta la password dal form dedicato.`),
+      note("ok", `Admin: controllo completo del profilo`, `Dalla scheda utente un admin modifica tutti i campi Accessi: anagrafica, cellulare, lingua, avatar, pagina di default, metadata JSON, 2FA/passwordless/login con password, flag, GDPR, stato registrazione e scadenza password. La password si imposta direttamente con set-password. Le scritture sono idempotenti (UPDATE OR INSERT su UTENTI_CONFIG) e verificate dal backend; non serve accedere al database.`),
+      note("info", `Consenso GDPR`, `Il pulsante "Registra consenso GDPR" completa il processo: imposta FLGGDPR e DATGDPR e scrive la riga storica in UTENTI_GDPR (endpoint set-gdpr). Anche impostare flagGdpr via update-user completa il processo con la stessa riga storica.`),
+      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 effettivi sommano ruoli e permessi diretti prendendo il livello massimo per menu; un livello 0 non annulla un grant del ruolo. I superutenti ricevono tutti i menu attivi al livello massimo.`),
+      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: "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"),
+      note("info", `Scambio service-to-service`, `Se il backend fratello valida il provider SSO, pu\xF2 scambiare { provider, subject } con POST /api/accessi/federated-auth/exchange usando un service token con scope accessi:federated:exchange. Accessi non riceve il token del provider.`),
+      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.`),
+      note("info", `Introspection`, `Per un backend fratello creare un service token con scope accessi:introspect e usarlo in POST /api/accessi/auth/introspect. Il resource server lo configura in introspection.serviceToken.`),
+      note("warn", `Rate limit condiviso`, `In cluster configurare serviceTokens.rateLimitStore e publicAuthRateLimit.store con createRedisRateLimitStore: i contatori in memoria valgono solo per singola istanza.`),
+      note("info", `Edge rate limit`, `Per una soglia grossolana per IP configurare edgeRateLimit: viene applicata davanti alle rotte Accessi. Il gateway/API gateway resta comunque consigliato per bot protection e limiti di connessione.`),
+      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 e Login as.`,
+        `Ruoli e grant: CRUD dei ruoli con l'albero delle abilitazioni.`,
+        `Menu e gruppi: CRUD di gruppi, menu e tipi menu.`,
+        `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. Gerarchia: ADMIN > SUPER > utente.`),
+      note("info", `Gerarchia dei ruoli`, `Vale ADMIN (2) > SUPER (1) > utente comune (0). Un attore pu\xF2 gestire solo utenti di rango pari o inferiore: un superutente pu\xF2 amministrare totalmente utenti comuni e superutenti (profilo, password, flag, ruoli, grant, stato, eliminazione e identit\xE0/utenti SSO) ma NON pu\xF2 toccare un admin. Un admin pu\xF2 gestire chiunque. La regola \xE8 imposta dal backend (ensureCanManageTargetUser): un tentativo non consentito restituisce 403.`),
+      note("info", `Gestione dei flag`, `Dalla scheda utente i flag sono mostrati in base al ruolo di chi \xE8 connesso: un admin pu\xF2 assegnare o togliere sia il flag Admin sia il flag Superutente; un superutente senza flag Admin pu\xF2 gestire solo il flag Superutente. I flag si impostano anche in creazione (utente locale o SSO).`),
+      note("warn", `Ultimo admin`, `Per non restare chiusi fuori dalla console, l'ultimo admin attivo non pu\xF2 essere disattivato, bloccato, eliminato n\xE9 privato del flag Admin: l'operazione restituisce 400 finch\xE9 non viene promosso un altro admin.`),
+      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). La sezione "Crea utente admin" nella schermata di login compare solo quando adminBootstrap \xE8 abilitato (stato esposto da GET /api/accessi/auth/bootstrap-admin/status): 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.`),
+      note("ok", `Auto-ingresso dal frontend`, `Se un frontend ha gi\xE0 una sessione Accessi valida e l'utente \xE8 abilitato alla console, pu\xF2 aprire la console senza rifare il login: \`POST /api/accessi/console/entry\` con \`Authorization: Bearer <jwt>\` restituisce un ticket monouso; apri poi \`/api/accessi/console#entry=<ticket>\`. Il JWT non finisce mai nell'URL; il ticket dura 60 secondi ed \xE8 utilizzabile una sola volta (endpoint di scambio protetto da rate limit).`),
+      note("info", `Console centralizzata`, `In una topologia multi-backend la console va ospitata una sola volta su Accessi Service. Gli altri backend possono linkarla con \`buildAccessiConsoleUrl\` di \`accessi/console\` oppure proxare \`/api/accessi/*\` sullo stesso dominio. Non copiare gli asset della console in ogni applicazione.`),
+      note("warn", `Ticket multi-istanza`, `I ticket di ingresso console sono in memoria per default. Con piu istanze configurare \`consoleEntry.store\` con \`createRedisConsoleEntryStore\`: il JWT viene cifrato e il consume e atomico.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    id: "login-as",
+    group: "Console",
+    title: "Login as (accesso temporaneo)",
+    summary: "Superutenti e admin possono generare un URL per entrare in un applicazione come un altro utente.",
+    blocks: [
+      p(`Dalla lista utenti della console il pulsante Login as apre il pannello dedicato: inserisci l'URL dell'applicazione e premi "Genera URL di accesso". Accessi emette un JWT per l'utente target e lo allega all'URL come query parameter \`loginAsToken\`.`),
+      code("http", `POST /api/accessi/user/login-as/:codiceUtente
+Content-Type: application/json
+Authorization: Bearer <jwt amministratore>
+
+{ "url": "https://app.example.com/dashboard" }`, "Richiesta"),
+      code("json", `{
+  "Result": {
+    "loginUrl": "https://app.example.com/dashboard?loginAsToken=eyJ...",
+    "token": "eyJ...",
+    "expiresInSeconds": 86400,
+    "expiresAt": "2026-10-24T14:05:00.000Z"
+  }
+}`, "Risposta"),
+      note("danger", `La durata \xE8 quella standard`, `Il token dura quanto la sessione Accessi standard (jwtOptions.expiresIn). \xC8 una credenziale: chiunque abbia l'URL pu\xF2 usarlo fino alla scadenza per entrare nell'applicazione come l'utente target. Non condividerlo, non salvarlo in log o documenti e non usarlo in produzione per operazioni distruttive.`),
+      note("info", `Chi pu\xF2 generarlo`, `Solo utenti con FLGSUPER o FLGADMIN. Vale la stessa gerarchia della gestione utenti: un superutente non pu\xF2 impersonare un admin; un admin pu\xF2 impersonare chiunque. Il tentativo non consentito restituisce 403.`),
+      note("warn", `Responsabilit\xE0 dell applicazione`, `Accessi non controlla l'URL di destinazione n\xE9 consuma il token al posto dell'applicazione. L'app deve leggere \`loginAsToken\`, validarlo (per esempio con \`POST /api/accessi/auth/get-user-by-token\` o \`authorizeAccessi\`) e decidere cosa consentire. Il token \xE8 un access token Accessi a tutti gli effetti, con claim \`loginAs: true\`, \`amr: ["login_as"]\` e \`act\` valorizzato con l'attore.`),
+      p(`Il token viene emesso anche per utenti con 2FA attiva: l'attore ha gi\xE0 completato l'autenticazione amministrativa. Non usare questa funzione per aggirare la 2FA di un utente comune al di fuori di un intervento amministrativo autorizzato.`)
+    ]
+  },
+  // -------------------------------------------------------------------------
+  {
+    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/refresh, auth/revoke-sessions, auth/revoke-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, DELETE user/delete-user-permanent/:codiceUtente, POST user/set-password/:codiceUtente, POST user/set-stato, PATCH user/set-gdpr/:codiceUtente, POST user/register, POST user/login-as/:codiceUtente"],
+          ["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"],
+          ["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## Non rilasciato\n\n### Cambiamenti\n- Import: gli entry point (`accessi/server`, `accessi/resource-server`, `accessi/client*`, `accessi/contracts*`, `accessi/openapi`, `accessi/console`, `accessi/ui`) sono la via consigliata. Root barrel e deep import restano supportati fino alla prossima major; mappa di migrazione in `docs/import-migration.md`.\n- Sicurezza HTTP: CSP configurabile con nonce per la console, `'unsafe-inline'` documentato solo per Swagger UI, header frame/referrer/cache personalizzabili; guida in `docs/security-headers.md`.\n- Autenticazione: modalita opzionale a cookie `HttpOnly` con CSRF double-submit, refresh da cookie e supporto console; Bearer resta il default. Guida in `docs/auth-cookies.md`.\n- Observability: metriche Prometheus di dominio per login, 2FA, refresh, rate limit, introspection, JWKS, revoche, ticket console e store Redis, con alert suggeriti in `docs/metrics.md`.\n- Audit: sink memory/Redis/HTTP/callback, redazione ricorsiva, retention, query ed export NDJSON admin in `docs/audit.md`.\n- Multi-tenancy: un database per tenant senza modifiche allo schema, cartella di file `<id>.env`, validazione isolamento, risoluzione host/path/header fidato e supervisore processi in `docs/multi-tenancy.md`.\n- Resource server: aggiunti `createAccessiAuthMiddleware`, `createAccessiAuthGuard`, `createAccessiTokenVerifier` e `createAccessiIntrospectionClient` per backend fratelli che non possiedono il database Accessi. Supporta HS256, RS/ES con chiave pubblica PEM e JWKS con cache.\n- Introspection: nuovo `POST /api/accessi/auth/introspect` protetto da service token con scope `accessi:introspect`. Restituisce `active`, profilo utente e grant correnti.\n- JWT: `jwtOptions` accetta `algorithm`, `issuer`, `audience`, `privateKey`, `publicKey`, `keyId`, `jwksPath` e `previousPublicKeys`. Default HS256 invariato; RS/ES sono consigliati per la topologia multi-servizio.\n- JWKS: con RS/ES Accessi pubblica `/accessi/.well-known/jwks.json` (path configurabile) con chiave corrente e chiavi precedenti per la rotazione. I resource server possono usare `jwks.url`.\n- Console ticket: introdotto `ConsoleEntryStore`. Default in memoria; `createRedisConsoleEntryStore` salva il JWT cifrato in Redis, usa TTL e consume atomico per il monouso multi-istanza. Configurazione in `consoleEntry.store` e `consoleEntry.ttlMs`.\n- Rate limit: introdotto `RateLimitStore`. `createRedisRateLimitStore` usa `INCR` + `PEXPIRE` atomici per contatori condivisi in cluster. Configurazione in `publicAuthRateLimit.store` e `serviceTokens.rateLimitStore`; default in memoria invariato.\n- Edge rate limit: aggiunto `createAccessiEdgeRateLimitMiddleware` e `AccessiOptions.edgeRateLimit` per una soglia grossolana per IP davanti alle rotte Accessi. Fail closed se lo store non risponde; supporta lo stesso store Redis.\n- Servizio standalone: aggiunti `createAccessiService`, `startAccessiService`, `/health/live`, `/health/ready`, `/health/metrics` e shutdown graceful. Aggiunti gli script `accessi:serve` e `accessi:serve:dist` per l'esecuzione come processo Node.\n- Configurazione: aggiunti `validateAccessiOptions` e `assertValidAccessiOptions`; il servizio standalone li applica al bootstrap.\n- HTTP: aggiunte opzioni `http.cors`, `http.trustProxy`, `http.securityHeaders`. La JWKS viene montata automaticamente anche con `AccessiModule.forRoot` tramite `HttpAdapterHost`.\n- SSO: aggiunto `POST /api/accessi/federated-auth/exchange` protetto da service token con scope `accessi:federated:exchange` per scambiare `{ provider, subject }` verificati da un backend fratello.\n- Audit: aggiunto `auditAccessi` per eventi di sicurezza strutturati; resource server ed edge rate limit registrano fallimenti di autenticazione, blocchi e rate limit non disponibile.\n- Contratto: aggiunto `npm run check:accessi-openapi`, eseguito nel build, che blocca path fuori prefisso, operationId duplicati/mancanti, $ref rotti, path legacy e rimozioni di operation/schema rispetto al fingerprint versionato.\n- Contratto: aggiunto `npm run accessi:update-openapi-fingerprint` per aggiornare intenzionalmente il fingerprint dopo una modifica breaking approvata.\n- Console: aggiunto `consoleApiBaseUrl` per servire UI e API su domini diversi; il valore viene iniettato in `window.__ACCESSI_API_BASE_URL__`.\n- Chiavi: aggiunto `npm run accessi:generate-jwt-keys` per generare coppia RS256/ES256, `keyId` e JWKS pubblica.\n- Sessioni: aggiunta la revoca per utente con `SessionRevocationStore` memory/Redis e `POST /api/accessi/auth/revoke-sessions`. Resource server e guard controllano il cutoff `iat`.\n- Refresh token: con `jwtOptions.refreshExpiresIn` login, 2FA e SSO emettono anche `refreshToken` (typ=refresh) e `POST /api/accessi/auth/refresh` restituisce una nuova coppia access+refresh. Gli access token hanno ora `jti`.\n- Refresh rotation: con `refreshTokenRotation.store` il refresh token e monouso e la rotazione e atomica tra istanze; due refresh concorrenti producono un solo successo.\n- Contratto: il fingerprint OpenAPI ora blocca anche la rimozione di operation/schema rispetto alla baseline versionata.\n- OpenAPI: aggiunto `mergeOpenApiDocuments` per unire il documento Accessi nel documento unico dell'host con conflitti espliciti.\n- Console: aggiunto `buildAccessiConsoleUrl` per linkare la console centrale senza mettere JWT nell'URL.\n- Rinomina: la configurazione e gli helper della documentazione usano `openapi`/`OpenApi` (`AccessiOptions.openapi`, `OpenApiSetupOptions`, `setupOpenApi`, `DEFAULT_ACCESSI_OPENAPI`); i vecchi nomi `swagger` non sono piu esportati.\n- Token Accessi: `TokenResult.expiresIn` riporta sempre la validita effettiva in secondi (es. `86400`), anche quando `jwtOptions.expiresIn` usa un formato leggibile come `24h`. I client possono quindi esporre `expires_in` anche per il token di login normale.\n- Console: nuova funzione **Login as** per superutenti e admin. Dalla lista utenti si genera un URL verso l'applicazione scelta con `?loginAsToken=<jwt>`; il token dura quanto la sessione Accessi standard (`jwtOptions.expiresIn`), registra l'attore nelle claim `act`/`loginAs` e resta soggetto alla gerarchia ADMIN > SUPER. Endpoint: `POST /api/accessi/user/login-as/:codiceUtente`.\n- Console: rimosse le sezioni **Filtri utente** e **Tipi filtro**. I filtri applicativi sono deprecati e non vengono pi\xF9 letti n\xE9 scritti dalla console; le tabelle restano invariate e la gestione torna manuale sul database.\n- Console: le conferme operative (es. \"Ruoli aggiornati\") ora compaiono come notifiche in alto a destra e scompaiono automaticamente.\n- Console: il salvataggio del profilo non invia pi\xF9 i campi della tabella `FILTRI`, evitando payload rifiutati dal backend. `UserService` tocca `FILTRI` solo se il chiamante invia esplicitamente almeno un campo legacy.\n- Console: scheda utente riorganizzata. \"Indietro\" resta nella barra superiore; stato registrazione, disattivazione ed eliminazione definitiva sono in un form coerente \"Stato e sicurezza\", con icone e tooltip allineati.\n- Console: pagina Changelog a larghezza piena, con intestazioni di versione evidenziate e sezioni orizzontali leggibili.\n- Seed `npm run accessi:seed-admin`: crea o aggiorna un admin completo (`FLGSUPER = 1` e `FLGADMIN = 1`) e corregge il nome colonna usato in precedenza (`FLGADMIN`).\n- Console: la pagina di default nella scheda utente \xE8 ora un autocomplete con ricerca. Propone tutte le rotte del catalogo menu, si filtra scrivendo ed \xE8 ancora possibile inserire un valore libero.\n- Autorizzazioni: i grant effettivi sommano ruoli e permessi diretti prendendo il livello massimo per menu. Un permesso diretto con livello inferiore (o 0) non annulla pi\xF9 il grant del ruolo.\n- Ruoli legacy: un menu senza descrizione non viene pi\xF9 scartato e un `TIPABI` mancante viene letto come livello 10, evitando utenti con ruolo ma senza accesso.\n- Grant dei ruoli arricchiti con i metadati di navigazione del catalogo menu (`pagina`, icona, gruppo, tipo): il frontend riceve gli stessi campi dei grant diretti e pu\xF2 costruire correttamente menu e rotte.\n- Sicurezza: `GET /api/accessi/permission/grants/:codiceUtente` accetta solo un JWT Accessi valido e consente la lettura solo al proprietario o a chi pu\xF2 gestire quel target (gerarchia ADMIN > SUPER). Un superutente non pu\xF2 leggere i grant di un admin.\n\n## 2.0.0-dev.50 (2026-10-15)\n\n### Cambiamenti\n- ORM: `Row` e `DbValue` sono i tipi predefiniti di `Orm.query` e `Orm.execute`; `transactionQuery` usa `Row[]`. Gli usi generici non devono pi\xF9 dichiarare `Record<string, unknown>`.\n- Build: il contratto OpenAPI generato (`src/accessi-module/openapi/`) \xE8 ignorato da Git e viene rigenerato da `npm run generate:accessi-openapi`.\n\n## 2.0.0-dev.49 (2026-10-15)\n\n### Cambiamenti\n- Documentazione HTTP rinominata da Swagger a **OpenAPI**: il modulo unificato espone `/accessi/openapi` e `/accessi/openapi.json`; `setupSwagger` usa `/openapi` come default.\n- Il path \xE8 configurabile tramite `EmilsoftwareOptions.swagger` (utile per far convivere pi\xF9 documentazioni).\n- Allineati log di avvio, Wiki e dispatch delle rotte del modulo.\n- L'alias storico `<path>-json` resta supportato.\n\n### Note\n- I consumer che aprivano `/swagger` o `/accessi/swagger` devono aggiornare l'URL alla nuova documentazione OpenAPI.\n\n## 2.0.0-dev.48 (2026-10-13)\n\n### Correzioni\n- `RestUtilities.sendErrorMessage` restituisce status HTTP specifici (400/401/403/4xx/5xx) e codici generici (`VALIDATION_ERROR`, `UNAUTHORIZED`, `FORBIDDEN`, `INTERNAL_ERROR`, `REQUEST_ERROR`), senza usare codici `ACCESSI_*` nel business helper.\n- Il messaggio restituito \xE8 quello reale dell'eccezione; gli errori testuali di validazione vengono riconosciuti come 400.\n\n## 2.0.0-dev.47 (2026-10-13)\n\n### Correzioni\n- Errore schema database reso generico: codice `DATABASE_SCHEMA_OUTDATED` e messaggio senza riferimenti specifici ad Accessi.\n\n## 2.0.0-dev.46 (2026-10-12)\n\n### Correzioni\n- `sendBaseResponse` resta retro-compatibile quando il terzo argomento \xE8 un tag stringa invece dello status HTTP.\n- Gestita la serializzazione dei `bigint`; gli errori di risposta vengono registrati con stack tramite `sendErrorMessage`.\n- `AccessiHttpExceptionFilter` registra gli errori con stack per facilitare la diagnosi.\n\n## 2.0.0-dev.45 (2026-10-12)\n\n### Correzioni\n- `set-gdpr` e l'aggiornamento di `flagGdpr` sono idempotenti: `UPDATE OR INSERT` su `UTENTI_GDPR` con `MATCHING (CODUTE, DATACC)`.\n- Evitate violazioni di chiave primaria e risposte 500 quando il consenso GDPR viene registrato pi\xF9 volte nello stesso giorno.\n\n## 2.0.0-dev.44\n\n### Aggiunte\n- Endpoint pubblico `GET /api/accessi/auth/bootstrap-admin/status` (`getAdminBootstrapStatus`): la console mostra la sezione \"Crea utente admin\" **solo** se `adminBootstrap.enabled` \xE8 `true`.\n\n### Correzioni\n- Rimossi i caratteri corrotti (mojibake UTF-8 \u2194 Windows-1252) da DTO, servizi, controller, console, OpenAPI e client generato (es. \"L'email \xE8 gi\xE0 associata a un utente Accessi.\").\n\n## 2.0.0-dev.43\n\n### Cambiamenti\n- Gerarchia dei ruoli formalizzata **ADMIN > SUPER > utente**: un superutente non puo' gestire un admin su `update-user`, `delete-user` (soft e hard), `set-password`, `force-password-reset`, `set-stato`, `assign-roles` e `assign-permissions` (`ensureCanManageTargetUser`, 403 se violato).\n- Guard **ultimo admin attivo**: non puo' essere disattivato, bloccato, eliminato o privato del flag Admin (400), per evitare il lockout della console.\n- Creazione utente (`create-managed-user` e registrazione pubblica) resa **atomica** rispetto all'invio email: fail-fast se SMTP non configurato e rollback dell'utente creato se l'invio fallisce (`ACCESSI_USER_INVITE_EMAIL_FAILED`).\n- Console: form password separato (Invio imposta la password invece di salvare il profilo), scheda utente in sola lettura per target di rango superiore.\n- SSO: anche il superutente puo' creare utenti SSO e gestirne identita/policy (`federated-auth/users/*`) sugli utenti non-admin; il catalogo dei provider SSO resta riservato agli admin.\n- Coerenza: i filtri utente (`saveFiltriUtente`) rispettano la gerarchia; il flag GDPR impostato dal profilo allinea anche `DATGDPR`; la scheda in sola lettura disabilita anche il collegamento SSO.\n- Eliminazione definitiva: se l'utente ha dati collegati (tabelle esterne/FK) risponde 400 con `code: ACCESSI_USER_DELETE_HAS_REFERENCES` e messaggio esplicito, suggerendo il soft delete (la hard delete resta invariata quando non ci sono vincoli).\n- Consenso GDPR completo: `update-user` con `flagGdpr` scrive anche la riga storica `UTENTI_GDPR`; in console il pulsante \"Registra consenso GDPR\" usa `set-gdpr`.\n- Console: aggiunto il pulsante \"Invia reset password legacy\" (super e admin).\n- Console: **auto-ingresso dal frontend** tramite ticket monouso (`POST /api/accessi/console/entry` + apertura di `#entry=<ticket>`), senza JWT nell'URL; il ticket e' legato all'utente, dura 60s, e' monouso e lo scambio e' protetto da rate limit (`publicAuthRateLimit.consoleEntry`).\n\n## 2.0.0-dev.42\n\n### Aggiunte\n- Gestione dei flag di privilegio dalla console Accessi:\n  - un admin pu\xF2 assegnare o togliere sia `FLGADMIN` sia `FLGSUPER`;\n  - un superutente senza `FLGADMIN` pu\xF2 gestire solo `FLGSUPER`;\n  - i flag sono impostabili in creazione (utente locale o SSO) e in modifica profilo.\n- Eliminazione utenti con due modalit\xE0:\n  - soft delete (`delete-user`, `STAREG=DELETE`) per admin e superutenti;\n  - eliminazione definitiva (`delete-user-permanent`, solo admin) che rimuove in transazione utente e record collegati.\n- Gestione completa dell'utente dalla console (admin): anagrafica estesa (cellulare, lingua, avatar, metadata JSON), GDPR, scadenza password, tutti i filtri (`FILTRI`) e **impostazione diretta della password** (`POST /api/accessi/user/set-password/:codiceUtente`), senza accesso al database.\n- Scritture utente idempotenti: `UTENTI_CONFIG` in `UPDATE OR INSERT ... MATCHING (CODUTE)`; i campi non inviati restano invariati.\n- Policy password moderna quando si imposta una password (reset, set-password admin, bootstrap): minimo 8 caratteri con maiuscola, minuscola, cifra e carattere speciale, senza spazi e non comune. In caso di violazione risposta 400 con `code: ACCESSI_WEAK_PASSWORD` e `details`. La policy **non** si applica al login, cos\xEC le password preesistenti deboli continuano a funzionare.\n\n### Correzioni\n- Il backend verifica i flag in base al ruolo dell'utente connesso (`ensurePrivilegeFlagChanges`): inviare un flag non consentito restituisce 403.\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(`La console propone in autocomplete tutte le rotte presenti nel catalogo dei menu. Puoi filtrare la lista scrivendo oppure inserire un valore libero.`),
+      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-cellulare": {
+    title: "Cellulare",
+    blocks: [
+      p2(`Numero di cellulare dell'utente (UTENTI_CONFIG.CELLULARE). \xC8 il recapito canonico per SMS o notifiche applicative; Accessi non lo invia da solo.`)
+    ]
+  },
+  "user-lingua": {
+    title: "Codice lingua",
+    blocks: [
+      p2(`Lingua preferita dell'utente (UTENTI_CONFIG.CODLINGUA). Stringa breve come it, en, sl; viene restituita nel profilo e il frontend decide come usarla.`)
+    ]
+  },
+  "user-avatar": {
+    title: "Avatar",
+    blocks: [
+      p2(`Riferimento all'avatar (UTENTI_CONFIG.AVATAR, massimo 30 caratteri): tipicamente un nome file o una chiave, non un base64.`)
+    ]
+  },
+  "user-scadenza-password": {
+    title: "Scadenza password",
+    blocks: [
+      p2(`Data di scadenza della password (UTENTI.DATSCAPWD). Lascia vuoto per non forzare una scadenza; usa una data passata per richiedere il cambio al prossimo login, se la policy \xE8 attiva.`)
+    ]
+  },
+  "user-gdpr": {
+    title: "Consenso GDPR",
+    blocks: [
+      p2(`Lo stato mostra se il consenso \xE8 registrato. Il pulsante "Registra consenso GDPR" (endpoint set-gdpr) imposta FLGGDPR e DATGDPR e scrive la riga storica in UTENTI_GDPR.`),
+      note2("info", "Completo e tracciato", `A differenza del flag impostato a mano, il flusso dedicato registra anche la data e lo storico dell'accettazione.`)
+    ]
+  },
+  "user-json": {
+    title: "Metadata JSON",
+    blocks: [
+      p2(`Campo libero JSON (UTENTI_CONFIG.JSON_METADATA) per dati applicativi del backend. Deve essere JSON valido se il backend lo interpreta.`)
+    ]
+  },
+  "user-set-password": {
+    title: "Imposta password",
+    blocks: [
+      p2(`Imposta direttamente una nuova password locale: viene hashata dal backend e la scadenza segue la policy. Nessuna email viene inviata.`),
+      p2(`Requisiti di sicurezza:`),
+      list2([
+        `Almeno 8 caratteri (massimo 100).`,
+        `Almeno una lettera maiuscola e una minuscola.`,
+        `Almeno una cifra e un carattere speciale (es. ! ? @ # $ %).`,
+        `Nessuno spazio e non deve essere una password comune.`
+      ]),
+      note2("danger", "Password non conforme", `Se non rispetta i requisiti l API risponde 400 con codice ACCESSI_WEAK_PASSWORD e l elenco dei requisiti mancanti; la password non viene salvata.`),
+      note2("warn", "Sostituisce la password attuale", `L'utente dovr\xE0 usare subito la nuova password. Per fargliela scegliere, usa "Invia reset password".`)
+    ]
+  },
+  "user-super": {
+    title: "Superutente (FLGSUPER)",
+    blocks: [
+      p2(`Assegna il flag superutente. Un superutente riceve TUTTE le abilitazioni al livello massimo (30) dopo il login e in console vede solo la sezione Utenti, dove gestisce utenti, ruoli e grant.`),
+      note2("warn", "Non \xE8 un ruolo", `Il flag non sostituisce i ruoli o i grant: li amplia assegnando ogni menu attivo al livello massimo. Usalo solo per gli amministratori di Accessi.`),
+      note2("info", "Chi lo modifica", `Un admin pu\xF2 assegnare o togliere sia Admin sia Superutente; un superutente senza Admin pu\xF2 gestire solo il flag Superutente. La verifica \xE8 ripetuta dal backend.`)
+    ]
+  },
+  "user-admin": {
+    title: "Admin (FLGADMIN)",
+    blocks: [
+      p2(`Assegna il flag admin. Un admin accede a tutta la console (catalogo, token di servizio, SSO e utenti) ma NON conferisce abilitazioni: i menu restano quelli assegnati via ABILITAZIONI e RUOLI_MNU.`),
+      note2("info", "Pu\xF2 gestire i flag", `Un admin pu\xF2 assegnare o togliere sia il flag Admin sia il flag Superutente. Un superutente senza Admin non pu\xF2 modificare il flag Admin.`)
+    ]
+  },
+  "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.`)
+    ]
+  },
+  // ------------------------------------------------------------ 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.`),
+      note2("info", "Chi pu\xF2 farlo", `Sia admin sia superutente possono eseguire il soft delete.`)
+    ]
+  },
+  "user-delete-permanent": {
+    title: "Elimina definitivamente",
+    blocks: [
+      p2(`Cancella l'utente e tutti i record collegati (configurazione, password, ruoli, abilitazioni, identit\xE0 SSO, challenge 2FA e GDPR). Operazione irreversibile.`),
+      note2("danger", "Non reversibile", `I dati vengono rimossi fisicamente dal database; non \xE8 possibile ripristinare l'utente.`),
+      note2("info", "Solo admin", `Il pulsante \xE8 mostrato e accettato solo per il flag Admin. Un superutente senza Admin pu\xF2 solo flaggare l'utente come eliminato.`)
+    ]
+  },
+  "user-login-as": {
+    title: "Login as",
+    blocks: [
+      p2(`Genera un accesso temporaneo all'applicazione come l'utente selezionato. Non richiede la password dell'utente e non modifica il suo profilo.`),
+      note2("danger", "La durata \xE8 quella standard", `Il token dura quanto la sessione Accessi standard (jwtOptions.expiresIn). \xC8 una credenziale: chiunque ottenga l'URL pu\xF2 usarlo fino alla scadenza per entrare nell'applicazione come l'utente target. Non condividerlo, non salvarlo in log o chat e non incollarlo in documenti.`),
+      note2("info", "Chi pu\xF2 usarlo", `Solo superutenti e admin. Vale la gerarchia ADMIN > SUPER: un superutente non pu\xF2 impersonare un admin.`),
+      p2(`Il token viene aggiunto all'URL scelto come parametro di query loginAsToken. Da quel momento \xE8 l'applicazione di destinazione a decidere come validarlo e cosa consentire.`)
+    ]
+  },
+  "login-as-url": {
+    title: "URL dell applicazione",
+    blocks: [
+      p2(`Inserisci l'indirizzo assoluto dell'applicazione in cui vuoi entrare, per esempio https://app.example.com/dashboard.`),
+      p2(`Il modulo aggiunge automaticamente ?loginAsToken=<token> conservando le query e il fragment gi\xE0 presenti. Sono ammessi solo URL http e https.`),
+      note2("warn", "Nessun controllo sull applicazione", `Accessi non verifica che l'URL appartenga a un ambiente autorizzato: incollalo con attenzione per non inviare il token a un dominio sbagliato.`)
+    ]
+  },
+  // ----------------------------------------------------- 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",
+  menuScopes: "menu-e-gruppi/scope",
+  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",
+  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 cookieMode = typeof window !== "undefined" && window.__ACCESSI_AUTH_COOKIE__ === true;
+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 actionIcon(paths) {
+  return `<svg class="button-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${paths}</svg>`;
+}
+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;
+}
+var noticeTimers = /* @__PURE__ */ new Set();
+function showNotice(message, isError = false) {
+  const container = byId("notice");
+  if (!message) {
+    noticeTimers.forEach((timer2) => window.clearTimeout(timer2));
+    noticeTimers.clear();
+    container.innerHTML = "";
+    return;
+  }
+  const toast = document.createElement("div");
+  const kind = isError ? "error" : "success";
+  const icon = isError ? "!" : "\u2713";
+  toast.className = `notice notice-${kind}`;
+  toast.setAttribute("role", isError ? "alert" : "status");
+  toast.innerHTML = `<span class="notice-icon" aria-hidden="true">${icon}</span><span class="notice-text">${escapeHtml(message)}</span><button type="button" class="notice-close" aria-label="Chiudi il messaggio">&times;</button>`;
+  container.appendChild(toast);
+  let timer;
+  const dismiss = () => {
+    if (timer !== void 0) {
+      window.clearTimeout(timer);
+      noticeTimers.delete(timer);
+      timer = void 0;
+    }
+    toast.remove();
+  };
+  toast.querySelector(".notice-close")?.addEventListener("click", dismiss);
+  timer = window.setTimeout(dismiss, isError ? 9e3 : 5e3);
+  noticeTimers.add(timer);
+  while (container.childElementCount > 4) container.firstElementChild?.remove();
+}
+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\xF9 presenti nel catalogo</strong>${missingMenus.map((menu) => `<div class="role-permission-entry"><div><strong>${escapeHtml(menu.codiceMenu)}</strong><p class="entity-note">Il menu \xE8 ancora associato al ruolo ma non \xE8 disponibile nel catalogo corrente.</p></div><span class="permission-level">${escapeHtml(rolePermissionLevel(menu.tipoAbilitazione))}</span></div>`).join("")}</section>` : ""}</div></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\xF9 nel catalogo</strong><span class="role-tree-count">${orphans.length}</span></div><ul class="role-tree-menus">${orphans.map((item) => `<li class="role-tree-menu"><span class="role-tree-menu-name"><code>${escapeHtml(item.codiceMenu)}</code></span><span class="permission-level">${escapeHtml(rolePermissionLevel(item.tipoAbilitazione))}</span></li>`).join("")}</ul></li>` : "";
+  return `<article class="role-card">
+    <div class="role-card-head">
+      <div class="role-card-title">
+        <strong>${escapeHtml(role.descrizioneRuolo)}</strong>
+        <span class="role-card-meta">Codice ${escapeHtml(role.codiceRuolo)} &middot; ${roleMenus.length} menu</span>
+      </div>
+      <div class="role-card-actions">
+        <button type="button" class="secondary" data-role="${escapeHtml(role.codiceRuolo)}">Modifica</button>
+        <button type="button" class="danger-button" data-role-delete="${escapeHtml(role.codiceRuolo)}">Elimina</button>
+      </div>
+    </div>
+    ${roleMenus.length ? `<details class="role-card-menus"><summary>Abilitazioni per menu (${roleMenus.length})</summary><ul class="role-tree">${groupNodes}${orphanNode}</ul></details>` : '<p class="role-card-empty">Nessun menu assegnato.</p>'}
+  </article>`;
+}
+function roleMenuEditorTable(group, role) {
+  const roleMenus = role?.menu ?? [];
+  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) {
+  if (!(error instanceof Error)) return "Operazione non riuscita.";
+  const extra = error;
+  const code3 = typeof extra.code === "string" ? extra.code : void 0;
+  const details = Array.isArray(extra.details) ? extra.details.map((item) => String(item)) : [];
+  const detailSuffix = details.length ? ` (${details.join("; ")})` : "";
+  const message = code3 && !error.message.startsWith(`${code3}:`) ? `${code3}: ${error.message}` : error.message;
+  return `${message}${detailSuffix}`;
+}
+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\xE0 SSO</h3></div><span class="muted">Collegamenti verificati dal backend</span></div><p class="form-help">Disabilita conserva lo storico; elimina rimuove il collegamento (l'utente resta).</p><div class="sso-identity-list">${identities.map((identity) => `<article class="sso-identity-item ${identity.active ? "" : "is-disabled"}"><div class="sso-identity-data"><strong>${escapeHtml(identity.provider)}</strong><dl class="entity-metadata"><div><dt>Subject</dt><dd>${escapeHtml(identity.subject)}</dd></div><div><dt>Stato</dt><dd>${identity.active ? "Abilitata" : "Disabilitata"}</dd></div></dl>${identity.note ? `<p class="entity-note"><strong>Nota</strong>${escapeHtml(identity.note)}</p>` : ""}</div><div class="sso-identity-actions"><button type="button" class="secondary" data-identity-toggle="${escapeHtml(identity.identityKey)}" data-active="${String(!identity.active)}">${identity.active ? "Disabilita" : "Abilita"}</button><button type="button" class="icon-button danger-button" data-identity-delete="${escapeHtml(identity.identityKey)}" aria-label="Elimina definitivamente il collegamento SSO ${escapeHtml(identity.provider)}" title="Elimina definitivamente il collegamento SSO"><span aria-hidden="true">&#128465;</span></button></div></article>`).join("") || '<p class="muted">Nessun collegamento SSO.</p>'}</div>${providers.some((provider) => provider.active) ? `<form id="link-sso" class="sso-link-form">${federatedIdentityFields(providers)}<button>Collega SSO verificato</button></form>` : '<p class="form-help">Non ci sono provider SSO attivi. Censiscine uno nella sezione SSO prima di creare collegamenti.</p>'}</section>`;
+}
+function loginAsPanel(user) {
+  return `<form id="login-as" class="user-editor-section" data-user-panel="loginAs" role="tabpanel" aria-labelledby="user-tab-loginAs">
+    <div class="section-heading"><div><p class="eyebrow">Accesso temporaneo</p><h3>Login as ${helpDot("user-login-as")}</h3></div><span class="muted">Solo superutenti e admin</span></div>
+    <div class="login-as-info"><strong>Prima di generare l'URL</strong><ul><li>Il token ha la <strong>stessa durata della sessione Accessi standard</strong> (<code>jwtOptions.expiresIn</code>) e permette di entrare nell'applicazione come <strong>${escapeHtml(user.email)}</strong>.</li><li>\xC8 una credenziale: chiunque abbia l'URL pu\xF2 usarlo fino alla scadenza. Non condividerlo e non salvarlo.</li><li>Il token viene allegato come <code>?loginAsToken=</code> all'URL indicato. L'applicazione di destinazione decide come consumarlo.</li><li>L'operazione \xE8 consentita solo a superutenti e admin, nel rispetto della gerarchia ADMIN &gt; SUPER.</li></ul></div>
+    <label>URL dell'applicazione ${helpDot("login-as-url")}<input name="url" type="url" placeholder="https://app.example.com/" maxlength="2048" required><span class="form-help">URL assoluto http/https. Eventuali query o fragment esistenti vengono conservati.</span></label>
+    <button type="submit">Genera URL di accesso</button>
+    <div id="login-as-result" class="token-reveal" hidden><code id="login-as-url"></code><a id="login-as-open" class="button-link" href="#" target="_blank" rel="noopener noreferrer">Apri</a><button id="login-as-copy" type="button">Copia URL</button></div>
+  </form>`;
+}
+function userDetailTabs(hasSso, hasLoginAs) {
+  const tabs = [
+    ...hasSso ? [{ id: "sso", label: "Identit\xE0 SSO" }] : [],
+    { id: "profile", label: "Profilo e accesso" },
+    { id: "roles", label: "Ruoli" },
+    { id: "grants", label: "Grant diretti" },
+    ...hasLoginAs ? [{ id: "loginAs", label: "Login as" }] : []
+  ];
+  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 ? ` \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 applyAdminBootstrapVisibility() {
+  const panel = document.getElementById("bootstrap-admin-panel");
+  if (!panel) return;
+  try {
+    const status = result(await getAdminBootstrapStatus());
+    panel.hidden = status.enabled !== true;
+  } catch {
+    panel.hidden = true;
+  }
+}
+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) {
+    token = response.token.value;
+    sessionStorage.setItem("accessi-console-token", token);
+    setAccessiConsoleToken(token);
+  } else if (!cookieMode) {
+    throw new Error("Risposta di autenticazione incompleta.");
+  }
+  resetLogin();
+  await bootstrap();
+}
+async function bootstrap() {
+  const hadToken = token !== null;
+  try {
+    setAccessiConsoleToken(token);
+    if (!token && !cookieMode) throw new Error("Inserisci le credenziali amministrative.");
+    const payload = result(await getUserByToken({ token: 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 = cookieMode && !hadToken ? "" : error instanceof Error ? error.message : "Sessione non valida.";
+  }
+}
+async function exchangeConsoleEntry(ticket) {
+  try {
+    const session = result(await exchangeConsoleEntryTicket({ ticket }));
+    const value = session.token?.value;
+    if (typeof value === "string" && value !== "") {
+      token = value;
+      sessionStorage.setItem("accessi-console-token", value);
+      setAccessiConsoleToken(value);
+    } else if (!cookieMode) {
+      throw new Error("Apertura automatica della console non riuscita.");
+    }
+    await bootstrap();
+  } catch (error) {
+    token = null;
+    setAccessiConsoleToken(null);
+    sessionStorage.removeItem("accessi-console-token");
+    finishBoot("login");
+    byId("login-error").textContent = error instanceof Error ? error.message : "Apertura automatica della console non riuscita.";
+  }
+}
+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><button id="reset-legacy" class="secondary">Invia reset password legacy</button></div>
+    <div class="pager-row pager-row-top">${pagerMarkup(totalPages)}</div>
+    <table class="users-table"><thead><tr><th>Utente</th><th>Stato</th><th>Accesso</th><th>2FA</th><th>Ruoli</th><th aria-label="Azioni"></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><div class="row-actions"><button type="button" class="secondary" data-login-as="${utente.codiceUtente}"${canManageUser(utente) ? "" : ' disabled title="Non puoi impersonare un utente di rango superiore" aria-disabled="true"'}>Login as</button><button data-user="${utente.codiceUtente}"${canManageUser(utente) ? "" : ' disabled title="Non puoi gestire un utente di rango superiore" aria-disabled="true"'}>Gestisci</button></div></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"));
+  byId("reset-legacy").onclick = () => handleAction(async () => {
+    if (!window.confirm("Inviare l email di reset a tutti gli utenti con password non ancora migrata? Richiede un servizio email configurato.")) return;
+    await forcePasswordResetLegacy();
+    showNotice("Email di reset inviate agli utenti con password legacy.");
+  });
+  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 ?? ""));
+  });
+  document.querySelectorAll("[data-login-as]").forEach((button) => {
+    button.onclick = () => handleAction(async () => {
+      await showUser(button.dataset.loginAs ?? "");
+      activateUserTab("loginAs");
+    });
+  });
+  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 \xE8 richiesto dopo password o SSO.</p>
+    <label class="check"><input name="passwordlessLoginEnabled" type="checkbox" ${user.passwordlessLoginEnabled ? "checked" : ""} ${user.flagDueFattori ? "" : "disabled"}> Consenti accesso con il solo codice email ${helpDot("user-passwordless")}</label>
+    <p class="form-help">Accesso senza password (richiede il codice email).</p>
+    </fieldset>`;
+}
+function canManageSuperFlag() {
+  return Boolean(currentUser?.flagSuper || currentUser?.flagAdmin);
+}
+function canManageAdminFlag() {
+  return Boolean(currentUser?.flagAdmin);
+}
+function consoleUserRank(user) {
+  if (user?.flagAdmin) return 2;
+  if (user?.flagSuper) return 1;
+  return 0;
+}
+function canManageUser(user) {
+  if (currentUser && user.codiceUtente === currentUser.codiceUtente) return true;
+  return consoleUserRank(currentUser) >= consoleUserRank(user);
+}
+function setUserManagementEnabled(enabled) {
+  for (const id of ["disable-user", "purge-user", "save-state", "set-password", "save-profile", "set-gdpr"]) {
+    const element = document.getElementById(id);
+    if (element) element.disabled = !enabled;
+  }
+  for (const selector of ["#roles button", "#grants button", "#link-sso button"]) {
+    document.querySelectorAll(selector).forEach((button) => {
+      button.disabled = !enabled;
+    });
+  }
+  for (const selector of ["#profile", "#password-form", "#roles", "#grants", "#link-sso"]) {
+    document.querySelectorAll(
+      `${selector} input, ${selector} select, ${selector} textarea`
+    ).forEach((field) => {
+      field.disabled = !enabled;
+    });
+  }
+  document.querySelectorAll("[data-identity-toggle], [data-identity-delete]").forEach((button) => {
+    button.disabled = !enabled;
+  });
+}
+function privilegeFields(user) {
+  const manageSuper = canManageSuperFlag();
+  const manageAdmin = canManageAdminFlag();
+  if (!manageSuper && !manageAdmin) return "";
+  return `<fieldset><legend>Privilegi Accessi (opzionale)</legend>
+    ${manageAdmin ? `<label class="check"><input name="flagAdmin" type="checkbox" ${user.flagAdmin ? "checked" : ""}> Admin ${helpDot("user-admin")}</label><p class="form-help">Accede a tutta la console (catalogo, token, SSO, utenti) e puo gestire i flag. Non modifica le abilitazioni.</p>` : ""}
+    ${manageSuper ? `<label class="check"><input name="flagSuper" type="checkbox" ${user.flagSuper ? "checked" : ""}> Superutente ${helpDot("user-super")}</label><p class="form-help">Riceve tutte le abilitazioni al livello massimo e gestisce utenti, ruoli e grant.</p>` : ""}
+    </fieldset>`;
+}
+function privilegePayload(form) {
+  const fields = new FormData(form);
+  const payload = {};
+  if (canManageSuperFlag()) payload.flagSuper = fields.has("flagSuper");
+  if (canManageAdminFlag()) payload.flagAdmin = fields.has("flagAdmin");
+  return payload;
+}
+function optionalText(values, key) {
+  if (!(key in values)) return void 0;
+  const raw = (values[key] ?? "").trim();
+  return raw === "" ? null : raw;
+}
+function passwordPolicyViolations(password) {
+  const violations = [];
+  if (password.length < 8) violations.push("almeno 8 caratteri");
+  if (password.length > 100) violations.push("al massimo 100 caratteri");
+  if (/\s/.test(password)) violations.push("nessuno spazio");
+  if (!/[A-Z]/.test(password)) violations.push("una lettera maiuscola");
+  if (!/[a-z]/.test(password)) violations.push("una lettera minuscola");
+  if (!/\d/.test(password)) violations.push("una cifra");
+  if (!/[^A-Za-z0-9]/.test(password)) violations.push("un carattere speciale");
+  return violations;
+}
+function dateInputValue(value) {
+  const text = typeof value === "string" ? value : "";
+  const match = /^(\d{4}-\d{2}-\d{2})/.exec(text);
+  return match?.[1] ?? "";
+}
+function pageRouteSuggestions(groups) {
+  const routes = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    for (const menu of group.menus) {
+      const value = (menu.pagina ?? "").trim();
+      if (!value) continue;
+      const suggestion = {
+        value,
+        menu: menu.descrizioneMenu || void 0,
+        group: group.descrizioneGruppo || void 0,
+        disabled: menu.enabled === false
+      };
+      const current = routes.get(value);
+      if (!current || current.disabled && !suggestion.disabled) routes.set(value, suggestion);
+    }
+  }
+  return [...routes.values()].sort((a, b) => a.value.localeCompare(b.value, "it"));
+}
+function pageDefaultField(user) {
+  const value = user.paginaDefault ?? "";
+  return `<label class="page-default-field">Pagina di default ${helpDot("user-default-page")}
+    <div class="page-combobox" data-page-combobox>
+      <div class="page-combobox-control">
+        ${actionIcon('<circle cx="11" cy="11" r="8"/><path d="m21 21-4.3-4.3"/>')}
+        <input id="pagina-default" name="paginaDefault" type="text" maxlength="50" value="${escapeHtml(value)}" autocomplete="off" role="combobox" aria-autocomplete="list" aria-expanded="false" aria-controls="pagina-default-listbox" placeholder="Cerca una rotta o scrivi una pagina">
+        <button type="button" class="page-combobox-clear" aria-label="Pulisci la pagina di default" ${value ? "" : "hidden"}>&times;</button>
+        <button type="button" class="page-combobox-toggle" aria-label="Mostra le pagine disponibili" aria-haspopup="listbox">${actionIcon('<path d="m6 9 6 6 6-6"/>')}</button>
+      </div>
+      <ul id="pagina-default-listbox" class="page-combobox-list" role="listbox" aria-label="Pagine disponibili" hidden></ul>
+    </div>
+    <span class="form-help">Scegli una rotta dal catalogo dei menu oppure scrivi un valore libero.</span>
+  </label>`;
+}
+function bindPageDefaultCombobox(routes) {
+  const root = document.querySelector("[data-page-combobox]");
+  if (!root) return;
+  const input = root.querySelector('input[name="paginaDefault"]');
+  const list3 = root.querySelector(".page-combobox-list");
+  const clear = root.querySelector(".page-combobox-clear");
+  const toggle = root.querySelector(".page-combobox-toggle");
+  if (!input || !list3) return;
+  let matches = [];
+  let activeIndex = -1;
+  const optionId = (index) => `pagina-default-option-${index}`;
+  const setOpen = (open) => {
+    list3.hidden = !open;
+    input.setAttribute("aria-expanded", String(open));
+    if (!open) {
+      activeIndex = -1;
+      input.removeAttribute("aria-activedescendant");
+    }
+  };
+  const renderMatches = (query) => {
+    const needle = query.trim().toLocaleLowerCase("it");
+    matches = needle === "" ? routes : routes.filter((route) => [route.value, route.menu ?? "", route.group ?? ""].join(" ").toLocaleLowerCase("it").includes(needle));
+    list3.innerHTML = matches.map((route, index) => `<li id="${optionId(index)}" class="page-combobox-option${route.disabled ? " is-disabled" : ""}" role="option" aria-selected="${route.value === input.value ? "true" : "false"}" data-index="${index}"><code>${escapeHtml(route.value)}</code><small>${escapeHtml([route.menu, route.group].filter(Boolean).join(" \xB7 ") || "Rotta del catalogo menu")}${route.disabled ? " \xB7 menu disabilitato" : ""}</small></li>`).join("") || '<li class="page-combobox-empty" role="presentation">Nessuna rotta corrisponde. Puoi comunque lasciare il valore scritto.</li>';
+    activeIndex = -1;
+    input.removeAttribute("aria-activedescendant");
+  };
+  const highlight = () => {
+    list3.querySelectorAll(".page-combobox-option").forEach((option, index) => {
+      option.classList.toggle("is-active", index === activeIndex);
+    });
+    const current = activeIndex >= 0 ? list3.querySelector(`#${optionId(activeIndex)}`) : null;
+    if (current) {
+      input.setAttribute("aria-activedescendant", optionId(activeIndex));
+      current.scrollIntoView({ block: "nearest" });
+    } else {
+      input.removeAttribute("aria-activedescendant");
+    }
+  };
+  const openList = () => {
+    renderMatches("");
+    setOpen(true);
+    highlight();
+  };
+  const refresh = (query) => {
+    renderMatches(query);
+    setOpen(true);
+    highlight();
+  };
+  const choose = (route) => {
+    input.value = route.value;
+    if (clear) clear.hidden = false;
+    input.focus();
+    setOpen(false);
+  };
+  input.addEventListener("focus", openList);
+  input.addEventListener("input", () => {
+    if (clear) clear.hidden = input.value.length === 0;
+    refresh(input.value);
+  });
+  input.addEventListener("blur", () => {
+    window.setTimeout(() => {
+      if (!root.contains(document.activeElement)) setOpen(false);
+    }, 0);
+  });
+  input.addEventListener("keydown", (event) => {
+    if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+      event.preventDefault();
+      if (list3.hidden) refresh(input.value);
+      if (matches.length === 0) return;
+      activeIndex = event.key === "ArrowDown" ? (activeIndex + 1) % matches.length : activeIndex <= 0 ? matches.length - 1 : activeIndex - 1;
+      highlight();
+      return;
+    }
+    if (event.key === "Enter" && !list3.hidden && activeIndex >= 0) {
+      const route = matches[activeIndex];
+      if (route) {
+        event.preventDefault();
+        choose(route);
+      }
+      return;
+    }
+    if (event.key === "Escape" && !list3.hidden) {
+      event.preventDefault();
+      setOpen(false);
+      return;
+    }
+    if (event.key === "Tab") setOpen(false);
+  });
+  list3.addEventListener("mousedown", (event) => {
+    if (event.target.closest("[data-index]")) event.preventDefault();
+  });
+  list3.addEventListener("click", (event) => {
+    const option = event.target.closest("[data-index]");
+    if (!option) return;
+    const route = matches[Number(option.dataset.index)];
+    if (route) choose(route);
+  });
+  if (clear) {
+    clear.addEventListener("click", () => {
+      input.value = "";
+      clear.hidden = true;
+      input.focus();
+      openList();
+    });
+  }
+  if (toggle) {
+    toggle.addEventListener("click", () => {
+      if (list3.hidden) {
+        input.focus();
+        openList();
+      } else {
+        setOpen(false);
+      }
+    });
+  }
+}
+function extendedProfileFields(user) {
+  return `<fieldset><legend>Anagrafica estesa</legend>
+    <label>Cellulare ${helpDot("user-cellulare")}<input name="cellulare" maxlength="30" value="${escapeHtml(user.cellulare ?? "")}"></label>
+    <label>Codice lingua ${helpDot("user-lingua")}<input name="codiceLingua" maxlength="2" value="${escapeHtml(user.codiceLingua ?? "")}"></label>
+    <label>Avatar ${helpDot("user-avatar")}<input name="avatar" maxlength="30" value="${escapeHtml(user.avatar ?? "")}"></label>
+    <label>Scadenza password ${helpDot("user-scadenza-password")}<input name="dataScadenzaPassword" type="date" value="${dateInputValue(user.dataScadenzaPassword)}"></label>
+    <fieldset class="gdpr-status"><legend>GDPR ${helpDot("user-gdpr")}</legend><p class="form-help">${user.flagGdpr ? `Consenso registrato${dateInputValue(user.dataGdpr) ? ` il ${escapeHtml(dateInputValue(user.dataGdpr))}` : ""}.` : "Consenso non ancora registrato."}</p><button type="button" id="set-gdpr" class="secondary">Registra consenso GDPR</button></fieldset>
+    <label>Metadata JSON ${helpDot("user-json")}<textarea name="jsonMetadata" rows="3">${escapeHtml(user.jsonMetadata ?? "")}</textarea></label>
+    </fieldset>`;
+}
+function profilePayload(form, codiceUtente) {
+  const values = formValues(form);
+  const fields = new FormData(form);
+  const payload = {
+    codiceUtente,
+    email: values.email ?? "",
+    nome: optionalText(values, "nome"),
+    cognome: optionalText(values, "cognome"),
+    cellulare: optionalText(values, "cellulare"),
+    codiceLingua: optionalText(values, "codiceLingua"),
+    avatar: optionalText(values, "avatar"),
+    paginaDefault: optionalText(values, "paginaDefault"),
+    jsonMetadata: optionalText(values, "jsonMetadata"),
+    dataScadenzaPassword: optionalText(values, "dataScadenzaPassword"),
+    flagDueFattori: fields.has("flagDueFattori"),
+    passwordlessLoginEnabled: fields.has("passwordlessLoginEnabled"),
+    ...privilegePayload(form)
+  };
+  if (federatedAuthenticationAvailable) {
+    payload.passwordLoginEnabled = fields.has("passwordLoginEnabled");
+  }
+  return payload;
+}
+function passwordFields() {
+  return `<form id="password-form" class="user-editor-section" data-user-panel="profile" role="tabpanel" aria-labelledby="user-tab-profile">
+    <h3>Password</h3>
+    <label>Nuova password ${helpDot("user-set-password")}<input name="newPassword" type="password" autocomplete="new-password" minlength="8" maxlength="100"><span class="form-help">Almeno 8 caratteri con maiuscola, minuscola, cifra e carattere speciale; nessuno spazio. Viene salvata come hash e la scadenza segue la policy; nessuna email inviata.</span></label>
+    <button type="submit" id="set-password" class="secondary">Imposta password</button>
+    </form>`;
+}
+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\xE0 l'email per la password.</span></label><label>Nome ${helpDot("user-name")}<input name="nome"></label><label>Cognome ${helpDot("user-name")}<input name="cognome"></label>${privilegeFields({})}<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 () => {
+      const form = eventForm(event);
+      await createManagedUser({ ...formValues(form), ...privilegePayload(form) });
+      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\xE0 verificati dal backend.</p>
+    <form id="sso-user"><label>Email ${helpDot("user-email")}<input name="email" type="email" required><span class="form-help">Email di contatto e identificativo Accessi dell'utente.</span></label><label>Nome ${helpDot("user-name")}<input name="nome"></label><label>Cognome ${helpDot("user-name")}<input name="cognome"></label>${federatedIdentityFields(providers)}<label class="check"><input name="passwordLoginEnabled" type="checkbox"> Abilita anche la password locale ${helpDot("user-password-login")}</label><span class="form-help">Se disattivato, l'utente accede solo via SSO.</span>${privilegeFields({})}<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, ...privilegePayload(form) }
+      };
+      await createFederatedUser(request);
+      showNotice("Utente SSO creato e collegamento registrato.");
+      await show(currentUser?.flagAdmin ? "ssoUsers" : "users");
+    });
+  };
+}
+async function showSsoProviders() {
+  if (!federatedAuthenticationAvailable) throw new Error("SSO non \xE8 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\xE0 \xE8 collegata.</p>
+    <div class="menu-table-wrap"><table><thead><tr><th>Provider</th><th>Descrizione</th><th>Stato</th><th></th></tr></thead><tbody>${providerList.map((provider) => `<tr class="${provider.active ? "" : "is-disabled"}"><td><code>${escapeHtml(provider.provider)}</code></td><td>${escapeHtml(provider.description)}</td><td>${provider.active ? "Attivo" : "Disabilitato"}</td><td class="row-actions"><button data-provider="${escapeHtml(provider.provider)}">Gestisci</button></td></tr>`).join("") || '<tr><td colspan="4" class="muted">Nessun provider censito.</td></tr>'}</tbody></table></div>`);
+  byId("new-provider").onclick = () => showProviderForm();
+  byId("reload-providers").onclick = () => handleAction(showSsoProviders);
+  document.querySelectorAll("[data-provider]").forEach((button) => {
+    button.onclick = () => showProviderForm(providerList.find((provider) => provider.provider === button.dataset.provider));
+  });
+}
+async function showSsoUsers() {
+  if (!federatedAuthenticationAvailable) throw new Error("SSO non \xE8 abilitato in questa istanza Accessi.");
+  const users = await loadUsers();
+  render(`<div class="toolbar"><button id="new-sso">Nuovo utente SSO</button><button id="reload-sso-users" class="secondary">Aggiorna</button></div>
+    <h2>Utenti e identit\xE0 SSO</h2><p class="muted">Gestisci i collegamenti provider/subject gi\xE0 verificati dal backend.</p>
+    <div class="menu-table-wrap"><table><thead><tr><th>Utente</th><th>Accesso</th><th></th></tr></thead><tbody>${users.map(({ utente }) => `<tr><td>${escapeHtml(utente.email)}</td><td>${utente.passwordLoginEnabled === false ? "solo SSO" : "password e SSO"}</td><td class="row-actions"><button data-sso-user="${utente.codiceUtente}">Gestisci identit\xE0</button></td></tr>`).join("") || '<tr><td colspan="3" class="muted">Nessun utente.</td></tr>'}</tbody></table></div>`);
+  byId("new-sso").onclick = () => handleAction(showSsoUserForm);
+  byId("reload-sso-users").onclick = () => handleAction(showSsoUsers);
+  document.querySelectorAll("[data-sso-user]").forEach((button) => {
+    button.onclick = () => handleAction(() => showUser(button.dataset.ssoUser ?? ""));
+  });
+}
+function showProviderForm(provider) {
+  const isExisting = provider !== void 0;
+  render(`<button id="back" type="button">Indietro</button><div class="page-header"><div><p class="eyebrow">Catalogo SSO</p><h2>${isExisting ? "Gestisci provider" : "Nuovo provider"}</h2></div><span class="muted">Le configurazioni tecniche restano nel backend</span></div><form id="provider-form"><label>Chiave provider ${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";
+  const manageable = canManageUser(user);
+  render(`${manageable ? "" : '<div class="notice notice-error" role="alert"><span class="notice-icon" aria-hidden="true">!</span><span class="notice-text">Stai visualizzando un utente di rango superiore: scheda in sola lettura.</span></div>'}<div class="user-action-bar"><button id="back" type="button" class="secondary">Indietro</button></div><div class="page-header"><div><p class="eyebrow">Utente ${codiceUtente}</p><h2>${escapeHtml(user.email)}</h2></div><span class="muted">Gestione profilo, ruoli e autorizzazioni</span></div>
+    <form id="user-state-form" class="account-panel">
+      <div class="account-panel-head"><div><p class="eyebrow">Amministrazione account</p><h3>Stato e sicurezza</h3><p class="form-help">Aggiorna lo stato di registrazione o disattiva l'account. Le azioni distruttive sono raccolte qui, separate dal profilo.</p></div></div>
+      <div class="account-state-row">
+        <label class="account-state-field">Stato registrazione ${helpDot("user-state")}<select id="user-state">${registrationStateOptions(user.statoRegistrazione)}</select></label>
+        <button id="save-state" type="submit" class="secondary">${actionIcon('<path d="M20 6 9 17l-5-5"/>')}<span>Aggiorna stato</span></button>
+      </div>
+      <div class="account-danger-zone">
+        <div class="account-danger-head"><strong>Azioni distruttive</strong><span class="form-help">La disattivazione conserva i dati; l'eliminazione definitiva \xE8 irreversibile.</span></div>
+        <div class="account-danger-actions">
+          <span class="action-with-help"><button id="disable-user" type="button" class="danger-button">${actionIcon('<path d="M3 6h18"/><path d="M8 6V4h8v2"/><path d="M19 6l-1 14H6L5 6"/><path d="M10 11v6"/><path d="M14 11v6"/>')}<span>Imposta stato eliminato</span></button>${helpDot("user-delete")}</span>
+          ${currentUser?.flagAdmin ? `<span class="action-with-help"><button id="purge-user" type="button" class="danger-button">${actionIcon('<path d="M10.29 3.86 1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z"/><path d="M12 9v4"/><path d="M12 17h.01"/>')}<span>Elimina definitivamente</span></button>${helpDot("user-delete-permanent")}</span>` : ""}
+        </div>
+      </div>
+    </form>
+    ${userDetailTabs(federatedAuthenticationAvailable, manageable)}<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>${pageDefaultField(user)}${federatedAuthenticationAvailable ? `<label class="check"><input name="passwordLoginEnabled" type="checkbox" ${user.passwordLoginEnabled !== false ? "checked" : ""}> Login con password ${helpDot("user-password-login")}</label><span class="form-help">Se disabilitato, il login con email e password restituisce un errore esplicito; restano valide le identit\xE0 SSO attive.</span>` : ""}${authenticationPolicyFields(user)}${extendedProfileFields(user)}${privilegeFields(user)}<button id="save-profile" type="submit">Salva</button></form>
+    ${passwordFields()}
+    ${roleAssignmentEditor(allRoles, userGrants.ruoli, menuGroups)}
+    ${directGrantEditor(menuGroups, userGrants.abilitazioni)}
+    ${manageable ? loginAsPanel(user) : ""}
+    </div>`);
+  bindPageDefaultCombobox(pageRouteSuggestions(menuGroups));
+  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 form = eventForm(event);
+        const fields = new FormData(form);
+        await updateUtente(codiceUtente, profilePayload(form, codiceUtente));
+        if (codiceUtente === currentUser?.codiceUtente && (fields.has("flagDueFattori") !== Boolean(user.flagDueFattori) || fields.has("passwordlessLoginEnabled") !== Boolean(user.passwordlessLoginEnabled) || canManageSuperFlag() && fields.has("flagSuper") !== Boolean(user.flagSuper) || canManageAdminFlag() && fields.has("flagAdmin") !== Boolean(user.flagAdmin))) {
+          token = null;
+          sessionStorage.removeItem("accessi-console-token");
+          setAccessiConsoleToken(null);
+          resetLogin();
+          await bootstrap();
+          byId("login-error").textContent = "Privilegi o policy aggiornati. Accedi di nuovo con la nuova configurazione.";
+          return;
+        }
+        await showUser(String(codiceUtente));
+        activateUserTab("profile");
+        showNotice("Profilo e policy aggiornati.");
+      });
+    };
+  }
+  const passwordForm = document.getElementById("password-form");
+  if (passwordForm) passwordForm.onsubmit = (event) => {
+    event.preventDefault();
+    handleAction(async () => {
+      const newPassword = (document.querySelector('#password-form input[name="newPassword"]')?.value ?? "").trim();
+      const violations = passwordPolicyViolations(newPassword);
+      if (violations.length > 0) throw new Error(`La password non rispetta i requisiti: richiede ${violations.join(", ")}.`);
+      if (!window.confirm(`Impostare una nuova password per ${user.email}?`)) return;
+      await setUserPassword(codiceUtente, { newPassword });
+      showNotice("Password aggiornata.");
+      await showUser(String(codiceUtente));
+    });
+  };
+  const loginAsForm = document.getElementById("login-as");
+  if (loginAsForm) loginAsForm.onsubmit = (event) => {
+    event.preventDefault();
+    handleAction(async () => {
+      const values = formValues(eventForm(event));
+      const issued = result(await createLoginAsUrl(codiceUtente, { url: values.url ?? "" }));
+      const box = byId("login-as-result");
+      box.hidden = false;
+      byId("login-as-url").textContent = issued.loginUrl;
+      byId("login-as-open").href = issued.loginUrl;
+      byId("login-as-copy").onclick = () => handleAction(async () => {
+        await navigator.clipboard.writeText(issued.loginUrl);
+        showNotice("URL di accesso copiato negli appunti.");
+      });
+      showNotice(`URL di accesso generato. Scade alle ${new Date(issued.expiresAt).toLocaleTimeString()}.`);
+    });
+  };
+  const setGdprButton = document.getElementById("set-gdpr");
+  if (setGdprButton) setGdprButton.onclick = () => handleAction(async () => {
+    if (!window.confirm(`Registrare il consenso GDPR per ${user.email}?`)) return;
+    await setGdpr(codiceUtente);
+    showNotice("Consenso GDPR registrato.");
+    await showUser(String(codiceUtente));
+  });
+  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 });
+        showNotice("Collegamento SSO registrato.");
+        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" });
+        showNotice("Collegamento SSO aggiornato.");
+        await showUser(String(codiceUtente));
+      });
+    });
+    document.querySelectorAll("[data-identity-delete]").forEach((button) => {
+      button.onclick = () => handleAction(async () => {
+        if (!window.confirm("Eliminare definitivamente questo collegamento SSO? L\u2019utente Accessi non verr\xE0 eliminato.")) return;
+        await deleteFederatedIdentityPermanently(codiceUtente, button.dataset.identityDelete ?? "");
+        showNotice("Collegamento SSO eliminato definitivamente.");
+        await showUser(String(codiceUtente));
+      });
+    });
+  }
+  const userStateForm = document.getElementById("user-state-form");
+  if (userStateForm) userStateForm.onsubmit = (event) => {
+    event.preventDefault();
+    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");
+  });
+  const purgeUser = document.getElementById("purge-user");
+  if (purgeUser) purgeUser.onclick = () => handleAction(async () => {
+    if (!window.confirm(`Eliminare DEFINITIVAMENTE l'utente ${user.email} e tutti i dati collegati? Operazione irreversibile.`)) return;
+    await deleteUserPermanently(codiceUtente);
+    showNotice("Utente eliminato definitivamente.");
+    await show("users");
+  });
+  if (!manageable) setUserManagementEnabled(false);
+}
+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 = (event) => {
+      event.preventDefault();
+      handleAction(async () => {
+        const form = eventForm(event);
+        const data = new FormData(form);
+        const menu = Array.from(data.getAll("menu"), (codiceMenu) => ({ codiceMenu: String(codiceMenu), tipoAbilitazione: Number(data.get(`menu-level:${codiceMenu}`) ?? 10) }));
+        if (menu.length === 0) throw new Error("Seleziona almeno un menu per il ruolo.");
+        const request = { descrizioneRuolo: formValues(form).descrizione ?? "", menu };
+        if (role?.codiceRuolo) await updateRole(role.codiceRuolo, request);
+        else await createRole(request);
+        showNotice(role?.codiceRuolo ? "Ruolo aggiornato." : "Ruolo creato.");
+        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 showMenuScopes() {
+  const scopes = result(await getScopes());
+  render(`<div class="toolbar"><button id="new-scope">Nuovo scope</button><button id="reload-scopes" class="secondary">Aggiorna</button></div>
+    <h2>Scope applicativi</h2><p class="form-help">Uno scope decide in quali applicazioni un menu e visibile. Un menu puo appartenere a piu scope.</p>
+    <table class="entity-table"><thead><tr><th>Codice</th><th>Nome</th><th>Azioni</th></tr></thead><tbody>
+      ${scopes.map((scope) => `<tr><td><code>${escapeHtml(scope.codice)}</code></td><td>${escapeHtml(scope.nome)}</td><td class="row-actions"><button type="button" class="secondary" data-scope-menus="${escapeHtml(scope.codice)}">Menu</button><button type="button" class="secondary" data-scope-edit="${escapeHtml(scope.codice)}">Rinomina</button><button type="button" class="danger-button" data-scope-delete="${escapeHtml(scope.codice)}">Elimina</button></td></tr>`).join("") || '<tr><td colspan="3">Nessuno scope configurato.</td></tr>'}
+    </tbody></table>`);
+  byId("new-scope").onclick = () => showScopeForm();
+  byId("reload-scopes").onclick = () => handleAction(showMenuScopes);
+  document.querySelectorAll("[data-scope-menus]").forEach((button) => {
+    button.onclick = () => handleAction(() => showScopeMenus(button.dataset.scopeMenus ?? ""));
+  });
+  document.querySelectorAll("[data-scope-edit]").forEach((button) => {
+    button.onclick = () => showScopeForm(scopes.find((scope) => scope.codice === button.dataset.scopeEdit));
+  });
+  document.querySelectorAll("[data-scope-delete]").forEach((button) => {
+    button.onclick = () => handleAction(async () => {
+      if (!window.confirm(`Eliminare lo scope ${button.dataset.scopeDelete}? Le associazioni ai menu verranno rimosse.`)) return;
+      await deleteScope(button.dataset.scopeDelete ?? "");
+      showNotice("Scope eliminato.");
+      await showMenuScopes();
+    });
+  });
+}
+function showScopeForm(scope) {
+  render(`<form id="scope-form"><h2>${scope ? "Rinomina scope" : "Nuovo scope"}</h2>
+    <label>Codice<input name="codice" maxlength="20" required ${scope ? "readonly" : ""} value="${escapeHtml(scope?.codice ?? "")}"><span class="form-help">Es. STEX. Maiuscole, cifre e underscore.</span></label>
+    <label>Nome<input name="nome" maxlength="100" required value="${escapeHtml(scope?.nome ?? "")}"><span class="form-help">Etichetta leggibile, es. SteX.</span></label>
+    <div class="toolbar"><button>Salva</button><button type="button" class="secondary" id="cancel-scope">Annulla</button></div></form>`);
+  const form = byId("scope-form");
+  form.onsubmit = (event) => {
+    event.preventDefault();
+    handleAction(async () => {
+      const values = formValues(form);
+      const nome = values["nome"] ?? "";
+      if (scope) {
+        await updateScope(scope.codice, { nome });
+      } else {
+        await createScope({ codice: (values["codice"] ?? "").trim().toUpperCase(), nome });
+      }
+      showNotice("Scope salvato.");
+      await showMenuScopes();
+    });
+  };
+  byId("cancel-scope").onclick = () => handleAction(showMenuScopes);
+}
+async function showScopeMenus(codiceScope) {
+  const [groupsResponse, assignedResponse] = await Promise.all([
+    getGroupsWithMenus({ includeDisabled: true }),
+    getMenuScopes(codiceScope)
+  ]);
+  const groups = result(groupsResponse);
+  const assigned = new Set(result(assignedResponse));
+  render(`<form id="scope-menus"><h2>Menu dello scope ${escapeHtml(codiceScope)}</h2><p class="form-help">Seleziona i menu visibili nelle applicazioni associate a questo scope. Il salvataggio sostituisce l'elenco.</p>
+    ${groups.map((group) => `<fieldset class="grant-menu-group"><legend>${escapeHtml(group.descrizioneGruppo)}</legend>${group.menus.map((menu) => `<label class="check"><input type="checkbox" name="menu" value="${escapeHtml(menu.codiceMenu)}" ${assigned.has(menu.codiceMenu) ? "checked" : ""}><span>${escapeHtml(menu.descrizioneMenu)} <code>${escapeHtml(menu.codiceMenu)}</code></span></label>`).join("")}</fieldset>`).join("")}
+    <div class="toolbar"><button>Salva</button><button type="button" class="secondary" id="cancel-scope-menus">Indietro</button></div></form>`);
+  const form = byId("scope-menus");
+  form.onsubmit = (event) => {
+    event.preventDefault();
+    handleAction(async () => {
+      const selected = new FormData(form).getAll("menu").map((value) => String(value));
+      await setScopeMenus(codiceScope, { menu: selected });
+      showNotice("Menu dello scope aggiornati.");
+      await showMenuScopes();
+    });
+  };
+  byId("cancel-scope-menus").onclick = () => handleAction(showMenuScopes);
+}
+async function showMenuTypes() {
+  const menuTypes = result(await getMenuTypes());
+  render(`<div class="toolbar"><button id="new-menu-type">Nuovo tipo menu</button><button id="reload-menu-types" class="secondary">Aggiorna</button></div>
+    <h2>Tipi menu</h2><p class="form-help">Classificano i menu (es. amministrazione, operativit\xE0). Un tipo si elimina solo se non \xE8 usato da alcun menu.</p>
+    ${menuTypeTable(menuTypes)}`);
+  byId("new-menu-type").onclick = () => showMenuTypeForm();
+  byId("reload-menu-types").onclick = () => handleAction(showMenuTypes);
+  document.querySelectorAll("[data-type-edit]").forEach((button) => {
+    button.onclick = () => showMenuTypeForm(menuTypes.find((type) => type.codiceTipo === button.dataset.typeEdit));
+  });
+  document.querySelectorAll("[data-type-delete]").forEach((button) => {
+    button.onclick = () => handleAction(async () => {
+      if (!window.confirm(`Eliminare il tipo menu ${button.dataset.typeDelete}? Operazione possibile solo se nessun menu lo utilizza.`)) return;
+      await deleteMenuType(button.dataset.typeDelete ?? "");
+      showNotice("Tipo menu eliminato.");
+      await showMenuTypes();
+    });
+  });
+}
+function showMenuGroupForm(group) {
+  const isExisting = group !== void 0;
+  render(`<button id="back" type="button">Indietro</button><h2>${isExisting ? "Modifica" : "Nuovo"} gruppo menu</h2>
+    <form id="group-form">
+      <label>Codice gruppo ${helpDot("menu-group-code")}<input name="codiceGruppo" maxlength="1" value="${escapeHtml(group?.codiceGruppo)}" ${isExisting ? "readonly" : ""} required><span class="form-help">Un solo carattere, es. <code>A</code>. Immutabile dopo la creazione.</span></label>
+      <label>Descrizione<input name="descrizioneGruppo" maxlength="100" value="${escapeHtml(group?.descrizioneGruppo)}" required></label>
+      <label>Ordine ${helpDot("menu-group-order")}<input name="ordineGruppo" type="number" value="${group?.ordineGruppo ?? ""}"><span class="form-help">Usato per ordinare i gruppi nella navigazione.</span></label>
+      <label class="check"><input name="enabled" type="checkbox" ${group?.enabled !== false ? "checked" : ""}> Gruppo abilitato ${helpDot("menu-group-enabled")}</label>
+      <button>${isExisting ? "Salva gruppo" : "Crea gruppo"}</button>
+    </form>`);
+  byId("back").onclick = () => handleAction(showMenuGroups);
+  const form = document.getElementById("group-form");
+  if (form) {
+    form.onsubmit = (event) => {
+      event.preventDefault();
+      handleAction(async () => {
+        const values = formValues(eventForm(event));
+        const payload = {
+          descrizioneGruppo: values.descrizioneGruppo || void 0,
+          ordineGruppo: values.ordineGruppo ? Number(values.ordineGruppo) : void 0,
+          enabled: new FormData(eventForm(event)).has("enabled")
+        };
+        if (isExisting) await updateMenuGroup(group.codiceGruppo, payload);
+        else await createMenuGroup({ codiceGruppo: values.codiceGruppo ?? "", ...payload });
+        showNotice(isExisting ? "Gruppo aggiornato." : "Gruppo creato.");
+        await showMenuGroups();
+      });
+    };
+  }
+}
+function showMenuForm(menu, groups, menuTypes) {
+  const isExisting = menu !== void 0;
+  const groupOptions = groups.map((group) => `<option value="${escapeHtml(group.codiceGruppo)}" ${menu?.codiceGruppo === group.codiceGruppo ? "selected" : ""}>${escapeHtml(group.codiceGruppo)} \u2013 ${escapeHtml(group.descrizioneGruppo)}</option>`).join("");
+  const typeOptions = `<option value="">Nessun tipo</option>${menuTypes.map((type) => `<option value="${escapeHtml(type.codiceTipo)}" ${menu?.tipo === type.codiceTipo ? "selected" : ""}>${escapeHtml(type.codiceTipo)} \u2013 ${escapeHtml(type.descrizioneTipo || "")}</option>`).join("")}`;
+  render(`<button id="back" type="button">Indietro</button><h2>${isExisting ? "Modifica" : "Nuovo"} menu</h2>
+    <form id="menu-form">
+      <label>Codice menu ${helpDot("menu-code")}<input name="codiceMenu" maxlength="20" value="${escapeHtml(menu?.codiceMenu)}" ${isExisting ? "readonly" : ""} required><span class="form-help">Chiave tecnica, es. <code>MNU001</code>. Immutabile dopo la creazione.</span></label>
+      <label>Descrizione<input name="descrizioneMenu" maxlength="100" value="${escapeHtml(menu?.descrizioneMenu)}" required></label>
+      <label>Gruppo ${helpDot("menu-group-select")}<select name="codiceGruppo" required>${groupOptions}</select><span class="form-help">Crea prima un gruppo se non ne esistono.</span></label>
+      <label>Tipo menu ${helpDot("menu-type-select")}<select name="tipo">${typeOptions}</select></label>
+      <label>Icona ${helpDot("menu-icon")}<input name="icona" maxlength="50" value="${escapeHtml(menu?.icona)}"><span class="form-help">Identificatore icona usato dalla UI host.</span></label>
+      <label>Pagina ${helpDot("menu-page")}<input name="pagina" maxlength="50" value="${escapeHtml(menu?.pagina)}"><span class="form-help">Percorso o pagina associata al menu.</span></label>
+      <label>Ordine ${helpDot("menu-order")}<input name="ordineMenu" type="number" value="${menu?.ordineMenu ?? ""}"></label>
+      <label>Menu di riferimento ${helpDot("menu-rifmenu")}<input name="rifMenu" maxlength="20" value="${escapeHtml(menu?.rifMenu)}"><span class="form-help">Codice di un menu padre, opzionale.</span></label>
+      <label>Nota ${helpDot("menu-note")}<textarea name="note" rows="3" maxlength="1000">${escapeHtml(menu?.note)}</textarea></label>
+      <label class="check"><input name="enabled" type="checkbox" ${menu?.enabled !== false ? "checked" : ""}> Menu abilitato ${helpDot("menu-enabled")}</label>
+      <button>${isExisting ? "Salva menu" : "Crea menu"}</button>
+    </form>`);
+  byId("back").onclick = () => handleAction(showMenuItems);
+  const form = document.getElementById("menu-form");
+  if (form) {
+    form.onsubmit = (event) => {
+      event.preventDefault();
+      handleAction(async () => {
+        const values = formValues(eventForm(event));
+        const payload = {
+          descrizioneMenu: values.descrizioneMenu || void 0,
+          codiceGruppo: values.codiceGruppo ?? "",
+          tipo: values.tipo || void 0,
+          icona: values.icona || void 0,
+          pagina: values.pagina || void 0,
+          ordineMenu: values.ordineMenu ? Number(values.ordineMenu) : void 0,
+          rifMenu: values.rifMenu || void 0,
+          note: values.note || void 0,
+          enabled: new FormData(eventForm(event)).has("enabled")
+        };
+        if (isExisting) await updateMenu(menu.codiceMenu, payload);
+        else await createMenu({ codiceMenu: values.codiceMenu ?? "", ...payload });
+        showNotice(isExisting ? "Menu aggiornato." : "Menu creato.");
+        await showMenuItems();
+      });
+    };
+  }
+}
+function showMenuTypeForm(type) {
+  const isExisting = type !== void 0;
+  render(`<button id="back" type="button">Indietro</button><h2>${isExisting ? "Modifica" : "Nuovo"} tipo menu</h2>
+    <form id="menu-type-form">
+      <label>Codice tipo ${helpDot("menu-type-code")}<input name="codiceTipo" maxlength="1" value="${escapeHtml(type?.codiceTipo)}" ${isExisting ? "readonly" : ""} required><span class="form-help">Un solo carattere, es. <code>A</code>. Immutabile dopo la creazione.</span></label>
+      <label>Descrizione<input name="descrizioneTipo" maxlength="20" value="${escapeHtml(type?.descrizioneTipo)}"></label>
+      <button>${isExisting ? "Salva tipo" : "Crea tipo"}</button>
+    </form>`);
+  byId("back").onclick = () => handleAction(showMenuTypes);
+  const form = document.getElementById("menu-type-form");
+  if (form) {
+    form.onsubmit = (event) => {
+      event.preventDefault();
+      handleAction(async () => {
+        const values = formValues(eventForm(event));
+        if (isExisting) await updateMenuType(type.codiceTipo, { descrizioneTipo: values.descrizioneTipo || void 0 });
+        else await createMenuType({ codiceTipo: values.codiceTipo ?? "", descrizioneTipo: values.descrizioneTipo || void 0 });
+        showNotice(isExisting ? "Tipo menu aggiornato." : "Tipo menu creato.");
+        await showMenuTypes();
+      });
+    };
+  }
+}
+function 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 ?? ""));
+      showNotice("Token di servizio ruotato.");
+      showIssuedServiceToken(issued);
+    });
+  });
+}
+function showServiceTokenForm() {
+  render(`<button id="back" type="button" class="secondary">Indietro</button><h2>Nuovo token di servizio</h2><form id="token-form"><label>Descrizione ${helpDot("token-label")}<input name="label" required maxlength="100"><span class="form-help">Identifica l'integrazione, ad esempio "IA - produzione".</span></label><label>Scope ${helpDot("token-scopes")}<input name="scopes" placeholder="ia, chat"><span class="form-help">Separati da virgola (lettere, numeri, ':', '_', '-'). Definiscono cosa pu\xF2 fare il token.</span></label><label>Durata in giorni ${helpDot("token-ttl")}<input name="ttlDays" type="number" min="1" step="1"><span class="form-help">Opzionale. Lascia vuoto per un token senza scadenza.</span></label><button>Crea token</button></form>`);
+  byId("back").onclick = () => void show("tokens");
+  const form = document.getElementById("token-form");
+  if (form) form.onsubmit = (event) => {
+    event.preventDefault();
+    handleAction(async () => {
+      const values = formValues(eventForm(event));
+      const scopes = (values.scopes ?? "").split(",").map((scope) => scope.trim()).filter(Boolean);
+      const ttlDays = values.ttlDays ? Number(values.ttlDays) : void 0;
+      const issued = result(await createServiceToken({
+        label: values.label ?? "",
+        scopes: scopes.length ? scopes : void 0,
+        ttlDays: Number.isFinite(ttlDays) ? ttlDays : void 0
+      }));
+      showNotice("Token di servizio creato.");
+      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(`<article class="wiki-content markdown-body changelog-page">
+    <header class="wiki-section-head"><h2>Changelog</h2><p>Novita e modifiche rilevanti del modulo Accessi.</p></header>
+    ${renderMarkdown(changelog_default)}
+  </article>`);
+}
+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 {
+    const views = {
+      users: showUsers,
+      roles: showRoles,
+      menuGroups: showMenuGroups,
+      menuItems: showMenuItems,
+      menuTypes: showMenuTypes,
+      menuScopes: showMenuScopes,
+      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 = () => {
+  void (async () => {
+    if (cookieMode) {
+      await revokeToken({}).catch(() => void 0);
+    }
+    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_UNAUTHORIZED_EVENT, () => {
+  if (!token && !cookieMode) return;
+  token = null;
+  currentUser = null;
+  setAccessiConsoleToken(null);
+  sessionStorage.removeItem("accessi-console-token");
+  finishBoot("login");
+  resetLogin();
+  byId("login-error").textContent = "Sessione scaduta o non piu valida. Accedi di nuovo.";
+});
+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);
+void applyAdminBootstrapVisibility();
+var entryTicket = /^#entry=([a-f0-9]{64})$/i.exec(window.location.hash)?.[1];
+var ssoChallenge = /^#two-factor=([a-f0-9]{64})$/.exec(window.location.hash)?.[1];
+if (entryTicket) {
+  window.history.replaceState(null, "", window.location.pathname);
+  void exchangeConsoleEntry(entryTicket);
+} else 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 || cookieMode) {
+  void bootstrap();
+} else {
+  finishBoot("login");
+}