@sd-angular/core 19.0.35 → 19.0.38

package/fesm2022/sd-angular-core-modules-authom.mjs

@@ -1,251 +1,695 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, PLATFORM_ID, signal, computed, Injectable, provideAppInitializer, makeEnvironmentProviders, APP_INITIALIZER, NgModule } from '@angular/core';
+import { InjectionToken, inject, PLATFORM_ID, DestroyRef, signal, computed, Injectable, provideAppInitializer, makeEnvironmentProviders, APP_INITIALIZER, NgModule } from '@angular/core';
 import { isPlatformBrowser } from '@angular/common';
-import { StringUtilities } from '@sdcorejs/utils/fns';
+import { OAuthService, OAuthErrorEvent, provideOAuthClient } from 'angular-oauth2-oidc';
+import { Subject, from, switchMap, catchError, throwError, map, of } from 'rxjs';
+import { HttpErrorResponse } from '@angular/common/http';
+import { toObservable } from '@angular/core/rxjs-interop';
+import { SD_AUTH_CONFIGURATION } from '@sd-angular/core/modules/auth';
 
 const SD_AUTHOM_CONFIGURATION = new InjectionToken('sd-authom.configuration');
+/** Scope mặc định. `offline_access` giữ cho token endpoint phát hành refresh_token. */
+const SD_AUTHOM_DEFAULT_SCOPE = 'openid profile email offline_access';
+/** Tỷ lệ vòng đời token mà tại đó refresh chủ động được kích hoạt. */
+const SD_AUTHOM_DEFAULT_TIMEOUT_FACTOR = 0.75;
+/** Timeout mặc định của silent refresh bằng iframe, tính bằng giây. */
+const SD_AUTHOM_DEFAULT_SILENT_REFRESH_TIMEOUT_SECONDS = 20;
 
-const STORAGE_KEY_STATE = 'authom_state';
-const STORAGE_KEY_CODE_VERIFIER = 'authom_code_verifier';
-const STORAGE_KEY_RETURN_TO = 'authom_return_to';
-const DEFAULT_SCOPE = 'openid profile email';
-const DEFAULT_REFRESH_THRESHOLD_SECONDS = 30;
-const DEFAULT_AUTHORIZE_TIMEOUT_SECONDS = 5;
-class SdAuthOmService {
-    platformId = inject(PLATFORM_ID);
-    isBrowser = isPlatformBrowser(this.platformId);
-    accessToken = signal(null);
-    idTokenClaims = signal(null);
-    isAuthenticated = computed(() => this.accessToken() !== null);
-    config;
-    refreshTimer = null;
-    getAccessToken() {
-        return this.accessToken();
+/**
+ * Giữ deep link sống sót qua vòng redirect đăng nhập.
+ *
+ * AuthOM chỉ chấp nhận một `redirect_uri` đã đăng ký (các portal hiện dùng `/callback`), nên một
+ * user mở thẳng link sâu mà chưa có token sẽ mất đích đến: guard gọi code flow, cookie SSO của
+ * AuthOM trả lời ngay không cần hỏi, và trình duyệt quay về `/callback` rồi bị route mặc định đẩy
+ * sang trang chủ.
+ *
+ * Đích đến đi kèm tham số OIDC `state` (IdP round-trip nguyên vẹn) chứ không nằm trong storage:
+ * như vậy nó gắn với đúng một lần đăng nhập, không thể cũ đi và không rò sang điều hướng khác.
+ */
+/** Đường dẫn callback mặc định — khôi phục nó chỉ khiến user bị đẩy về trang chủ lần nữa. */
+const DEFAULT_CALLBACK_PATH = '/callback';
+/**
+ * Mã hoá trang mà user thực sự muốn vào, để gửi kèm `initCodeFlow`.
+ *
+ * Trả về `undefined` khi không có gì đáng khôi phục — lúc đó caller khởi động đăng nhập bình thường.
+ *
+ * Giá trị trả về là chuỗi THÔ, cố ý không percent-encode: client OIDC đã tự
+ * `encodeURIComponent(additionalState)` trước khi ghép vào `state`, và chuỗi giải mã của nó chỉ bóc
+ * đúng một lớp. Encode thêm ở đây làm giá trị quay về dạng double-encoded (`%252F...`) và
+ * `resolveReturnUrl` sẽ loại bỏ nó.
+ */
+function captureReturnUrl(requestedUrl, callbackPath = DEFAULT_CALLBACK_PATH) {
+    const url = requestedUrl?.trim();
+    if (!url || !isRestorableAppUrl(url, callbackPath)) {
+        return undefined;
     }
-    base64UrlEncode(bytes) {
-        let binary = '';
-        for (let i = 0; i < bytes.length; i++)
-            binary += String.fromCharCode(bytes[i]);
-        return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-    }
-    generateCodeVerifier() {
-        const bytes = new Uint8Array(32);
-        crypto.getRandomValues(bytes);
-        return this.base64UrlEncode(bytes);
-    }
-    async generateCodeChallenge(verifier) {
-        return StringUtilities.sha256(verifier);
-    }
-    buildAuthorizeUrl(params) {
-        const search = new URLSearchParams({
-            response_type: 'code',
-            client_id: this.config.clientId,
-            redirect_uri: params.redirectUri,
-            state: params.state,
-            code_challenge: params.codeChallenge,
-            code_challenge_method: 'S256',
-            scope: this.config.scope || DEFAULT_SCOPE,
-        });
-        if (this.config.audience)
-            search.set('audience', this.config.audience);
-        if (this.config.organization)
-            search.set('organization', this.config.organization);
-        if (params.prompt)
-            search.set('prompt', params.prompt);
-        return `https://${this.config.domain}/authorize?${search.toString()}`;
+    return url;
+}
+/**
+ * Đọc lại giá trị mà `captureReturnUrl` đã gửi đi; trả `null` khi `state` rỗng hoặc không khôi phục được.
+ *
+ * Một lần `decodeURIComponent` để bóc lớp mã hoá mà client OIDC áp lên phần state của app; lớp ngoài
+ * bọc cả tham số đã được chính nó gỡ trước khi giá trị tới đây. Chuỗi không mã hoá sẽ giải mã ra
+ * chính nó, nên hàm vẫn đúng trong cả hai trường hợp.
+ */
+function resolveReturnUrl(state, callbackPath = DEFAULT_CALLBACK_PATH) {
+    const raw = state?.trim();
+    if (!raw) {
+        return null;
+    }
+    let url;
+    try {
+        url = decodeURIComponent(raw);
+    }
+    catch {
+        // why: percent-encoding hỏng — bị can thiệp trên đường truyền hoặc IdP làm méo.
+        // Bỏ hẳn thay vì đoán đích đến.
+        return null;
+    }
+    return isRestorableAppUrl(url, callbackPath) ? url : null;
+}
+/**
+ * `state` đi vòng qua IdP nên kẻ tấn công có thể tác động; chỉ chấp nhận path nằm trong chính app này.
+ *
+ * URL tuyệt đối hoặc protocol-relative (`//evil.example`, hoặc `/\evil.example` — trình duyệt tự
+ * chuẩn hoá dấu gạch ngược) sẽ biến vòng đăng nhập thành open redirect.
+ */
+function isRestorableAppUrl(url, callbackPath = DEFAULT_CALLBACK_PATH) {
+    if (!url.startsWith('/') || url.startsWith('//') || url.startsWith('/\\')) {
+        return false;
+    }
+    // why: ký tự điều khiển (CR/LF/NUL/DEL) trong path mở đường cho header hoặc log injection.
+    if ([...url].some(character => character.charCodeAt(0) < 0x20 || character.charCodeAt(0) === 0x7f)) {
+        return false;
+    }
+    return url.split(/[?#]/)[0] !== callbackPath;
+}
+
+/**
+ * Đồng bộ đăng xuất giữa các tab cùng origin.
+ *
+ * Phiên AuthOM sống trong bộ nhớ của client OIDC, có `sessionStorage` làm nền — mà `sessionStorage`
+ * bị trình duyệt cô lập theo tab. Không có server-side session để thu hồi (AuthOM không công bố
+ * `end_session_endpoint`) và cũng không có cơ chế kiểm tra liveness xuyên tab. Hệ quả: đăng xuất ở
+ * một tab để các tab còn lại dùng được bình thường cho tới khi access token của chính chúng hết hạn.
+ *
+ * `BroadcastChannel` không bao giờ gửi message ngược về đối tượng đã post, nên tab kích hoạt đăng
+ * xuất không tự xử lý lại sự kiện của chính nó.
+ */
+const LOGOUT_MESSAGE_TYPE = 'sd-authom:logout';
+/**
+ * Bọc `BroadcastChannel` cho tín hiệu đăng xuất, và tự vô hiệu hoá khi môi trường không hỗ trợ
+ * (SSR, trình duyệt cũ, `BroadcastChannel` bị chặn).
+ */
+class SdAuthOmSessionChannel {
+    #channel;
+    constructor(name) {
+        this.#channel = SdAuthOmSessionChannel.#create(name);
+    }
+    /** `true` khi môi trường thực sự hỗ trợ kênh; `false` thì mọi thao tác là no-op. */
+    get enabled() {
+        return this.#channel !== null;
     }
-    getDefaultRedirectUri() {
-        return this.config.redirectUri || window.location.origin;
+    /** Báo cho mọi tab khác rằng phiên vừa kết thúc. */
+    notifyLogout() {
+        const message = { type: LOGOUT_MESSAGE_TYPE };
+        this.#channel?.postMessage(message);
+    }
+    /** Đăng ký callback chạy khi một tab khác báo đã đăng xuất. */
+    onLogout(handler) {
+        if (!this.#channel) {
+            return;
+        }
+        this.#channel.onmessage = (event) => {
+            if (event.data?.type === LOGOUT_MESSAGE_TYPE) {
+                handler();
+            }
+        };
     }
-    getSilentRedirectUri() {
-        return this.config.silentRefreshRedirectUri || `${window.location.origin}/silent-authom.html`;
+    close() {
+        this.#channel?.close();
     }
-    decodeJwtPayload(token) {
+    static #create(name) {
+        if (typeof BroadcastChannel === 'undefined') {
+            return null;
+        }
         try {
-            const parts = token.split('.');
-            if (parts.length !== 3)
-                return null;
-            const padded = parts[1].replace(/-/g, '+').replace(/_/g, '/');
-            const json = atob(padded + '==='.slice((padded.length + 3) % 4));
-            return JSON.parse(json);
+            return new BroadcastChannel(name);
         }
         catch {
+            // why: một số trình duyệt ném khi site data bị chặn. Đăng xuất xuyên tab là tính năng
+            // phụ trợ, không được phép làm hỏng bootstrap.
             return null;
         }
     }
+}
+
+/** Sự kiện của client OIDC được coi là lỗi xác thực ngoài luồng refresh. */
+const AUTH_ERROR_EVENT_TYPES = new Set([
+    'discovery_document_load_error',
+    'discovery_document_validation_error',
+    'jwks_load_error',
+    'invalid_nonce_in_state',
+    'code_error',
+    'token_error',
+    'token_validation_error',
+]);
+/** Sự kiện của client OIDC báo một lần gia hạn token thất bại. */
+const REFRESH_ERROR_EVENT_TYPES = new Set(['token_refresh_error', 'silent_refresh_error', 'silent_refresh_timeout']);
+/**
+ * Client xác thực AuthOM: Authorization Code + PKCE trên discovery document của IdP.
+ *
+ * Service sở hữu toàn bộ vòng đời phiên — bootstrap, khôi phục deep link, gia hạn token chủ động,
+ * phát hiện hết phiên, đăng xuất xuyên tab — nên app chỉ cần khai báo cấu hình tenant.
+ */
+class SdAuthOmService {
+    #platformId = inject(PLATFORM_ID);
+    #isBrowser = isPlatformBrowser(this.#platformId);
+    #destroyRef = inject(DestroyRef);
+    /**
+     * Optional để một app chỉ đăng ký `SdAuthOmInterceptor` mà quên `provideSdAuthOm()` thì bị hỏng
+     * đúng luồng đăng nhập, chứ không ném NullInjectorError trên mọi HTTP request.
+     */
+    #oauth = inject(OAuthService, { optional: true });
+    /** Cấu hình tenant đang dùng. `undefined` cho tới khi `init()` chạy xong. */
+    config;
+    accessToken = signal(null);
+    idTokenClaims = signal(null);
+    isAuthenticated = computed(() => this.accessToken() !== null);
+    /** `true` khi gia hạn đã thất bại VÀ access token cuối cùng cũng đã hết hạn. */
+    sessionExpired = signal(false);
+    /** Sự kiện `auth_error` gần nhất, hoặc `null` khi lần đăng nhập gần nhất sạch. */
+    lastAuthError = signal(null);
+    #events = new Subject();
+    /** Luồng sự kiện xác thực. Xem `SdAuthOmEventType`. */
+    events$ = this.#events.asObservable();
+    #channel = null;
+    #eventsSubscription = null;
+    #expiryCheckTimer = null;
+    #inFlightRefresh = null;
+    #initialized = false;
+    constructor() {
+        this.#destroyRef.onDestroy(() => this.#teardown());
+    }
+    // ---------------------------------------------------------------------------------------------
+    // Bootstrap
+    // ---------------------------------------------------------------------------------------------
+    /**
+     * Cấu hình client, tải discovery document, xử lý callback nếu có, rồi bật gia hạn chủ động.
+     *
+     * Chạy trong APP_INITIALIZER (xem `provideSdAuthOm`), tức trước điều hướng đầu tiên của Router —
+     * nhờ vậy guard của route đầu tiên đã thấy trạng thái phiên đúng.
+     *
+     * @returns `true` khi kết thúc với một access token hợp lệ.
+     */
+    async init(config) {
+        this.config = config;
+        if (!this.#isBrowser || !this.#oauth) {
+            return false;
+        }
+        const authErrorHref = config.authErrorUrl ? this.#toPublicHtmlUrl(config.authErrorUrl) : null;
+        // why: đang đứng sẵn ở trang lỗi thì KHÔNG init lại, tránh vòng lặp redirect khi IdP sập lâu.
+        if (authErrorHref && window.location.pathname === new URL(authErrorHref).pathname) {
+            return false;
+        }
+        this.#oauth.configure(this.buildAuthConfig(config));
+        if (!this.#initialized) {
+            this.#initialized = true;
+            this.#subscribeOAuthEvents();
+        }
+        try {
+            await this.#oauth.loadDiscoveryDocumentAndTryLogin();
+        }
+        catch (error) {
+            this.#emitAuthError('discovery_document_load_error', error);
+            if (authErrorHref) {
+                this.navigate(authErrorHref);
+            }
+            return false;
+        }
+        this.#restoreReturnUrl();
+        this.#syncFromOAuth();
+        this.#emit('ready');
+        this.#oauth.setupAutomaticSilentRefresh({}, 'access_token');
+        if (config.crossTabLogout !== false) {
+            this.#listenCrossTabLogout(config);
+        }
+        return this.isAuthenticated();
+    }
+    /**
+     * Quy đổi cấu hình tenant sang `AuthConfig` của client OIDC.
+     *
+     * Public để app kiểm tra được cấu hình thực tế trong test mà không phải chạy cả `init()`.
+     */
+    buildAuthConfig(config) {
+        const audience = config.audience?.trim();
+        const silentRefreshSeconds = config.silentRefreshTimeoutInSeconds ?? config.authorizeTimeoutInSeconds ?? SD_AUTHOM_DEFAULT_SILENT_REFRESH_TIMEOUT_SECONDS;
+        const authConfig = {
+            issuer: this.#resolveIssuer(config),
+            clientId: config.clientId,
+            redirectUri: config.redirectUri || window.location.origin,
+            postLogoutRedirectUri: config.postLogoutRedirectUri || window.location.origin,
+            responseType: 'code',
+            scope: config.scope || SD_AUTHOM_DEFAULT_SCOPE,
+            // why: giữ bật (mặc định của client OIDC). Discovery document thật của AuthOM QC đặt mọi
+            // endpoint trong cây issuer nên phép kiểm tra này đi qua; chỉ tenant nào công bố endpoint
+            // ngoài cây issuer mới cần tắt.
+            strictDiscoveryDocumentValidation: config.strictDiscoveryDocumentValidation ?? true,
+            // why: 'remoteOnly' vẫn ép HTTPS với IdP thật nhưng cho phép chạy dev trên localhost.
+            requireHttps: config.requireHttps ?? 'remoteOnly',
+            showDebugInformation: config.showDebugInformation ?? false,
+            timeoutFactor: config.timeoutFactor ?? SD_AUTHOM_DEFAULT_TIMEOUT_FACTOR,
+            silentRefreshTimeout: silentRefreshSeconds * 1000,
+            useSilentRefresh: config.useSilentRefresh ?? false,
+            clearHashAfterLogin: true,
+        };
+        if (config.refreshThresholdSeconds !== undefined) {
+            // why: client OIDC đo ngưỡng refresh bằng "coi token hết hạn sớm N giây", không có
+            // tham số "refresh trước exp N giây" riêng. Hai cách diễn đạt cho cùng một hành vi.
+            authConfig.decreaseExpirationBySec = config.refreshThresholdSeconds;
+        }
+        if (config.clockSkewInSec !== undefined) {
+            authConfig.clockSkewInSec = config.clockSkewInSec;
+        }
+        if (config.useSilentRefresh) {
+            authConfig.silentRefreshRedirectUri = config.silentRefreshRedirectUri || `${window.location.origin}/silent-authom.html`;
+        }
+        // why: customQueryParams được gắn vào CẢ /authorize, CẢ lần đổi code lấy token, CẢ refresh —
+        // đó là đường duy nhất để `audience` bắt buộc của AuthOM tới được token endpoint.
+        const customQueryParams = { ...(config.customQueryParams ?? {}) };
+        if (audience) {
+            customQueryParams['audience'] = audience;
+        }
+        if (Object.keys(customQueryParams).length > 0) {
+            authConfig.customQueryParams = customQueryParams;
+        }
+        return authConfig;
+    }
+    // ---------------------------------------------------------------------------------------------
+    // Đăng nhập / đăng xuất
+    // ---------------------------------------------------------------------------------------------
+    /**
+     * Khởi động Authorization Code flow.
+     *
+     * `returnTo` mặc định là URL hiện tại, đi kèm tham số OIDC `state` để deep link sống sót qua
+     * vòng redirect (xem `authom.return-url.ts`).
+     */
     async login(options) {
-        if (!this.isBrowser)
+        if (!this.#isBrowser || !this.#oauth) {
             return;
-        const state = crypto.randomUUID();
-        const codeVerifier = this.generateCodeVerifier();
-        const codeChallenge = await this.generateCodeChallenge(codeVerifier);
-        const returnTo = options?.returnTo || (window.location.pathname + window.location.search);
-        sessionStorage.setItem(STORAGE_KEY_STATE, state);
-        sessionStorage.setItem(STORAGE_KEY_CODE_VERIFIER, codeVerifier);
-        sessionStorage.setItem(STORAGE_KEY_RETURN_TO, returnTo);
-        window.location.href = this.buildAuthorizeUrl({
-            state,
-            codeChallenge,
-            redirectUri: this.getDefaultRedirectUri(),
-        });
+        }
+        const requested = options?.returnTo ?? `${window.location.pathname}${window.location.search}${window.location.hash}`;
+        this.#oauth.initCodeFlow(captureReturnUrl(requested), this.#authorizeParams(options?.prompt));
     }
+    /**
+     * Kết thúc phiên cục bộ rồi (mặc định) bắt đăng nhập lại với `prompt=login`.
+     *
+     * AuthOM không công bố `end_session_endpoint` và không hỗ trợ thu hồi token, nên đăng xuất
+     * KHÔNG gọi endpoint nào của IdP trừ khi `endSessionOnLogout` được bật rõ ràng.
+     */
     logout(options) {
-        if (!this.isBrowser)
+        if (!this.#isBrowser || !this.#oauth) {
             return;
-        this.accessToken.set(null);
-        this.idTokenClaims.set(null);
-        if (this.refreshTimer) {
-            clearTimeout(this.refreshTimer);
-            this.refreshTimer = null;
-        }
-        const returnTo = options?.returnTo || window.location.origin;
-        const search = new URLSearchParams({
-            client_id: this.config.clientId,
-            returnTo,
+        }
+        const config = this.config;
+        const prompt = options?.prompt ?? config?.logoutPrompt ?? 'login';
+        this.#clearExpiryCheck();
+        this.#inFlightRefresh = null;
+        if (config?.endSessionOnLogout) {
+            this.#resetSessionState();
+            this.#emit('logout');
+            this.#notifyOtherTabs(config);
+            // logOut() không tham số sẽ redirect tới end_session_endpoint khi IdP có công bố.
+            this.#oauth.logOut();
+            return;
+        }
+        // why: logOut(true) chỉ dọn phiên cục bộ, không thử redirect tới logout URL không tồn tại.
+        this.#oauth.logOut(true);
+        this.#resetSessionState();
+        this.#emit('logout');
+        this.#notifyOtherTabs(config);
+        if (prompt === false) {
+            const returnTo = options?.returnTo ?? config?.postLogoutRedirectUri ?? window.location.origin;
+            this.navigate(returnTo);
+            return;
+        }
+        // why: cookie SSO của AuthOM không bị xoá cùng phiên cục bộ. Không ép prompt thì lần
+        // /authorize kế tiếp được cookie đó trả lời ngay và user bị đăng nhập lại im lặng.
+        this.#oauth.initCodeFlow(undefined, this.#authorizeParams(prompt));
+    }
+    // ---------------------------------------------------------------------------------------------
+    // Gia hạn token
+    // ---------------------------------------------------------------------------------------------
+    /**
+     * Gia hạn access token ngay lập tức.
+     *
+     * Dùng refresh_token grant khi IdP đã phát hành refresh token, ngược lại rơi về silent refresh
+     * bằng iframe ẩn. Các lời gọi chồng nhau dùng chung một request đang bay.
+     *
+     * @returns `true` khi kết thúc với access token hợp lệ.
+     */
+    refresh() {
+        if (!this.#isBrowser || !this.#oauth) {
+            return Promise.resolve(false);
+        }
+        if (this.#inFlightRefresh) {
+            return this.#inFlightRefresh;
+        }
+        const pending = this.#runRefresh().finally(() => {
+            this.#inFlightRefresh = null;
         });
-        window.location.href = `https://${this.config.domain}/v2/logout?${search.toString()}`;
+        this.#inFlightRefresh = pending;
+        return pending;
+    }
+    /**
+     * Tên cũ của `refresh()`, giữ để tương thích ngược.
+     *
+     * @deprecated Dùng `refresh()`.
+     */
+    silentRefresh() {
+        return this.refresh();
+    }
+    /**
+     * Ghi nhận một `401` từ route đã được bảo vệ.
+     *
+     * Đây là tín hiệu hết phiên đáng tin nhất: một lần refresh hỏng vẫn có thể xảy ra khi token cũ
+     * còn hạn, nhưng `401` nghĩa là resource server đã từ chối đúng token đang dùng.
+     *
+     * - Token đã hết hạn ⇒ phiên chết, phát `session_expired` (và đăng nhập lại nếu cấu hình cho phép).
+     * - Token vẫn còn hạn ⇒ server từ chối vì lý do khác (sai `audience`, client bị thu hồi...);
+     *   phát `auth_error` với `reason = 'unauthorized'` để app tự hiển thị thông báo.
+     *
+     * `SdAuthOmInterceptor` gọi sẵn; chỉ cần gọi tay khi app dùng HTTP client riêng.
+     */
+    handleUnauthorized() {
+        if (!this.#oauth) {
+            return;
+        }
+        if (this.#oauth.hasValidAccessToken()) {
+            this.#emitAuthError('unauthorized');
+            return;
+        }
+        this.#markSessionExpired();
+    }
+    /** `true` khi có thể thử gia hạn mà không cần user tương tác. */
+    canRefresh() {
+        if (!this.#oauth) {
+            return false;
+        }
+        return Boolean(this.#oauth.getRefreshToken()) || this.config?.useSilentRefresh === true;
     }
-    async exchangeCode(code, codeVerifier, redirectUri) {
+    // ---------------------------------------------------------------------------------------------
+    // Callback
+    // ---------------------------------------------------------------------------------------------
+    /**
+     * Xử lý callback `?code=` thủ công.
+     *
+     * `init()` đã tự làm việc này; chỉ cần gọi tay khi app tách riêng một route `/callback` chạy
+     * ngoài APP_INITIALIZER.
+     */
+    async handleCallback() {
+        if (!this.#isBrowser || !this.#oauth) {
+            return false;
+        }
         try {
-            const body = new URLSearchParams({
-                grant_type: 'authorization_code',
-                code,
-                code_verifier: codeVerifier,
-                redirect_uri: redirectUri,
-                client_id: this.config.clientId,
-            });
-            const res = await fetch(`https://${this.config.domain}/oauth/token`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-                body: body.toString(),
-            });
-            if (!res.ok)
-                return false;
-            const data = await res.json();
-            if (!data.access_token)
-                return false;
-            this.accessToken.set(data.access_token);
-            if (data.id_token) {
-                this.idTokenClaims.set(this.decodeJwtPayload(data.id_token));
-            }
-            this.scheduleRefresh(data.access_token);
-            return true;
+            await this.#oauth.tryLogin();
+        }
+        catch (error) {
+            this.#emitAuthError('code_error', error);
+            return false;
+        }
+        this.#restoreReturnUrl();
+        this.#syncFromOAuth();
+        return this.isAuthenticated();
+    }
+    // ---------------------------------------------------------------------------------------------
+    // Đọc trạng thái
+    // ---------------------------------------------------------------------------------------------
+    getAccessToken() {
+        return this.accessToken();
+    }
+    /** `true` khi không còn access token dùng được (chưa đăng nhập, hoặc đã quá hạn). */
+    isAccessTokenExpired() {
+        return !this.#oauth?.hasValidAccessToken();
+    }
+    /** URL có nằm trong `secureRoutes` không — tức có được đính Bearer token không. */
+    isSecureUrl(url) {
+        const patterns = this.config?.secureRoutes;
+        if (!patterns?.length) {
+            return false;
+        }
+        return patterns.some(pattern => matchSecureRoute(pattern, url));
+    }
+    /** Origin của IdP, để interceptor không bao giờ tự đính token vào chính request lấy token. */
+    getIssuerOrigin() {
+        const issuer = this.config ? this.#resolveIssuer(this.config) : null;
+        if (!issuer) {
+            return null;
+        }
+        try {
+            return new URL(issuer).origin;
         }
         catch {
+            return null;
+        }
+    }
+    /** Claims của user hiện tại ở dạng `SdAuthInfo` của module auth, hoặc `null` khi chưa đăng nhập. */
+    authInfo() {
+        const claims = this.idTokenClaims();
+        if (!claims) {
+            return null;
+        }
+        return {
+            id: claims['sub'],
+            username: resolveUsername(claims),
+            email: claims['email'],
+            firstName: claims['given_name'],
+            lastName: claims['family_name'],
+            data: claims,
+        };
+    }
+    /** Claims của user hiện tại ở dạng `SdLayoutUserInfo` của module layout. */
+    userInfo() {
+        const claims = this.idTokenClaims();
+        if (!claims) {
+            return {};
+        }
+        return {
+            username: resolveUsername(claims),
+            email: claims['email'],
+            fullName: resolveFullName(claims),
+            avatar: claims['picture'],
+        };
+    }
+    // ---------------------------------------------------------------------------------------------
+    // Mối nối với trình duyệt (tách riêng để test ghi đè được)
+    // ---------------------------------------------------------------------------------------------
+    /** Điều hướng full-page. */
+    navigate(url) {
+        window.location.href = url;
+    }
+    /** Viết lại URL trên thanh địa chỉ mà không tạo entry mới trong history. */
+    replaceHistoryState(url) {
+        window.history.replaceState(null, '', url);
+    }
+    // ---------------------------------------------------------------------------------------------
+    // Nội bộ
+    // ---------------------------------------------------------------------------------------------
+    async #runRefresh() {
+        const oauth = this.#oauth;
+        if (!oauth) {
+            return false;
+        }
+        try {
+            if (!this.config?.useSilentRefresh && oauth.getRefreshToken()) {
+                await oauth.refreshToken();
+            }
+            else {
+                await oauth.silentRefresh();
+            }
+        }
+        catch (error) {
+            this.#emit('token_refresh_error', undefined, error);
+            this.#evaluateSessionExpired();
             return false;
         }
+        this.#syncFromOAuth();
+        return this.isAuthenticated();
+    }
+    #subscribeOAuthEvents() {
+        const oauth = this.#oauth;
+        if (!oauth) {
+            return;
+        }
+        // why: KHÔNG đăng ký onDestroy ở đây — hàm này chạy bên trong init() bất đồng bộ, và
+        // DestroyRef.onDestroy ném NG0205 nếu injector đã bị huỷ trước khi init() kịp chạy xong.
+        // Dọn dẹp dồn hết về #teardown(), vốn đã đăng ký một lần trong constructor.
+        this.#eventsSubscription = oauth.events.subscribe(event => this.#onOAuthEvent(event));
+    }
+    #onOAuthEvent(event) {
+        if (event.type === 'token_received') {
+            this.#clearExpiryCheck();
+            this.sessionExpired.set(false);
+            this.lastAuthError.set(null);
+            this.#syncFromOAuth();
+            this.#emit('token_received');
+            return;
+        }
+        if (event.type === 'token_refreshed' || event.type === 'silently_refreshed') {
+            this.#clearExpiryCheck();
+            this.sessionExpired.set(false);
+            this.#syncFromOAuth();
+            this.#emit('token_refreshed');
+            return;
+        }
+        if (REFRESH_ERROR_EVENT_TYPES.has(event.type)) {
+            this.#emit('token_refresh_error', event.type, reasonOf(event));
+            this.#evaluateSessionExpired();
+            return;
+        }
+        if (AUTH_ERROR_EVENT_TYPES.has(event.type)) {
+            this.#emitAuthError(event.type, reasonOf(event));
+        }
     }
-    scheduleRefresh(token) {
-        if (this.refreshTimer) {
-            clearTimeout(this.refreshTimer);
-            this.refreshTimer = null;
+    /**
+     * Quyết định một lần gia hạn thất bại có phải là hết phiên hay không.
+     *
+     * Refresh hỏng CHƯA phải hết phiên: access token đang giữ thường vẫn còn hạn thêm một lúc, và
+     * báo "phiên hết hạn" ngay lúc đó là báo sớm — app vẫn chạy bình thường cho tới khi có một
+     * request thật trả 401. Chỉ khi token đó cũng chết thì phiên mới thực sự kết thúc.
+     */
+    #evaluateSessionExpired() {
+        if (!this.#oauth) {
+            return;
         }
-        const claims = this.decodeJwtPayload(token);
-        const exp = claims?.['exp'];
-        if (typeof exp !== 'number') {
-            // @i18n-ignore — dev console warning
-            console.warn('[SdAuthOmService] Token không có exp — bỏ qua auto-refresh');
+        if (this.#oauth.hasValidAccessToken()) {
+            // why: lần gia hạn chủ động này đã hỏng và sẽ không tự lặp lại (timer chỉ lên lịch lại khi
+            // nhận token mới), nên phải tự hẹn kiểm tra đúng lúc token hiện tại hết hạn.
+            this.#scheduleExpiryCheck();
             return;
         }
-        const threshold = this.config.refreshThresholdSeconds ?? DEFAULT_REFRESH_THRESHOLD_SECONDS;
-        const nowSeconds = Math.floor(Date.now() / 1000);
-        const delayMs = Math.max(0, (exp - nowSeconds - threshold) * 1000);
-        this.refreshTimer = setTimeout(() => {
-            this.silentRefresh();
-        }, delayMs);
+        this.#markSessionExpired();
     }
-    silentRefresh() {
-        if (!this.isBrowser)
-            return Promise.resolve(false);
-        return new Promise(async (resolve) => {
-            const state = crypto.randomUUID();
-            const codeVerifier = this.generateCodeVerifier();
-            const codeChallenge = await this.generateCodeChallenge(codeVerifier);
-            const redirectUri = this.getSilentRedirectUri();
-            const timeoutMs = (this.config.authorizeTimeoutInSeconds ?? DEFAULT_AUTHORIZE_TIMEOUT_SECONDS) * 1000;
-            const iframe = document.createElement('iframe');
-            iframe.style.display = 'none';
-            let done = false;
-            const finish = (success) => {
-                if (done)
-                    return;
-                done = true;
-                clearTimeout(timer);
-                iframe.remove();
-                window.removeEventListener('message', onMessage);
-                resolve(success);
-            };
-            const timer = setTimeout(() => finish(false), timeoutMs);
-            const onMessage = async (event) => {
-                if (event.origin !== window.location.origin)
-                    return;
-                const data = event.data;
-                if (!data || typeof data !== 'object')
-                    return;
-                if (data.type === 'AUTHOM_SILENT_SUCCESS' && data.code && data.state === state) {
-                    const ok = await this.exchangeCode(data.code, codeVerifier, redirectUri);
-                    if (!ok) {
-                        this.accessToken.set(null);
-                        this.idTokenClaims.set(null);
-                    }
-                    finish(ok);
-                }
-                else if (data.type === 'AUTHOM_SILENT_ERROR') {
-                    this.accessToken.set(null);
-                    this.idTokenClaims.set(null);
-                    finish(false);
-                }
-            };
-            window.addEventListener('message', onMessage);
-            iframe.src = this.buildAuthorizeUrl({
-                state,
-                codeChallenge,
-                redirectUri,
-                prompt: 'none',
-            });
-            document.body.appendChild(iframe);
+    #scheduleExpiryCheck() {
+        this.#clearExpiryCheck();
+        const expiresAt = this.#oauth?.getAccessTokenExpiration();
+        if (!expiresAt) {
+            return;
+        }
+        const delay = Math.max(0, expiresAt - Date.now()) + 1000;
+        this.#expiryCheckTimer = setTimeout(() => {
+            this.#expiryCheckTimer = null;
+            if (!this.#oauth?.hasValidAccessToken()) {
+                this.#markSessionExpired();
+            }
+        }, delay);
+    }
+    #clearExpiryCheck() {
+        if (this.#expiryCheckTimer !== null) {
+            clearTimeout(this.#expiryCheckTimer);
+            this.#expiryCheckTimer = null;
+        }
+    }
+    #markSessionExpired() {
+        if (this.sessionExpired()) {
+            return;
+        }
+        this.#clearExpiryCheck();
+        this.#resetSessionState();
+        this.sessionExpired.set(true);
+        this.#emit('session_expired');
+        if ((this.config?.onSessionExpired ?? 'login') === 'login') {
+            void this.login();
+        }
+    }
+    #listenCrossTabLogout(config) {
+        if (this.#channel) {
+            return;
+        }
+        this.#channel = new SdAuthOmSessionChannel(config.sessionChannelName || `sd-authom-session:${config.clientId}`);
+        this.#channel.onLogout(() => {
+            this.#clearExpiryCheck();
+            this.#oauth?.logOut(true);
+            this.#resetSessionState();
+            this.#emit('logout_other_tab');
+            this.#oauth?.initCodeFlow(undefined, this.#authorizeParams('login'));
         });
     }
-    async handleCallback() {
-        if (!this.isBrowser)
-            return false;
-        const params = new URLSearchParams(window.location.search);
-        const code = params.get('code');
-        const state = params.get('state');
-        if (!code)
-            return false;
-        const savedState = sessionStorage.getItem(STORAGE_KEY_STATE);
-        const codeVerifier = sessionStorage.getItem(STORAGE_KEY_CODE_VERIFIER);
-        const returnTo = sessionStorage.getItem(STORAGE_KEY_RETURN_TO);
-        sessionStorage.removeItem(STORAGE_KEY_STATE);
-        sessionStorage.removeItem(STORAGE_KEY_CODE_VERIFIER);
-        if (state !== savedState || !codeVerifier) {
-            window.history.replaceState({}, '', window.location.pathname);
-            sessionStorage.removeItem(STORAGE_KEY_RETURN_TO);
-            return false;
+    #notifyOtherTabs(config) {
+        if (config?.crossTabLogout === false) {
+            return;
         }
-        const redirectUri = this.getDefaultRedirectUri();
-        const ok = await this.exchangeCode(code, codeVerifier, redirectUri);
+        this.#channel?.notifyLogout();
+    }
+    #restoreReturnUrl() {
+        const returnTo = resolveReturnUrl(this.#oauth?.state);
         if (returnTo) {
-            sessionStorage.removeItem(STORAGE_KEY_RETURN_TO);
-            window.history.replaceState({}, '', returnTo);
+            // why: vẫn đang trong APP_INITIALIZER, tức trước điều hướng đầu tiên của Router — viết lại
+            // URL ở đây khiến lần điều hướng đó nhắm thẳng trang user yêu cầu và chạy guard bình thường.
+            this.replaceHistoryState(window.location.origin + returnTo);
         }
-        else {
-            window.history.replaceState({}, '', window.location.pathname);
+    }
+    #syncFromOAuth() {
+        const oauth = this.#oauth;
+        if (!oauth?.hasValidAccessToken()) {
+            this.accessToken.set(null);
+            this.idTokenClaims.set(null);
+            return;
         }
-        return ok;
+        this.accessToken.set(oauth.getAccessToken() || null);
+        this.idTokenClaims.set(oauth.getIdentityClaims() ?? null);
     }
-    async init(config) {
-        this.config = config;
-        if (!this.isBrowser)
-            return false;
-        const hasCode = new URLSearchParams(window.location.search).has('code');
-        if (hasCode) {
-            const ok = await this.handleCallback();
-            if (ok)
-                return true;
+    #resetSessionState() {
+        this.accessToken.set(null);
+        this.idTokenClaims.set(null);
+    }
+    #authorizeParams(prompt) {
+        const params = {};
+        if (this.config?.organization) {
+            params['organization'] = this.config.organization;
+        }
+        if (prompt) {
+            params['prompt'] = prompt;
+        }
+        return params;
+    }
+    #resolveIssuer(config) {
+        const issuer = config.issuer?.trim();
+        if (issuer) {
+            return issuer;
+        }
+        const domain = config.domain?.trim();
+        if (domain) {
+            return /^https?:\/\//i.test(domain) ? domain : `https://${domain}/`;
         }
-        return this.silentRefresh();
+        throw new Error('[SdAuthOmService] Missing tenant "issuer" (or legacy "domain") in SdAuthOmTenantConfig.');
+    }
+    /**
+     * Chuẩn hoá basename file tĩnh trong `public/` thành URL tuyệt đối.
+     * `'auth-error'` | `'/auth-error'` | `'auth-error.html'` → `${origin}/auth-error.html`.
+     */
+    #toPublicHtmlUrl(name) {
+        const base = name
+            .trim()
+            .replace(/^\/+/, '')
+            .replace(/\.html$/i, '');
+        return `${window.location.origin}/${base}.html`;
+    }
+    #emit(type, reason, error) {
+        this.#events.next({ type, reason, error });
+    }
+    #emitAuthError(reason, error) {
+        const event = { type: 'auth_error', reason, error };
+        this.lastAuthError.set(event);
+        this.#events.next(event);
+    }
+    #teardown() {
+        this.#clearExpiryCheck();
+        this.#eventsSubscription?.unsubscribe();
+        this.#eventsSubscription = null;
+        this.#channel?.close();
+        this.#channel = null;
+        this.#events.complete();
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: SdAuthOmService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: SdAuthOmService, providedIn: 'root' });
@@ -253,59 +697,216 @@ class SdAuthOmService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: SdAuthOmService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }] });
-
-const escapeRegExp = (str) => str.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+        }], ctorParameters: () => [] });
+/**
+ * Khớp một URL với một phần tử `secureRoutes`.
+ *
+ * Có `*` → glob trên toàn bộ URL. Không có `*` → khớp tiền tố, không phân biệt hoa thường
+ * (đây là dạng "danh sách host" mà các portal đang dùng).
+ */
+function matchSecureRoute(pattern, url) {
+    if (!pattern) {
+        return false;
+    }
+    if (pattern.includes('*')) {
+        return matchGlob(pattern, url);
+    }
+    return url.toLowerCase().startsWith(pattern.toLowerCase());
+}
+const escapeRegExp = (value) => value.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+/** Khớp glob đơn giản, `*` thay cho một đoạn bất kỳ. Giữ nguyên hành vi từ bản trước của module. */
 const matchGlob = (pattern, url) => {
     const regexBody = pattern.split('*').map(escapeRegExp).join('.*');
     return new RegExp(`^${regexBody}$`).test(url);
 };
+/**
+ * AuthOM không phát claim `preferred_username` (xác nhận từ discovery document thật), nên phải có
+ * chuỗi fallback thay vì đọc thẳng một claim.
+ */
+function resolveUsername(claims) {
+    return (claims['preferred_username'] ?? claims['email'] ?? claims['nickname'] ?? claims['sub']);
+}
+function resolveFullName(claims) {
+    const lastName = claims['family_name'];
+    const firstName = claims['given_name'];
+    const composed = [lastName, firstName].filter(Boolean).join(' ');
+    return composed || (claims['name'] ?? claims['nickname']);
+}
+function reasonOf(event) {
+    return event instanceof OAuthErrorEvent ? event.reason : event.info;
+}
+
+/**
+ * Đính `Authorization: Bearer <token>` vào các request khớp `secureRoutes`.
+ *
+ * Interceptor này cũng là chốt gia hạn cuối cùng: nếu access token đã hết hạn ngay trước khi gửi
+ * (máy vừa ngủ dậy, tab bị treo, timer refresh chủ động lỡ nhịp) thì nó gia hạn trước rồi mới gửi,
+ * thay vì để request chết 401 rồi mới xử lý.
+ */
 const SdAuthOmInterceptor = (req, next) => {
     const authom = inject(SdAuthOmService);
-    const token = authom.getAccessToken();
-    const config = authom.config;
-    if (!token || !config)
+    if (!authom.config) {
+        return next(req);
+    }
+    // why: request lấy/gia hạn token cũng đi qua HttpClient. Không loại trừ origin của IdP thì một
+    // `secureRoutes` rộng tay sẽ khiến refresh tự gọi lại chính nó.
+    const issuerOrigin = authom.getIssuerOrigin();
+    if (issuerOrigin && req.url.toLowerCase().startsWith(issuerOrigin.toLowerCase())) {
         return next(req);
-    const isSecure = config.secureRoutes?.some(pattern => matchGlob(pattern, req.url));
-    if (!isSecure)
+    }
+    if (!authom.isSecureUrl(req.url)) {
         return next(req);
-    const authReq = req.clone({
-        headers: req.headers.set('Authorization', `Bearer ${token}`),
-    });
-    return next(authReq);
+    }
+    const send = (token) => forward(req, next, authom, token);
+    if (!authom.isAccessTokenExpired()) {
+        return send(authom.getAccessToken());
+    }
+    if (!authom.canRefresh()) {
+        return send(null);
+    }
+    return from(authom.refresh()).pipe(switchMap(refreshed => send(refreshed ? authom.getAccessToken() : null)));
 };
+function forward(req, next, authom, token) {
+    const outgoing = token ? req.clone({ headers: req.headers.set('Authorization', `Bearer ${token}`) }) : req;
+    return next(outgoing).pipe(catchError((error) => {
+        // why: 401 từ một route đã được bảo vệ là tín hiệu đáng tin cậy nhất cho biết phiên đã chết
+        // thật — đáng tin hơn một lần refresh hỏng, vì lúc đó token cũ thường vẫn còn hạn.
+        if (error instanceof HttpErrorResponse && error.status === 401) {
+            authom.handleUnauthorized();
+        }
+        return throwError(() => error);
+    }));
+}
 
-function provideSdAuthOm(options) {
-    const providers = [SdAuthOmService];
+/**
+ * Chặn route khi chưa đăng nhập và khởi động code flow, mang theo URL được yêu cầu.
+ *
+ * Dùng trực tiếp trên route:
+ * ```ts
+ * { path: 'orders', canActivate: [sdAuthOmGuard], loadChildren: ... }
+ * ```
+ *
+ * App đã dùng `SdAuthGuard` của module auth thì không cần guard này — hãy để
+ * `SdAuthOmAuthConfiguration` cấp `SD_AUTH_CONFIGURATION` (mặc định `provideSdAuthOm` làm sẵn).
+ */
+const sdAuthOmGuard = (_route, state) => {
+    const authom = inject(SdAuthOmService);
+    if (authom.isAuthenticated()) {
+        return true;
+    }
+    void authom.login({ returnTo: state.url });
+    return false;
+};
+
+/**
+ * Nối AuthOM vào module `auth` dùng chung.
+ *
+ * Cấp token này (mặc định `provideSdAuthOm` đã làm) là đủ để `SdAuthGuard`, `SdPortalGuard` và
+ * `SdAuthService.signout()` chạy đúng trên AuthOM mà app không phải viết thêm gì.
+ *
+ * `changePassword` cố ý KHÔNG được cài đặt: AuthOM chưa công bố cơ chế đổi mật khẩu, và
+ * `SdAuthService.changePassword()` tự bỏ qua khi thiếu action — đúng hơn là ném lỗi lúc chạy.
+ */
+class SdAuthOmAuthConfiguration {
+    #authom = inject(SdAuthOmService);
+    /**
+     * Phát lại mỗi khi claims đổi, thay vì trả một giá trị chụp một lần.
+     *
+     * `SdAuthService` bọc giá trị này bằng `toSignal` trong constructor của chính nó, nên một
+     * Observable sống giữ cho `getAuthInfo()` đúng cả khi service được tạo trước lúc đăng nhập xong.
+     */
+    #authInfo$ = toObservable(this.#authom.idTokenClaims).pipe(map(() => this.#authom.authInfo() ?? {}));
+    guard = {
+        auth: (_route, state) => {
+            if (this.#authom.isAuthenticated()) {
+                return of(true);
+            }
+            void this.#authom.login({ returnTo: state.url });
+            return of(false);
+        },
+        /** AuthOM không có khái niệm portal riêng — mặc định cho qua, app tự override nếu cần. */
+        portal: () => of(true),
+        authInfo: () => this.#authInfo$,
+    };
+    action = {
+        signout: () => this.#authom.logout(),
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: SdAuthOmAuthConfiguration, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: SdAuthOmAuthConfiguration, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: SdAuthOmAuthConfiguration, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+function buildConfigurationProvider(options) {
     if (options.useFactory) {
-        providers.push({ provide: SD_AUTHOM_CONFIGURATION, useFactory: options.useFactory, deps: options.deps || [] });
+        return { provide: SD_AUTHOM_CONFIGURATION, useFactory: options.useFactory, deps: options.deps || [] };
+    }
+    if (options.useClass) {
+        return { provide: SD_AUTHOM_CONFIGURATION, useClass: options.useClass };
     }
-    else if (options.useClass) {
-        providers.push({ provide: SD_AUTHOM_CONFIGURATION, useClass: options.useClass });
+    throw new Error('[provideSdAuthOm] Either "useClass" or "useFactory" must be supplied.');
+}
+function buildCommonProviders(options) {
+    const providers = [
+        // why: config = null nên interceptor DI mặc định của client OIDC không đính token cho ai cả.
+        // Việc đính token thuộc về SdAuthOmInterceptor, nhờ đó app chỉ cần withInterceptors([...])
+        // và không phải nhớ thêm withInterceptorsFromDi().
+        provideOAuthClient(),
+        SdAuthOmService,
+        buildConfigurationProvider(options),
+    ];
+    if (options.withAuthConfiguration !== false) {
+        providers.push({ provide: SD_AUTH_CONFIGURATION, useExisting: SdAuthOmAuthConfiguration });
     }
+    return providers;
+}
+/**
+ * Đăng ký AuthOM cho app standalone (gọi trong `app.config.ts`).
+ *
+ * ```ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideHttpClient(withInterceptors([SdAuthOmInterceptor])),
+ *     provideSdAuthOm({
+ *       useFactory: () => ({
+ *         loadTenantConfig: () => Promise.resolve({
+ *           issuer: 'https://api-qc.onemount.dev/auth-om/iam/v1/mag-qc/',
+ *           clientId: 'YOUR_CLIENT_ID',
+ *           redirectUri: `${location.origin}/callback`,
+ *           audience: 'http://api-qc.int.onemount.dev/auth-om/api/v1/mag-qc',
+ *           secureRoutes: ['https://api-qc.onemount.dev'],
+ *         }),
+ *       }),
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+function provideSdAuthOm(options) {
+    const providers = buildCommonProviders(options);
     providers.push(provideAppInitializer(() => {
         const configLoader = inject(SD_AUTHOM_CONFIGURATION);
         const authom = inject(SdAuthOmService);
-        return configLoader.loadTenantConfig().then((config) => authom.init(config));
+        return configLoader.loadTenantConfig().then(config => authom.init(config));
     }));
     return makeEnvironmentProviders(providers);
 }
+/** Đăng ký AuthOM cho kiến trúc `NgModule` cũ. */
 class SdAuthOmModule {
     static forRoot(options) {
         return {
             ngModule: SdAuthOmModule,
             providers: [
-                SdAuthOmService,
-                ...(options.useFactory
-                    ? [{ provide: SD_AUTHOM_CONFIGURATION, useFactory: options.useFactory, deps: options.deps || [] }]
-                    : [{ provide: SD_AUTHOM_CONFIGURATION, useClass: options.useClass }]),
+                ...buildCommonProviders(options),
                 {
                     provide: APP_INITIALIZER,
                     multi: true,
                     useFactory: () => {
                         const configLoader = inject(SD_AUTHOM_CONFIGURATION);
                         const authom = inject(SdAuthOmService);
-                        return () => configLoader.loadTenantConfig().then((config) => authom.init(config));
+                        return () => configLoader.loadTenantConfig().then(config => authom.init(config));
                     },
                 },
             ],
@@ -321,7 +922,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.21", ngImpo
         }] });
 
 /**
- * Module `authom` — OAuth 2.0 + PKCE authentication client cho AuthOM (Auth0-based).
+ * Module `authom` — client xác thực OAuth 2.0 Authorization Code + PKCE cho AuthOM.
+ *
+ * Module sở hữu trọn vòng đời phiên: bootstrap qua discovery document, đổi authorization code,
+ * khôi phục deep link, gia hạn token chủ động, phát hiện hết phiên, xử lý lỗi xác thực và đăng
+ * xuất đồng bộ giữa các tab.
  *
  * Cách dùng (standalone):
  * ```ts
@@ -334,12 +939,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.21", ngImpo
  *     provideSdAuthOm({
  *       useFactory: () => ({
  *         loadTenantConfig: () => Promise.resolve({
- *           domain: 'login.example.com',
+ *           issuer: 'https://api-qc.onemount.dev/auth-om/iam/v1/mag-qc/',
  *           clientId: 'YOUR_CLIENT_ID',
- *           audience: 'https://api.example.com',
- *           organization: 'org_xxx',
- *           scope: 'openid profile email offline_access',
- *           secureRoutes: ['https://api.example.com/*'],
+ *           redirectUri: `${location.origin}/callback`,
+ *           audience: 'http://api-qc.int.onemount.dev/auth-om/api/v1/mag-qc',
+ *           secureRoutes: ['https://api-qc.onemount.dev'],
  *         }),
  *       }),
  *     }),
@@ -347,14 +951,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.21", ngImpo
  * };
  * ```
  *
- * Yêu cầu setup thêm:
- * 1. Copy file `silent-authom.html` từ source module này vào thư mục `public/` của app.
- * 2. App phải chạy trên HTTPS (hoặc localhost) — Web Crypto API yêu cầu secure context.
+ * Yêu cầu phía app:
+ * 1. Cài `angular-oauth2-oidc` (peer dependency, chọn major khớp Angular của app).
+ * 2. App chạy trên HTTPS hoặc localhost — Web Crypto API cần secure context để tạo PKCE.
+ * 3. `redirectUri` phải trùng giá trị đã đăng ký trên client AuthOM.
+ * 4. Chỉ khi bật `useSilentRefresh`: copy `silent-authom.html` cạnh source module này vào `public/`.
  */
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { SD_AUTHOM_CONFIGURATION, SdAuthOmInterceptor, SdAuthOmModule, SdAuthOmService, matchGlob, provideSdAuthOm };
+export { SD_AUTHOM_CONFIGURATION, SD_AUTHOM_DEFAULT_SCOPE, SD_AUTHOM_DEFAULT_SILENT_REFRESH_TIMEOUT_SECONDS, SD_AUTHOM_DEFAULT_TIMEOUT_FACTOR, SdAuthOmAuthConfiguration, SdAuthOmInterceptor, SdAuthOmModule, SdAuthOmService, SdAuthOmSessionChannel, captureReturnUrl, isRestorableAppUrl, matchGlob, matchSecureRoute, provideSdAuthOm, resolveReturnUrl, sdAuthOmGuard };
 //# sourceMappingURL=sd-angular-core-modules-authom.mjs.map