@liorian/sdk 0.28.4-alpha.0a2443c → 0.30.0-alpha.ed4249e

package/README.md

@@ -322,7 +322,9 @@ import {motionVariants, transitionEasing} from "@liorian/sdk/infrastructure/libr
 ### Hooks (`infrastructure/hooks/`)
 
 `use-auth`, `use-notifications`, `use-mobile`, `use-is-desktop`, `use-is-tauri`,
-`use-activity-lock-draft`, `use-elastic-interaction`, `use-recent-colors`, `use-recent-modules`.
+`use-activity-lock-draft`, `use-elastic-interaction`, `use-recent-colors`, `use-recent-modules`,
+`use-sso-login` (déclenche le flux SSO selon `AuthConfig.sso.mode` — `redirect` par défaut,
+`popup` sur option — et reçoit le résultat via `postMessage` + repli `storage`).
 
 ### Stores zustand (`infrastructure/stores/`)
 
@@ -361,7 +363,10 @@ manager. Reprendre la même source de vérité côté SDK et côté manager.
 - `permission.util`, `format.util`, `strings.util`, `classname.util` (`cn`/`CommonClassName`) ;
 - `encryption.service`, `activity-tracker.service`, `activity-lock.service` (verrouillage d'écran),
   `form-snapshot.service` (brouillons de formulaire au verrouillage) ;
-- `sso-auth.util`, `auth-logout.util`, `route-access` (accès par route), `media-label.service`,
+- `sso-auth.util` — client SSO OAuth 2.0 + PKCE vers Liorian Auth : `startSsoLogin`
+  (redirection, mode par défaut), `startSsoLoginPopup` (optionnel), `handleSsoCallback`,
+  `isSsoCallbackInPopup`, `SSO_MODE`, `SSO_RESULT_STORAGE_KEY` ;
+- `auth-logout.util`, `route-access` (accès par route), `media-label.service`,
   `push-permission.util`, `tauri.util`, `modules.ts`.
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liorian/sdk",
-  "version": "0.28.4-alpha.0a2443c",
+  "version": "0.30.0-alpha.ed4249e",
   "description": "Core package for the Liorian (application shell, domain, infrastructure, UI design system).",
   "type": "module",
   "license": "MIT",

package/schemas/module.schema.json

@@ -3,7 +3,7 @@
   "$id": "module-manifest.schema.json",
   "$comment": "Schéma canonique du manifest.json des modules Liorian (@liorian/sdk). Référencé par les modules du socle (frontend/liorian-socle/src/modules/*) et les modules externes (frontend/liorian-socle/library/modules/*).",
   "title": "Module Manifest (Liorian)",
-  "description": "Manifeste d'installation et de déclaration d'un module Liorian. Ce fichier décrit l'identité du module, sa compatibilité (plateformes, versions manager/API), ses permissions et ses prérequis fonctionnels (requirements/optionalRequirements). Les dépendances npm d'exécution et de développement sont portées par le `package.json` du module. Il est la source de vérité des métadonnées techniques d'un module, consommée par le Module Store et l'outillage de distribution.",
+  "description": "Manifeste d'installation et de déclaration d'un module Liorian. Ce fichier décrit l'identité du module, sa compatibilité (plateformes, versions socle/API), ses permissions, ses scopes OAuth, ses capacités Tauri et ses prérequis fonctionnels (requirements/optionalRequirements). Les dépendances npm d'exécution et de développement sont portées par le `package.json` du module. Il est la source de vérité des métadonnées techniques d'un module, consommée par le Module Store et l'outillage de distribution.",
   "type": "object",
   "default": {},
   "examples": [
@@ -19,25 +19,18 @@
       "type": "INTERNAL",
       "entry": "index.tsx",
       "uri": "/hello-world",
-      "publisher": {
-        "id": "liorian",
-        "name": "Liorian Workspace"
-      },
       "platforms": {
         "web": {"supported": true, "modes": ["web"]},
         "desktop": {"supported": true, "modes": ["local-webview"], "os": ["windows", "macos", "linux"]},
-        "mobile": {"supported": true, "modes": ["local-webview"], "os": ["android"], "iosSupported": false}
+        "mobile": {"supported": true, "modes": ["local-webview"], "os": ["android"]}
       },
-      "managerCompatibility": {"min": "0.17.1", "max": "0.17.x"},
-      "apiCompatibility": {"min": "0.27.0", "max": "0.27.x"},
-      "permissions": ["hello-world.read", "hello-world.write", "hello-world.manage"],
-      "apiScopes": ["hello-world.read", "hello-world.write"],
-      "capabilities": {
-        "needsNetwork": true,
-        "supportsOffline": false,
-        "requiresOrganization": true,
-        "requiresAuthenticatedUser": true
+      "compatibility": {
+        "socle": {"min": "0.17.1", "max": "0.17.x"},
+        "api": {"min": "0.27.0", "max": "0.27.x"}
       },
+      "permissions": ["User:Get", "Editor:Post", "Editor:Put", "Admin:Delete"],
+      "oauth": {"scopes": ["openid", "profile", "email", "organizations"]},
+      "capabilities": ["core:default"],
       "isEnabled": true,
       "isDefault": false,
       "requirements": {
@@ -62,12 +55,10 @@
     "type",
     "entry",
     "uri",
-    "publisher",
     "platforms",
-    "managerCompatibility",
-    "apiCompatibility",
+    "compatibility",
     "permissions",
-    "apiScopes",
+    "oauth",
     "capabilities",
     "isEnabled",
     "isDefault",
@@ -181,52 +172,71 @@
       "description": "Catégorie du module utilisée pour le filtrage et le regroupement dans le Module Store (alignée sur l'enum `ModuleCategory` du SDK).",
       "examples": ["FINANCE", "COMMERCIAL", "SYSTEM"]
     },
-    "publisher": {
-      "$ref": "#/definitions/publisher",
-      "title": "Éditeur",
-      "description": "Identité de l'éditeur du module, affichée dans le Module Store et utilisée pour la vérification de signature."
-    },
     "platforms": {
       "$ref": "#/definitions/platforms",
       "title": "Plateformes supportées",
       "description": "Matrice de support du module par plateforme (web, desktop, mobile) et par modes d'exécution."
     },
-    "managerCompatibility": {
-      "$ref": "#/definitions/version-range",
-      "title": "Compatibilité manager",
-      "description": "Plage de versions du manager (frontend liorian-socle) acceptées par le module. Hors de cette plage, le module est marqué `incompatible`."
-    },
-    "apiCompatibility": {
-      "$ref": "#/definitions/version-range",
-      "title": "Compatibilité API",
-      "description": "Plage de versions de l'API backend attendues par le module. Hors de cette plage, les appels de service peuvent ne pas être conformes."
+    "compatibility": {
+      "type": "object",
+      "required": ["socle", "api"],
+      "properties": {
+        "socle": {
+          "$ref": "#/definitions/version-range",
+          "title": "Compatibilité socle (manager)",
+          "description": "Plage de versions du socle (manager, frontend liorian-socle) acceptées par le module. Hors de cette plage, le module est marqué `incompatible`."
+        },
+        "api": {
+          "$ref": "#/definitions/version-range",
+          "title": "Compatibilité API",
+          "description": "Plage de versions de l'API backend attendues par le module. Hors de cette plage, les appels de service peuvent ne pas être conformes."
+        }
+      },
+      "additionalProperties": false,
+      "title": "Compatibilité",
+      "description": "Plages de versions attendues du socle/manager (`socle`) et de l'API backend (`api`). Chaque plage est un objet `version-range` (`min` requis, `max` optionnel).",
+      "examples": [
+        {
+          "socle": {"min": "0.17.1", "max": "0.17.x"},
+          "api": {"min": "0.27.0", "max": "0.27.x"}
+        }
+      ]
     },
     "permissions": {
       "type": "array",
       "items": {
-        "$ref": "#/definitions/permission-code"
+        "$ref": "#/definitions/role-permission-code"
       },
       "minItems": 1,
       "uniqueItems": true,
       "title": "Permissions",
-      "description": "Liste des permissions demandées par le module (format `<module>.<action>`). Ces permissions sont exposées au moteur d'autorisation via le composant `PermissionActionBadge` / `permission.util`.",
-      "examples": [["accounting.read", "accounting.write", "accounting.manage"]]
+      "description": "Accès accordés au module par rôle et par verbe HTTP, au format `<ROLE>:<VERBE>` (ex. `User:Get`, `Editor:Post`, `Editor:Put`, `Admin:Delete`). Rôles et actions alignés sur les rôles/permissions du backend (PermissionsConfig) et sur les verbes HTTP des contrôleurs Raiton.",
+      "examples": [["User:Get", "Editor:Post", "Editor:Put", "Admin:Delete"]]
     },
-    "apiScopes": {
-      "type": "array",
-      "items": {
-        "$ref": "#/definitions/permission-code"
+    "oauth": {
+      "type": "object",
+      "required": ["scopes"],
+      "properties": {
+        "scopes": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/oauth-scope"
+          },
+          "minItems": 1,
+          "uniqueItems": true,
+          "title": "Scopes OAuth",
+          "description": "Scopes OAuth demandés par le module lors de la négociation d'accès. Doivent appartenir au catalogue OAuth autorisé (`openid`, `profile`, `email`, `organizations`, `roles`, `permissions`).",
+          "examples": [["openid", "profile", "email", "organizations"]]
+        }
       },
-      "minItems": 1,
-      "uniqueItems": true,
-      "title": "Scopes API",
-      "description": "Scopes OAuth/API recensés par le module, généralement un sous-ensemble des permissions demandées (lecture/écriture). Utilisés lors de la négociation des accès avec l'API backend.",
-      "examples": [["accounting.read", "accounting.write"]]
+      "additionalProperties": false,
+      "title": "Configuration OAuth",
+      "description": "Scopes OAuth requis par le module, alignés sur le catalogue de scopes autorisés par le serveur OAuth."
     },
     "capabilities": {
       "$ref": "#/definitions/capabilities",
       "title": "Capacités",
-      "description": "Déclaration des capacités techniques du module (réseau, hors-ligne, organisation requise, utilisateur authentifié, etc.)."
+      "description": "Identifiants de permissions/capacités Tauri requis par le module sur le client desktop, alignés sur les capacités déclarées dans `src-tauri/capabilities/`."
     },
     "isEnabled": {
       "type": "boolean",
@@ -372,7 +382,7 @@
       },
       "additionalProperties": false,
       "title": "Plage de compatibilité",
-      "description": "Contrainte de compatibilité avec le manager (`managerCompatibility`) ou l'API (`apiCompatibility`) : borne minimale requise, borne maximale et sévérité.",
+      "description": "Contrainte de compatibilité avec le socle (`compatibility.socle`) ou l'API backend (`compatibility.api`) : borne minimale requise, borne maximale et sévérité.",
       "examples": [{"min": "0.17.1", "max": "0.17.x"}]
     },
     "module-version-map": {
@@ -390,52 +400,6 @@
       "description": "Association d'identifiants de modules (`requirements` / `optionalRequirements`) à des plages de versions acceptées.",
       "examples": [{"organization": ">=1.0.0", "media-library": ">=1.0.0"}]
     },
-    "publisher": {
-      "type": "object",
-      "required": ["id", "name"],
-      "properties": {
-        "id": {
-          "type": "string",
-          "pattern": "^[a-z0-9]+([-_][a-z0-9]+)*$",
-          "title": "Identifiant de l'éditeur",
-          "description": "Identifiant technique de l'éditeur (ex. `liorian`)."
-        },
-        "name": {
-          "type": "string",
-          "minLength": 1,
-          "title": "Nom de l'éditeur",
-          "description": "Nom affiché de l'éditeur (ex. `Liorian Workspace`)."
-        },
-        "url": {
-          "type": "string",
-          "format": "uri",
-          "title": "Site de l'éditeur",
-          "description": "URL du site officiel de l'éditeur."
-        },
-        "email": {
-          "type": "string",
-          "format": "email",
-          "title": "Contact",
-          "description": "Adresse de contact du support."
-        },
-        "description": {
-          "type": "string",
-          "maxLength": 256,
-          "title": "Description",
-          "description": "Courte présentation de l'éditeur."
-        },
-        "avatar": {
-          "type": "string",
-          "format": "uri",
-          "title": "Avatar",
-          "description": "URL de l'avatar logo de l'éditeur."
-        }
-      },
-      "additionalProperties": false,
-      "title": "Éditeur",
-      "description": "Identité de l'entité publiant le module.",
-      "examples": [{"id": "liorian", "name": "Liorian Workspace"}]
-    },
     "platforms": {
       "type": "object",
       "required": ["web", "desktop", "mobile"],
@@ -494,14 +458,9 @@
           },
           "uniqueItems": true,
           "title": "Systèmes d'exploitation",
-          "description": "Systèmes d'exploitation supportés (pertinent pour desktop/mobile).",
+          "description": "Systèmes d'exploitation supportés (pertinent pour desktop/mobile, où `ios` signifie support iOS).",
           "examples": [["windows", "macos", "linux"]]
         },
-        "iosSupported": {
-          "type": "boolean",
-          "title": "Support iOS",
-          "description": "Indique si iOS est supporté sur la plateforme mobile (obsolète si `os` inclut déjà `ios`)."
-        },
         "minOsVersion": {
           "type": "string",
           "title": "Version OS minimale",
@@ -529,71 +488,29 @@
       "description": "Définition du support d'un module sur une plateforme donnée."
     },
     "capabilities": {
-      "type": "object",
-      "properties": {
-        "needsNetwork": {
-          "type": "boolean",
-          "default": true,
-          "title": "Réseau requis",
-          "description": "Si `true`, le module requiert une connexion réseau pour fonctionner (appels API)."
-        },
-        "supportsOffline": {
-          "type": "boolean",
-          "default": false,
-          "title": "Mode hors-ligne",
-          "description": "Si `true`, le module conserve un fonctionnement dégradé hors connexion (cache local, file d'attente)."
-        },
-        "requiresOrganization": {
-          "type": "boolean",
-          "default": true,
-          "title": "Organisation requise",
-          "description": "Si `true`, le module exige une organisation active (le Module Guard bloque sans organisation)."
-        },
-        "requiresAuthenticatedUser": {
-          "type": "boolean",
-          "default": true,
-          "title": "Utilisateur authentifié requis",
-          "description": "Si `true`, le module exige une session utilisateur authentifiée."
-        },
-        "requiresAdmin": {
-          "type": "boolean",
-          "default": false,
-          "title": "Administrateur requis",
-          "description": "Si `true`, seules les sessions avec le rôle administrateur peuvent accéder au module."
-        },
-        "supportsRealtime": {
-          "type": "boolean",
-          "default": false,
-          "title": "Temps réel",
-          "description": "Si `true`, le module s'appuie sur des routines et/ou événements temps réel (push, websocket)."
-        },
-        "processesLocalData": {
-          "type": "boolean",
-          "default": false,
-          "title": "Traitement local des données",
-          "description": "Si `true`, le module traite des données sur l'appareil (chiffrement local, médias locaux)."
-        }
+      "type": "array",
+      "items": {
+        "type": "string",
+        "pattern": "^[a-z][a-z0-9_]*:[a-z0-9_.:-]+$"
       },
-      "additionalProperties": true,
-      "title": "Capacités techniques",
-      "description": "Déclaration des capacités techniques du module. Les drapeaux inconnus restent autorisés pour préserver l'extensibilité.",
-      "examples": [
-        {
-          "needsNetwork": true,
-          "supportsOffline": false,
-          "requiresOrganization": true,
-          "requiresAuthenticatedUser": true
-        }
-      ]
+      "uniqueItems": true,
+      "title": "Capacités Tauri",
+      "description": "Identifiants de permissions/capacités Tauri requis par le module sur le client desktop. Valeurs alignées sur les identifiants déclarés dans `src-tauri/capabilities/*.json` (ex. `core:default`, `notification:default`, `core:window:allow-start-dragging`).",
+      "examples": [["core:default", "notification:default"]]
     },
-    "permission-code": {
+    "role-permission-code": {
       "type": "string",
-      "pattern": "^[a-z0-9]+([-_][a-z0-9]+)*(\\.[a-z0-9]+([-_][a-z0-9]+)*)+$",
-      "minLength": 3,
-      "maxLength": 64,
-      "title": "Code de permission / scope",
-      "description": "Code hiérarchique au format `<module>.<action>` (ex. `accounting.write`, `project_management.manage`). L'action suit les conventions : `read`, `write`, `manage`, `delete`, `create`, `update`, `list`, `execute`.",
-      "examples": ["accounting.read", "project_management.manage", "hello-world.write"]
+      "pattern": "^(Root|SuperAdmin|Admin|Manager|Editor|Moderator|Analyst|Commercial|Operator|Contributor|Caissier|User|Guest|Viewer):(Get|Post|Put|Delete)$",
+      "title": "Permission rôle:verbe",
+      "description": "Accès accordé au format `<ROLE>:<VERBE>`. `ROLE` est un nom de rôle existant du backend (`Root`, `SuperAdmin`, `Admin`, `Manager`, `Editor`, `Moderator`, `Analyst`, `Commercial`, `Operator`, `Contributor`, `Caissier`, `User`, `Guest`, `Viewer`) et `VERBE` un verbe HTTP (`Get`, `Post`, `Put`, `Delete`).",
+      "examples": ["User:Get", "Editor:Post", "Editor:Put", "Admin:Delete"]
+    },
+    "oauth-scope": {
+      "type": "string",
+      "enum": ["openid", "profile", "email", "organizations", "roles", "permissions"],
+      "title": "Scope OAuth",
+      "description": "Scope OAuth du catalogue autorisé, aligné sur les scopes pré-enregistrés du serveur OAuth (définis par `packages/oauth-kit` et les seeds).",
+      "examples": ["openid", "profile", "email", "organizations"]
     },
     "icon-reference": {
       "type": "string",

package/src/domain/config/app.config.ts

@@ -11,9 +11,16 @@ export const AppConfig = {
     APP_VERSION: process.env.NEXT_PUBLIC_APP_VERSION as unknown as string,
     APP_VERSION_NUMBER: process.env.NEXT_PUBLIC_APP_VERSION_NUMBER as unknown as number,
     
-    UI_REFRESH_TIMEOUT: process.env.NEXT_PUBLIC_UI_REFRESH_TIMEOUT as unknown as number,
+    /** Alias conservé pour compatibilité : renvoie la même cadence que `APP_REFRESH_UI`. */
+    UI_REFRESH_TIMEOUT: toPositiveMilliseconds(
+        process.env.NEXT_PUBLIC_APP_REFRESH_UI ?? process.env.NEXT_PUBLIC_UI_REFRESH_TIMEOUT,
+        30 * 1000
+    ),
     UI_ACTIVITY_TRACKER_TIMEOUT: toPositiveMilliseconds(process.env.NEXT_PUBLIC_UI_ACTIVITY_TRACKER_TIMEOUT, 3 * 60 * 1000),
-    APP_REFRESH_UI: toPositiveMilliseconds(process.env.NEXT_PUBLIC_APP_REFRESH_UI, 30 * 1000),
+    APP_REFRESH_UI: toPositiveMilliseconds(
+        process.env.NEXT_PUBLIC_APP_REFRESH_UI ?? process.env.NEXT_PUBLIC_UI_REFRESH_TIMEOUT,
+        30 * 1000
+    ),
 
     AUTH_HOST: process.env.NEXT_PUBLIC_AUTH_HOST as unknown as string,
     CONNECT_HOST: process.env.NEXT_PUBLIC_CONNECT_HOST as unknown as string,

package/src/domain/config/auth.config.ts

@@ -21,6 +21,13 @@ export const AuthConfig = {
         clientId: process.env.NEXT_PUBLIC_AUTH_CLIENT_ID || 'liorian-socle',
         /** Chemin de rappel SSO de l'application (code + state). */
         redirectPath: '/auth/callback',
+        /**
+         * Mode de déclenchement du SSO :
+         *  - `redirect` (défaut) : redirection pleine page vers Liorian Auth ;
+         *  - `popup` : fenêtre popup, avec repli automatique en redirection si bloquée.
+         * Configurable par application via `NEXT_PUBLIC_AUTH_SSO_MODE`.
+         */
+        mode: (process.env.NEXT_PUBLIC_AUTH_SSO_MODE === 'popup' ? 'popup' : 'redirect') as 'popup' | 'redirect',
     },
     excludes: [
         '/auth',

package/src/infrastructure/hooks/index.ts

@@ -7,4 +7,5 @@ export * from "./use-is-tauri";
 export * from "./use-mobile";
 export * from "./use-notifications";
 export * from "./use-recent-colors";
-export * from "./use-recent-modules";
+export * from "./use-recent-modules";
+export * from "./use-sso-login";

package/src/infrastructure/hooks/use-sso-login.ts

@@ -0,0 +1,126 @@
+"use client"
+
+import {useCallback, useEffect, useRef, useState} from "react"
+import {
+    SSO_CALLBACK_MESSAGE,
+    SSO_MODE,
+    SSO_RESULT_STORAGE_KEY,
+    startSsoLogin,
+    startSsoLoginPopup,
+} from "../utilities/sso-auth.util"
+
+export interface UseSsoLoginOptions {
+    /** Destination après une authentification réussie (navigation complète). Par défaut, recharge la page courante. */
+    redirectUrl?: string
+    /** Callback invoqué après une authentification réussie. */
+    onAuthenticated?: () => void
+    /** Callback invoqué en cas d'échec (popup fermé/refusé, redirection impossible). */
+    onError?: (error?: unknown) => void
+}
+
+export interface UseSsoLoginResult {
+    /** Vrai pendant le lancement et l'attente du flux SSO. */
+    connecting: boolean
+    /** Démarre le flux SSO selon le mode configuré (`redirect` par défaut, `popup` sur option). */
+    start: () => Promise<void>
+}
+
+/**
+ * Gère le déclenchement du SSO Liorian et la réception de son résultat.
+ *
+ * Le mode est lu depuis `AuthConfig.sso.mode` (`NEXT_PUBLIC_AUTH_SSO_MODE`) :
+ *  - `redirect` (défaut) : redirection pleine page, aucun écouteur requis ;
+ *  - `popup` : fenêtre popup (repli automatique en redirection si bloquée).
+ *
+ * En mode popup, le résultat est reçu via `postMessage` et, en repli lorsque
+ * `window.opener` a été neutralisé (COOP), via l'événement `storage`.
+ */
+export function useSsoLogin({redirectUrl, onAuthenticated, onError}: UseSsoLoginOptions = {}): UseSsoLoginResult {
+    const [connecting, setConnecting] = useState(false)
+    const settled = useRef(false)
+    const watcher = useRef<ReturnType<typeof setInterval> | null>(null)
+
+    const stopWatcher = useCallback(() => {
+        if (watcher.current) {
+            clearInterval(watcher.current)
+            watcher.current = null
+        }
+    }, [])
+
+    const finish = useCallback((success: boolean, error?: unknown) => {
+        if (settled.current) return
+        settled.current = true
+        stopWatcher()
+        setConnecting(false)
+
+        if (!success) {
+            onError?.(error)
+            return
+        }
+
+        onAuthenticated?.()
+        if (redirectUrl) {
+            window.location.assign(redirectUrl)
+        } else {
+            window.location.reload()
+        }
+    }, [redirectUrl, onAuthenticated, onError, stopWatcher])
+
+    useEffect(() => {
+        // En mode redirection, la navigation quitte la page : aucun écouteur requis.
+        if (SSO_MODE !== 'popup') return
+
+        const onMessage = (event: MessageEvent) => {
+            if (event.origin !== window.location.origin) return
+            if (event.data?.source !== 'liorian-auth') return
+            if (event.data?.type !== SSO_CALLBACK_MESSAGE) return
+            finish(Boolean(event.data?.success))
+        }
+        const onStorage = (event: StorageEvent) => {
+            if (event.key !== SSO_RESULT_STORAGE_KEY || !event.newValue) return
+            try {
+                finish(Boolean(JSON.parse(event.newValue)?.success))
+            } catch {
+                // Valeur illisible : ignorer.
+            }
+        }
+
+        window.addEventListener('message', onMessage)
+        window.addEventListener('storage', onStorage)
+        return () => {
+            window.removeEventListener('message', onMessage)
+            window.removeEventListener('storage', onStorage)
+            stopWatcher()
+        }
+    }, [finish, stopWatcher])
+
+    const start = useCallback(async () => {
+        if (connecting) return
+        settled.current = false
+        setConnecting(true)
+
+        try {
+            if (SSO_MODE !== 'popup') {
+                await startSsoLogin()
+                return
+            }
+
+            const popup = await startSsoLoginPopup()
+            if (!popup) {
+                await startSsoLogin()
+                return
+            }
+
+            // Popup fermé sans résultat : réactiver le bouton côté onglet d'origine.
+            watcher.current = setInterval(() => {
+                if (popup.closed) {
+                    finish(false, new Error('Fenêtre d’authentification fermée.'))
+                }
+            }, 500)
+        } catch (error) {
+            finish(false, error)
+        }
+    }, [connecting, finish])
+
+    return {connecting, start}
+}

package/src/infrastructure/providers/auth.provider.tsx

@@ -46,7 +46,7 @@ export function AuthProvider({children, requireOrganization = true}: AuthProvide
                 if (!armed()) return
                 ActivityLockService.start({
                     userId,
-                    timeout: Number(AppConfig.UI_ACTIVITY_TRACKER_TIMEOUT),
+                    timeout: AppConfig.UI_ACTIVITY_TRACKER_TIMEOUT,
                     onLocked: () => setLocked(true),
                 })
             })

package/src/infrastructure/utilities/activity-lock.service.ts

@@ -12,9 +12,6 @@ export const ACTIVITY_LOCK_PREFERENCE_LABEL = "ui_activity_tracker_timeout";
 /** Clé localStorage du verrou : persiste l'état verrouillé même après un rafraîchissement. */
 const ACTIVITY_LOCK_STORAGE_KEY = "@liorian-activity-lock";
 
-/** Délai d'inactivité par défaut (repli) : 3 minutes. */
-const DEFAULT_TIMEOUT = 3 * 60 * 1000;
-
 export interface ActivityLockState {
     locked: boolean;
     userId?: string;
@@ -115,6 +112,11 @@ export class ActivityLockService {
     /**
      * Résout le délai d'inactivité : préférence utilisateur persistée (si définie),
      * sinon `AppConfig.UI_ACTIVITY_TRACKER_TIMEOUT`, sinon valeur par défaut.
+     *
+     * La préférence utilisateur prime volontairement sur la configuration
+     * `NEXT_PUBLIC_UI_ACTIVITY_TRACKER_TIMEOUT` : c'est le comportement attendu,
+     * mais une trace (mode développement) indique la source réellement appliquée
+     * pour lever toute ambiguïté.
      */
     static async getTimeout(userId?: string): Promise<number> {
         if (userId) {
@@ -122,10 +124,23 @@ export class ActivityLockService {
                 .getValue(userId, ACTIVITY_LOCK_PREFERENCE_LABEL)
                 .catch(() => undefined);
             const parsed = raw ? Number(raw) : NaN;
-            if (Number.isFinite(parsed) && parsed > 0) return parsed;
+            if (Number.isFinite(parsed) && parsed > 0) {
+                if (process.env.NODE_ENV === "development") {
+                    console.info(
+                        `[ActivityLock] Préférence utilisateur "${ACTIVITY_LOCK_PREFERENCE_LABEL}" = ${parsed} ms —` +
+                        "elle prime sur NEXT_PUBLIC_UI_ACTIVITY_TRACKER_TIMEOUT."
+                    );
+                }
+                return parsed;
+            }
+        }
+        if (process.env.NODE_ENV === "development") {
+            console.info(
+                `[ActivityLock] Délai d'inactivité = ${AppConfig.UI_ACTIVITY_TRACKER_TIMEOUT} ms` +
+                "(NEXT_PUBLIC_UI_ACTIVITY_TRACKER_TIMEOUT)."
+            );
         }
-        const config = Number(AppConfig.UI_ACTIVITY_TRACKER_TIMEOUT);
-        return Number.isFinite(config) && config > 0 ? config : DEFAULT_TIMEOUT;
+        return AppConfig.UI_ACTIVITY_TRACKER_TIMEOUT;
     }
 
     /** Persiste le délai d'inactivité choisi par l'utilisateur (via UserPreference). */
@@ -149,7 +164,7 @@ export class ActivityLockService {
 
         this.enabled = true;
         this.userId = options.userId;
-        this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+        this.timeout = options.timeout ?? AppConfig.UI_ACTIVITY_TRACKER_TIMEOUT;
         this.onLocked = options.onLocked;
 
         // S'assure que le tracker d'activité tourne (partagé avec les notifications push) :

package/src/infrastructure/utilities/sso-auth.util.ts

@@ -10,28 +10,47 @@ import {authUserConnectedStore} from "../stores/auth-user-connected.store";
  * Client OAuth 2.0 (Authorization Code + PKCE) vers Liorian Auth.
  *
  * Utilisé par les applications consommatrices (ex. liorian-socle) pour
- * s'authentifier via le SSO de `liorian-auth`. Deux modes de déclenchement :
- *  - fenêtre popup (`startSsoLoginPopup`) — privilégié ;
- *  - redirection complète (`startSsoLogin`) — solution de repli si le popup est bloqué.
+ * s'authentifier via le SSO de `liorian-auth`. Deux modes de déclenchement,
+ * choisis par `NEXT_PUBLIC_AUTH_SSO_MODE` (défaut : redirection) :
+ *  - redirection complète (`startSsoLogin`) — mode par défaut ;
+ *  - fenêtre popup (`startSsoLoginPopup`) — optionnel, repli en redirection si bloquée.
  *
  * Les secrets PKCE (`code_verifier`/`state`) sont stockés en `localStorage`
  * (et non en `sessionStorage`) afin d'être partagés entre l'onglet principal
- * et le popup de la même origine.
+ * et le popup de la même origine. Le mode courant y est également mémorisé afin
+ * de fermer le popup de façon fiable, même lorsque `window.opener` est neutralisé
+ * (Cross-Origin-Opener-Policy). Le résultat est alors aussi publié via
+ * `localStorage` pour prévenir l'onglet d'origine.
  */
 
+/** Mode de déclenchement du SSO (voir `AuthConfig.sso.mode`). */
+export type SsoMode = 'redirect' | 'popup';
+
 /** Identifiant OAuth de l'application consommatrice (configurable par application). */
 export const SSO_CLIENT_ID = AuthConfig.sso.clientId;
 export const SSO_SCOPE = 'openid profile email organizations';
 export const SSO_REDIRECT_PATH = AuthConfig.sso.redirectPath;
 
+/** Mode SSO effectif de l'application (`redirect` par défaut, `popup` sur option). */
+export const SSO_MODE: SsoMode = AuthConfig.sso.mode;
+
 const SSO_STORAGE = {
     codeVerifier: 'sso.code_verifier',
     state: 'sso.state',
+    mode: 'sso.mode',
+    result: 'sso.result',
 } as const;
 
 /** Type de message posté par le popup de callback vers l'onglet d'origine. */
 export const SSO_CALLBACK_MESSAGE = 'SSO_CALLBACK';
 
+/**
+ * Clé `localStorage` publiée par le popup à la fin du callback. Sert de repli
+ * à `postMessage` : l'onglet d'origine écoute l'événement `storage` pour savoir
+ * si l'authentification a réussi.
+ */
+export const SSO_RESULT_STORAGE_KEY = SSO_STORAGE.result;
+
 function ssoOrigin(): string {
     return (AppConfig.AUTH_HOST || 'https://localhost:5050').replace(/\/$/, '');
 }
@@ -54,6 +73,10 @@ async function sha256Base64url(input: string): Promise<string> {
     return base64url(digest);
 }
 
+function randomId(): string {
+    return Math.random().toString(36).slice(2);
+}
+
 /** Construit l'URL d'autorisation vers Liorian Auth (PKCE S256). */
 export async function buildSsoLoginUrl(clientId: string = AuthConfig.sso.clientId): Promise<string> {
     const codeVerifier = randomBase64url(64);
@@ -75,19 +98,22 @@ export async function buildSsoLoginUrl(clientId: string = AuthConfig.sso.clientI
     return url.toString();
 }
 
-/** Redirige toute la fenêtre vers Liorian Auth. */
+/** Redirige toute la fenêtre vers Liorian Auth (mode redirection, par défaut). */
 export async function startSsoLogin(clientId?: string): Promise<void> {
+    localStorage.removeItem(SSO_STORAGE.mode);
     window.location.assign(await buildSsoLoginUrl(clientId));
 }
 
 /**
- * Ouvre un popup Liorian Auth pour se connecter.
+ * Ouvre un popup Liorian Auth pour se connecter (mode popup, optionnel).
  * Retourne la référence de la fenêtre, ou `null` si le popup a été bloqué
- * (appelant doit alors basculer sur une redirection).
+ * (l'appelant doit alors basculer sur une redirection).
  */
 export async function startSsoLoginPopup(clientId?: string): Promise<Window | null> {
     const url = await buildSsoLoginUrl(clientId);
 
+    localStorage.setItem(SSO_STORAGE.mode, 'popup');
+
     const width = 480;
     const height = 720;
     const left = window.screenX + (window.outerWidth - width) / 2;
@@ -100,16 +126,33 @@ export async function startSsoLoginPopup(clientId?: string): Promise<Window | nu
     );
 }
 
-/** Vrai si la page de callback s'exécute dans un popup ouvert par `startSsoLoginPopup`. */
+/**
+ * Vrai si la page de callback s'exécute dans un popup ouvert par `startSsoLoginPopup`.
+ *
+ * Seul le marqueur mémorisé par `startSsoLoginPopup` fait foi : une redirection
+ * pleine page (`startSsoLogin`) doit toujours ramener l'utilisateur dans
+ * l'onglet courant, même si ce dernier possède un `window.opener` (onglet ouvert
+ * par un lien `_blank`, webview Tauri, etc.). Se fier à `window.opener` ferait
+ * passer ce callback pour un popup : la session serait installée mais la
+ * navigation jamais déclenchée, laissant l'utilisateur bloqué sur le callback.
+ */
 export function isSsoCallbackInPopup(): boolean {
-    return typeof window !== 'undefined' && !!window.opener && window.location !== window.opener.location;
+    if (typeof window === 'undefined') return false;
+    try {
+        return window.localStorage.getItem(SSO_STORAGE.mode) === 'popup';
+    } catch {
+        // Stockage indisponible : on retombe sur la détection par `window.opener`.
+        return !!window.opener && window.opener !== window;
+    }
 }
 
 /**
  * Échange le code d'autorisation (callback) contre une session et l'installe.
  *
- * En mode popup, le résultat est renvoyé à l'onglet d'origine via `postMessage`
- * puis le popup est refermé (retourne `false` pour empêcher la navigation).
+ * En mode popup, le résultat est renvoyé à l'onglet d'origine (`postMessage` +
+ * repli `localStorage`) puis le popup est refermé : la méthode retourne `false`
+ * pour empêcher la navigation. En mode redirection, elle retourne `true` en cas
+ * de succès et lève une erreur en cas d'échec pour laisser l'appelant rediriger.
  */
 export async function handleSsoCallback(): Promise<boolean> {
     const params = new URLSearchParams(window.location.search);
@@ -121,10 +164,10 @@ export async function handleSsoCallback(): Promise<boolean> {
 
     if (error || !code) {
         if (isPopup) {
-            postResult(window.opener, false);
-            window.close();
+            finishPopup(false);
+            return false;
         }
-        return false;
+        throw new Error(params.get('error_description') || error || 'Code d’autorisation manquant.');
     }
 
     try {
@@ -158,31 +201,49 @@ export async function handleSsoCallback(): Promise<boolean> {
         authUserConnectedStore.getState().setCurrentUser(authData.user);
         authUserConnectedStore.getState().setOrganizations(authData.organizations || []);
 
-        localStorage.removeItem(SSO_STORAGE.codeVerifier);
-        localStorage.removeItem(SSO_STORAGE.state);
-
-        if (isPopup && window.opener) {
-            postResult(window.opener, true);
-            window.close();
+        if (isPopup) {
+            finishPopup(true);
             return false;
         }
 
+        localStorage.removeItem(SSO_STORAGE.codeVerifier);
+        localStorage.removeItem(SSO_STORAGE.state);
         return true;
     } catch (e) {
-        // En mode popup : signaler l'échec à l'onglet d'origine et refermer le popup,
-        // sinon l'écran reste bloqué sur « Finalisation de la connexion… ».
-        if (isPopup && window.opener) {
-            postResult(window.opener, false);
-            window.close();
+        // En mode popup : signaler l'échec puis refermer, sinon l'écran reste
+        // bloqué sur « Finalisation de la connexion… ».
+        if (isPopup) {
+            finishPopup(false);
             return false;
         }
         throw e;
     }
 }
 
-function postResult(opener: Window, success: boolean): void {
-    opener.postMessage(
-        {source: 'liorian-auth', type: SSO_CALLBACK_MESSAGE, success},
-        window.location.origin,
-    );
-}
+/**
+ * Clôt le popup : notifie l'onglet d'origine puis referme la fenêtre.
+ *
+ * Le résultat est publié à la fois par `postMessage` (si `window.opener` est
+ * disponible) et via `localStorage`, dont l'événement `storage` est reçu par
+ * l'onglet d'origine même lorsque COOP a neutralisé l'opener.
+ */
+function finishPopup(success: boolean): void {
+    localStorage.removeItem(SSO_STORAGE.codeVerifier);
+    localStorage.removeItem(SSO_STORAGE.state);
+    localStorage.removeItem(SSO_STORAGE.mode);
+    localStorage.setItem(SSO_STORAGE.result, JSON.stringify({success, id: randomId()}));
+
+    const opener = window.opener;
+    if (opener) {
+        try {
+            opener.postMessage(
+                {source: 'liorian-auth', type: SSO_CALLBACK_MESSAGE, success},
+                window.location.origin,
+            );
+        } catch {
+            // Opener cross-origin : le résultat reste disponible via `localStorage`.
+        }
+    }
+
+    window.close();
+}

package/src/presentation/components/auth/sso-callback.view.tsx

@@ -2,7 +2,7 @@
 
 import {useEffect, useRef} from "react";
 import {useRouter} from "next/navigation";
-import {handleSsoCallback, isSsoCallbackInPopup} from "../../../infrastructure/utilities/sso-auth.util";
+import {handleSsoCallback} from "../../../infrastructure/utilities/sso-auth.util";
 import {Activity} from "../activity";
 
 export interface SsoCallbackViewProps {
@@ -27,11 +27,12 @@ export function SsoCallbackView({successRedirect = '/', errorRedirect = '/auth/s
         }
         done.current = true;
         handleSsoCallback()
-            .then(() => {
-                if (!isSsoCallbackInPopup()) router.replace(successRedirect);
+            .then((handledInPage) => {
+                // `false` : le résultat a été renvoyé au popup appelant, la fenêtre se ferme.
+                if (handledInPage) router.replace(successRedirect);
             })
             .catch(() => {
-                if (!isSsoCallbackInPopup()) router.replace(errorRedirect);
+                router.replace(errorRedirect);
             });
     }, [router, successRedirect, errorRedirect]);
 

package/src/presentation/components/auth/sso-sign-in.view.tsx

@@ -1,24 +1,34 @@
 "use client";
 
-import {useEffect} from "react";
-import {startSsoLogin} from "../../../infrastructure/utilities/sso-auth.util";
+import {useEffect, useRef} from "react";
+import {useSsoLogin} from "../../../infrastructure/hooks/use-sso-login";
 import {Activity} from "../activity";
 
 export interface SsoSignInViewProps {
+    /** Destination après une authentification réussie en mode popup. */
+    successRedirect?: string
     /** Destination si le SSO ne peut pas être démarré (popup/redirection bloquée). */
     fallbackRedirect?: string
 }
 
 /**
- * Écran de connexion SSO : redirige vers Liorian Auth (flux Authorization Code
- * + PKCE) dès le montage. Réutilisable par toutes les applications consommatrices.
+ * Écran de connexion SSO : lance le flux Liorian Auth (Authorization Code + PKCE)
+ * dès le montage, selon le mode configuré (`NEXT_PUBLIC_AUTH_SSO_MODE` :
+ * `redirect` par défaut, `popup` sur option). Réutilisable par toutes les
+ * applications consommatrices.
  */
-export function SsoSignInView({fallbackRedirect = '/auth/sign-up'}: SsoSignInViewProps) {
+export function SsoSignInView({successRedirect = '/', fallbackRedirect = '/auth/sign-up'}: SsoSignInViewProps) {
+    const {start} = useSsoLogin({
+        redirectUrl: successRedirect,
+        onError: () => window.location.assign(fallbackRedirect),
+    });
+    const started = useRef(false);
+
     useEffect(() => {
-        startSsoLogin().catch(() => {
-            window.location.assign(fallbackRedirect);
-        });
-    }, [fallbackRedirect]);
+        if (started.current) return;
+        started.current = true;
+        void start();
+    }, [start]);
 
     return (
         <div className="flex min-h-svh flex-col items-center justify-center gap-4 bg-background">
@@ -26,4 +36,4 @@ export function SsoSignInView({fallbackRedirect = '/auth/sign-up'}: SsoSignInVie
             <p className="text-sm text-muted-foreground">Connexion…</p>
         </div>
     );
-}
+}

package/src/presentation/components/auth-lock-screen.tsx

@@ -7,7 +7,7 @@ import {AppConfig} from "../../domain/config/app.config"
 import {AuthUserService} from "../../application/service/auth-user.service"
 import {AuthApiService, webauthnBytes} from "../../application/service/auth-api-service"
 import {ActivityLockService} from "../../infrastructure/utilities/activity-lock.service"
-import {startSsoLogin, startSsoLoginPopup, SSO_CALLBACK_MESSAGE} from "../../infrastructure/utilities/sso-auth.util"
+import {useSsoLogin} from "../../infrastructure/hooks/use-sso-login"
 import {Avatar, AvatarFallback} from "../ui/avatar"
 import {Button} from "../ui/button"
 import {Input} from "../ui/input"
@@ -49,7 +49,6 @@ export function AuthLockScreen(
         onUnlocked,
         actionLabel = 'Se connecter avec Liorian Auth',
     }: AuthLockScreenProps) {
-    const [connecting, setConnecting] = useState(false)
     const [user, setUser] = useState<UserInterface | null>(null)
     const [mode, setMode] = useState<'sso' | 'unlock'>(() => AuthUserService.isAuthenticated() ? 'unlock' : 'sso')
     const [password, setPassword] = useState('')
@@ -57,6 +56,11 @@ export function AuthLockScreen(
     const [unlocking, setUnlocking] = useState(false)
     const [error, setError] = useState<string | null>(null)
 
+    // Connexion SSO Liorian : déléguée au hook partagé (redirection par défaut,
+    // popup sur option). Le hook gère le repli, la fermeture du popup et la
+    // réception du résultat, puis déclenche `onAuthenticated` / la navigation.
+    const {connecting, start: startSsoLoginFlow} = useSsoLogin({redirectUrl, onAuthenticated})
+
     useEffect(() => {
         setUser(AuthUserService.getUser())
     }, [])
@@ -81,52 +85,8 @@ export function AuthLockScreen(
         return {name, avatarId, initials};
     }, [user]);
 
-    useEffect(() => {
-        const onMessage = (event: MessageEvent) => {
-            if (event.origin !== window.location.origin) return;
-            if (event.data?.source !== 'liorian-auth') return;
-            if (event.data?.type !== SSO_CALLBACK_MESSAGE) return;
-
-            if (event.data?.success) {
-                setConnecting(false);
-                onAuthenticated?.();
-                // La session a été installée dans le `localStorage` partagé : on force une
-                // navigation complète pour que `AuthProvider` ré-hydrate le store depuis le stockage.
-                if (redirectUrl) {
-                    window.location.assign(redirectUrl);
-                } else {
-                    window.location.reload();
-                }
-            } else {
-                setConnecting(false);
-            }
-        };
-        window.addEventListener('message', onMessage);
-        return () => window.removeEventListener('message', onMessage);
-    }, [redirectUrl, onAuthenticated]);
-
-    const handleAuthenticate = async () => {
-        if (connecting) return;
-        setConnecting(true);
-        try {
-            const popup = await startSsoLoginPopup();
-            if (!popup) {
-                await startSsoLogin();
-                return;
-            }
-
-            // Si le popup est fermé sans message de succès, réactiver le bouton.
-            const watchPopup = setInterval(() => {
-                if (popup.closed) {
-                    clearInterval(watchPopup);
-                    setConnecting(false);
-                }
-            }, 500);
-            window.addEventListener('beforeunload', () => clearInterval(watchPopup));
-        } catch (e) {
-            console.error('Impossible de démarrer l’authentification SSO', e);
-            setConnecting(false);
-        }
+    const handleAuthenticate = () => {
+        void startSsoLoginFlow();
     };
 
     const handleUnlockWithPassword = async (e: React.FormEvent<HTMLFormElement>) => {

package/src/presentation/components/index.tsx

@@ -16,6 +16,7 @@ export * from "./local-time";
 export * from "./markdown-parser";
 export * from "./message-scroller";
 export * from "./module-first-access-config.view";
+export * from "./navigation-progress";
 export * from "./module-first-access-pending.view";
 export * from "./module-guard";
 export * from "./modules-first-access.guard";
@@ -24,6 +25,7 @@ export * from "./notification-details.modal";
 export * from "./notification-item";
 export * from "./notifications-popover";
 export * from "./push-notifications.provider";
+export * from "./redirect";
 export * from "./upload-progress-dialog";
 export * from "./waiting";
 export * from "./waiting-bar";

package/src/presentation/components/navigation-progress.tsx

@@ -0,0 +1,135 @@
+"use client"
+
+import * as React from "react";
+import {usePathname} from "next/navigation";
+import {useIsFetching} from "@tanstack/react-query";
+import {WaitingBar} from "./waiting-bar";
+import {cn} from "../../infrastructure/utilities/utils";
+
+// Délai avant affichage : évite tout flash sur les navigations instantanées
+const SHOW_DELAY_MS = 150;
+// Filet de sécurité : la barre ne doit jamais rester bloquée à l'écran
+const SAFETY_TIMEOUT_MS = 20_000;
+
+/**
+ Barre de progression de navigation globale, visible :
+ - dès que l'utilisateur entame un changement de page (clic sur un lien
+   interne ou navigation programmatique),
+ - pendant que le serveur compile la page demandée (dev, compilation à la
+   demande : le clic bloque jusqu'à la fin de compilation),
+ puis masquée dès que la page cible est affichée.
+ S'affiche aussi pendant les requêtes react-query en cours (comportement
+ historique).
+ */
+export function NavigationProgress() {
+    const isFetching = useIsFetching() > 0;
+
+    const [navigating, setNavigating] = React.useState(false);
+    const pathname = usePathname();
+
+    const targetRef = React.useRef<string | null>(null);
+    const showTimerRef = React.useRef<ReturnType<typeof setTimeout> | null>(null);
+    const safetyTimerRef = React.useRef<ReturnType<typeof setTimeout> | null>(null);
+
+    const finish = React.useCallback(() => {
+        if (showTimerRef.current) clearTimeout(showTimerRef.current);
+        if (safetyTimerRef.current) clearTimeout(safetyTimerRef.current);
+        showTimerRef.current = null;
+        safetyTimerRef.current = null;
+        targetRef.current = null;
+        setNavigating(false);
+    }, []);
+
+    React.useEffect(() => {
+        const currentPath = () => window.location.pathname + window.location.search;
+
+        const startNavigation = (path: string) => {
+            if (path === currentPath()) return;
+            targetRef.current = path;
+            if (showTimerRef.current) clearTimeout(showTimerRef.current);
+            showTimerRef.current = setTimeout(() => setNavigating(true), SHOW_DELAY_MS);
+            if (safetyTimerRef.current) clearTimeout(safetyTimerRef.current);
+            safetyTimerRef.current = setTimeout(finish, SAFETY_TIMEOUT_MS);
+        };
+
+        // 1. Clic sur un lien interne : signal immédiat, y compris pendant que
+        //    le serveur compile la page suivante (aucun événement routeur tant
+        //    que la compilation/RSC n'est pas prête).
+        const onClickCapture = (event: MouseEvent) => {
+            if (event.defaultPrevented || event.button !== 0 ||
+                event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+            const anchor = (event.target as Element | null)?.closest?.("a");
+            if (!anchor) return;
+            const href = anchor.getAttribute("href");
+            if (!href || href.startsWith("#")) return;
+            if (anchor.target === "_blank" || anchor.hasAttribute("download")) return;
+            let url: URL;
+            try {
+                url = new URL(anchor.href, window.location.href);
+            } catch {
+                return;
+            }
+            if (url.origin !== window.location.origin) return;
+            startNavigation(url.pathname + url.search);
+        };
+
+        // 2. Navigations programmatiques (router.push…) : le routeur passe par
+        //    l'History API au moment où il confirme la navigation.
+        const wrap = (key: "pushState" | "replaceState") => {
+            const original = window.history[key].bind(window.history);
+            (window.history as any)[key] = (data: unknown, unused: string, url?: string | URL | null) => {
+                try {
+                    if (url != null) {
+                        const parsed = new URL(String(url), window.location.href);
+                        if (parsed.origin === window.location.origin) {
+                            startNavigation(parsed.pathname + parsed.search);
+                        }
+                    }
+                } catch {
+                    // URL non parsable : ignorer silencieusement
+                }
+                const result = original(data, unused, url as never);
+                // Navigation confirmée : masque dès que la cible est atteinte
+                if (targetRef.current && currentPath() === targetRef.current) {
+                    setTimeout(finish, 0);
+                }
+                return result;
+            };
+            return original;
+        };
+
+        const originalPush = wrap("pushState");
+        const originalReplace = wrap("replaceState");
+
+        document.addEventListener("click", onClickCapture, true);
+        return () => {
+            document.removeEventListener("click", onClickCapture, true);
+            window.history.pushState = originalPush;
+            window.history.replaceState = originalReplace;
+            if (showTimerRef.current) clearTimeout(showTimerRef.current);
+            if (safetyTimerRef.current) clearTimeout(safetyTimerRef.current);
+        };
+    }, [finish]);
+
+    // Filet complémentaire : la page cible est rendue (changement de route
+    // détecté par le routeur) alors que le push n'aurait pas suffi.
+    React.useEffect(() => {
+        if (targetRef.current && window.location.pathname + window.location.search === targetRef.current) {
+            finish();
+        }
+    }, [pathname, finish]);
+
+    const visible = navigating || isFetching;
+
+    return (
+        <div
+            aria-hidden={!visible}
+            className={cn(
+                "fixed top-0 left-0 right-0 z-9999 transition-opacity duration-300",
+                visible ? "opacity-100" : "opacity-0 pointer-events-none",
+            )}
+        >
+            <WaitingBar/>
+        </div>
+    );
+}

package/src/presentation/components/redirect.tsx

@@ -0,0 +1,14 @@
+"use client"
+
+import {useEffect} from "react";
+import {useRouter} from "next/navigation";
+
+export function Redirect({to}: { to: string }) {
+    const router = useRouter();
+
+    useEffect(() => {
+        router.replace(to);
+    }, [router, to]);
+
+    return null;
+}