@aurabase/aurabase-js 0.3.0 → 0.3.1

package/packages/core/src/fetch.ts

@@ -1,435 +0,0 @@
-import { AuraError } from './AuraError'
-import type { AuraResponse, TokenPair, Meta } from './types'
-import { emitAuraEvent } from './types'
-import type { AuraClientLike } from './client'
-import { isTokenExpired } from './stores/BaseAuthStore'
-import {
-  isRetryableMethod,
-  isRetryableStatus,
-  computeBackoff,
-  parseRetryAfter,
-  abortableSleep,
-  isAbortError,
-  DEFAULT_MAX_RETRIES,
-} from './retry'
-import { serializeBody } from './serialize'
-
-const REFRESH_MARGIN_SEC = 30
-
-/** Plafond du délai `Retry-After` (borne un serveur renvoyant une valeur énorme). */
-const RETRY_AFTER_CAP_MS = 60_000
-
-/** Timeout par défaut d'une requête HTTP (borne un serveur qui « hang »). */
-export const DEFAULT_REQUEST_TIMEOUT_MS = 30_000
-
-/**
- * Déballe l'enveloppe backend `{data, meta}` de façon SÛRE (minor 6b).
- * `'data' in body` JETTE un TypeError si `body` n'est pas un objet (corps JSON
- * primitif ou `null` : `42`, `"x"`, `null`). On garde alors le corps tel quel comme
- * `data` (pas de throw, pas de perte de valeur). `null` explicite dans une enveloppe
- * (`{data:null,meta:null}`) reste distingué de « absent » (I5).
- */
-function unwrapEnvelope(body: unknown): unknown {
-  if (body !== null && typeof body === 'object' && 'data' in body) {
-    return (body as { data: unknown }).data
-  }
-  return body
-}
-
-/**
- * Single-flight de rafraîchissement (E17).
- * Une seule promesse de refresh en vol par client : `maybeRefresh` (proactif),
- * `AuthService.refreshSession` (manuel) et le retry 401 (E19) passent TOUS par
- * `refreshOnce`, ce qui évite deux refresh concurrents avec le même refresh token
- * (qui, sur un backend à rotation stricte, provoquaient une déconnexion aléatoire).
- */
-const inflightRefreshes = new WeakMap<AuraClientLike, Promise<AuraResponse<TokenPair>>>()
-
-/** Effectue le refresh (sans dédup) — appelé uniquement via `refreshOnce`. */
-async function doRefresh(client: AuraClientLike): Promise<AuraResponse<TokenPair>> {
-  const store = client.authStore
-  const rt = store.refreshToken
-  if (!rt) {
-    return {
-      data: null,
-      error: new AuraError(0, { error: { code: 'no_session', message: 'No refresh token available' } }),
-    }
-  }
-  // Commit-guard (B) : snapshot (epoch + refresh token) avant le fetch. Si un clear()/signOut
-  // OU un save()/signIn concurrent (ou une rotation par un autre onglet) s'intercale pendant
-  // l'await, la session courante a changé → on ne doit NI la ressusciter (succès) NI l'effacer
-  // (échec sur l'ancien token). On compare epoch ET l'identité du refresh token.
-  const epoch = store.removalEpoch
-  let res: Response
-  try {
-    res = await client.fetchFn(`${client.baseUrl}/v1/auth/${client.projectId}/refresh`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: serializeBody({ refresh_token: rt }),
-    })
-  } catch (err) {
-    // Erreur réseau : on garde les tokens existants (peut-être encore valides).
-    return {
-      data: null,
-      error: new AuraError(0, {
-        error: { code: 'network_error', message: err instanceof Error ? err.message : 'Network request failed' },
-      }),
-    }
-  }
-  if (!res.ok) {
-    let body: { error?: { code?: string; message?: string }; message?: string } | null = null
-    try {
-      body = await res.json()
-    } catch {
-      // corps non-JSON
-    }
-    // Clear sélectif (B, proactive-preserve) : ne détruire la session que sur rejet DÉFINITIF
-    // du refresh token (invalide/révoqué/expiré). Sur transitoire (5xx/429/408/réseau), on
-    // préserve la session. Commit-guard : ne PAS effacer une session déjà changée pendant
-    // l'await (signIn/rotation concurrente) — le 401 porte alors sur un ANCIEN token.
-    if (res.status === 400 || res.status === 401 || res.status === 403) {
-      if (store.removalEpoch === epoch && store.refreshToken === rt) {
-        store.clear()
-      }
-    }
-    return { data: null, error: new AuraError(res.status, body) }
-  }
-  // Chemin succès : le corps DOIT être du JSON. Un 200 non-JSON (proxy mal
-  // configuré, page HTML d'erreur renvoyée en 200…) ne doit pas faire rejeter
-  // la promesse `refreshOnce` (les appelants attendent un AuraResponse, jamais
-  // un throw) — on renvoie un AuraError structuré, cohérent avec le chemin erreur.
-  let body: { data?: TokenPair } & Partial<TokenPair>
-  try {
-    body = await res.json()
-  } catch {
-    return {
-      data: null,
-      error: new AuraError(0, { error: { code: 'invalid_response', message: 'Invalid refresh response (non-JSON body)' } }),
-    }
-  }
-  // I5 : `'data' in body` (pas `body.data ?? body`) — un `data` EXPLICITEMENT `null`
-  // dans l'enveloppe backend (`ApiResponse::empty()` → `{"data":null,"meta":null}`)
-  // ne doit jamais retomber sur l'enveloppe entière (nullish coalescing traite `null`
-  // comme absent). Ici la réponse de refresh a toujours un `data` enveloppé ; ce
-  // garde-fou reste cohérent avec le même correctif dans `fetchWithAuth`.
-  const data = unwrapEnvelope(body) as TokenPair
-  if (data?.access_token && data?.refresh_token && data?.user) {
-    // Commit-guard : un clear()/signOut OU un save()/signIn concurrent s'est-il intercalé ?
-    // On compare l'epoch de suppression ET l'identité du refresh token utilisé.
-    if (store.removalEpoch !== epoch || store.refreshToken !== rt) {
-      emitAuraEvent(client.onEvent, client.debug, {
-        kind: 'refresh-discarded',
-        reason: 'Session changed during refresh (concurrent signIn/signOut/rotation)',
-      })
-      return {
-        data: null,
-        error: new AuraError(409, { error: { code: 'refresh_discarded', message: 'Session changed during refresh' } }),
-      }
-    }
-    store.save(data.access_token, data.refresh_token, data.user)
-    emitAuraEvent(client.onEvent, client.debug, { kind: 'refresh-success' })
-    return { data, error: null }
-  }
-  return {
-    data: null,
-    error: new AuraError(0, { error: { code: 'invalid_response', message: 'Invalid refresh response' } }),
-  }
-}
-
-/**
- * Coordination CROSS-ONGLETS du refresh via l'API Web Locks (I2). Le single-flight
- * `inflightRefreshes` ne dédup que DANS un onglet ; deux onglets pouvaient encore
- * lancer deux refresh concurrents avec le même refresh token → churn de rotation
- * (le commit-guard évitait la déconnexion mais pas la course). On enveloppe donc le
- * refresh dans `navigator.locks.request(lockName)` EN NAVIGATEUR uniquement ; hors
- * navigateur (SSR/Node) fallback au single-flight in-process seul (aucun lock).
- *
- * Anti-interblocage : l'ATTENTE d'acquisition est bornée par un `AbortSignal`
- * (timeout = requestTimeoutMs). Si un autre onglet tient le lock trop longtemps
- * (refresh qui « hang »), on n'attend pas indéfiniment — on abandonne le lock et on
- * exécute le refresh SANS coordination (fallback). Une fois le lock acquis, le timer
- * est désarmé (le signal n'a plus d'effet côté spec) : pas de double exécution.
- */
-function withRefreshLock(
-  client: AuraClientLike,
-  fn: () => Promise<AuraResponse<TokenPair>>,
-): Promise<AuraResponse<TokenPair>> {
-  // Web Locks = coordination cross-ONGLETS : purement navigateur. On gate sur
-  // `window` : sur un serveur Node (SSR), `navigator.locks` existe (Node 21+) mais
-  // est PROCESS-GLOBAL — deux requêtes d'utilisateurs différents partageant le même
-  // `projectId` verraient leurs refresh sérialisés par `aura-refresh-{projectId}`.
-  // En dehors d'un navigateur, on retombe sur le single-flight in-process seul.
-  const browser = typeof window !== 'undefined'
-  const nav = (globalThis as { navigator?: { locks?: { request?: unknown } } }).navigator
-  const locks = nav?.locks
-  if (!browser || !locks || typeof locks.request !== 'function') {
-    return fn()
-  }
-  const request = locks.request as (
-    name: string,
-    options: { signal?: AbortSignal },
-    cb: () => Promise<AuraResponse<TokenPair>>,
-  ) => Promise<AuraResponse<TokenPair>>
-
-  const lockName = `aura-refresh-${client.projectId}`
-  const timeoutMs =
-    (client.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS) || DEFAULT_REQUEST_TIMEOUT_MS
-
-  let timer: ReturnType<typeof setTimeout> | undefined
-  const options: { signal?: AbortSignal } = {}
-  if (typeof AbortController !== 'undefined') {
-    const ctrl = new AbortController()
-    timer = setTimeout(() => ctrl.abort(), timeoutMs)
-    ;(timer as unknown as { unref?: () => void }).unref?.()
-    options.signal = ctrl.signal
-  }
-  const clearTimer = (): void => {
-    if (timer) {
-      clearTimeout(timer)
-      timer = undefined
-    }
-  }
-
-  try {
-    return Promise.resolve(
-      request(lockName, options, () => {
-        // Lock acquis : désarmer le timer d'attente avant d'exécuter le refresh.
-        clearTimer()
-        return fn()
-      }),
-    ).catch(() => {
-      // Acquisition abandonnée (signal abort → AbortError) ou API en erreur
-      // (SecurityError…) : fallback SANS lock — jamais de blocage permanent.
-      clearTimer()
-      return fn()
-    })
-  } catch {
-    clearTimer()
-    return fn()
-  }
-}
-
-/** Point d'entrée unique du refresh, dédupliqué par client (single-flight). */
-export function refreshOnce(client: AuraClientLike): Promise<AuraResponse<TokenPair>> {
-  const existing = inflightRefreshes.get(client)
-  if (existing) return existing
-  // Le lock cross-onglets enveloppe le refresh ; le single-flight in-process (ci-dessus)
-  // reste la 1re barrière (une seule acquisition de lock par onglet à la fois).
-  const p = withRefreshLock(client, () => doRefresh(client)).finally(() =>
-    inflightRefreshes.delete(client),
-  )
-  inflightRefreshes.set(client, p)
-  return p
-}
-
-/** Refresh proactif : seulement si le token est (presque) expiré. */
-async function maybeRefresh(client: AuraClientLike): Promise<void> {
-  const store = client.authStore
-  if (!store.token || !store.refreshToken) return
-  if (!isTokenExpired(store.token, REFRESH_MARGIN_SEC)) return
-  await refreshOnce(client)
-}
-
-export interface FetchInit {
-  method?: string
-  headers?: Record<string, string>
-  body?: unknown
-  signal?: AbortSignal
-  skipAuthRefresh?: boolean
-  /**
-   * Override explicite du `Authorization: Bearer` (LOT D). S'il est fourni, il
-   * GAGNE sur `store.token` — permet de valider un token ARBITRAIRE (foreign)
-   * plutôt que celui de la session courante (ex. `getUser(jwt)`). Sans lui, le
-   * comportement historique s'applique (`Authorization = Bearer store.token`).
-   */
-  authToken?: string
-  /** Désactive le retry transitoire pour cette requête (override). */
-  skipRetry?: boolean
-  /** Interne (E19) : marque une requête déjà rejouée après refresh pour borner la récursion. */
-  _retried?: boolean
-}
-
-/**
- * Core fetch wrapper that handles:
- * - Lazy token refresh before expiry
- * - Authorization / API key injection
- * - Content-Type defaulting
- * - Structured AuraResponse parsing
- */
-export async function fetchWithAuth<T>(
-  url: string,
-  init: FetchInit,
-  client: AuraClientLike,
-): Promise<AuraResponse<T>> {
-  // Attempt lazy token refresh
-  if (!init.skipAuthRefresh) {
-    await maybeRefresh(client)
-  }
-
-  const method = (init.method ?? 'GET').toUpperCase()
-  const retryEnabled =
-    !init.skipRetry &&
-    (client.retryConfig?.enabled ?? true) &&
-    isRetryableMethod(method)
-  const maxRetries = client.retryConfig?.maxRetries ?? DEFAULT_MAX_RETRIES
-
-  const store = client.authStore
-  const isFormData = typeof FormData !== 'undefined' && init.body instanceof FormData
-
-  // Timeout par défaut : borne une requête vers un serveur qui « hang ». Appliqué
-  // seulement si l'appelant n'a pas fourni son propre `signal` (invoke, downloads…
-  // gèrent leur annulation) et si le corps n'est pas un FormData (uploads longs).
-  const timeoutMs = client.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS
-  const applyTimeout = timeoutMs > 0 && init.signal === undefined && !isFormData
-
-  let attempt = 0
-  for (;;) {
-    const headers: Record<string, string> = { ...init.headers }
-
-    // Inject auth headers (Supabase-compatible: apikey ALWAYS sent, JWT when authenticated)
-    if (client.apiKey) {
-      headers['apikey'] = client.apiKey
-    }
-    // LOT D : override `authToken` prioritaire sur `store.token`. Sans override,
-    // comportement historique (JWT de session injecté quand authentifié).
-    if (init.authToken) {
-      headers['Authorization'] = `Bearer ${init.authToken}`
-    } else if (store.token) {
-      headers['Authorization'] = `Bearer ${store.token}`
-    }
-    // Set Content-Type unless body is FormData
-    if (!isFormData && init.body !== undefined) {
-      headers['Content-Type'] = headers['Content-Type'] ?? 'application/json'
-    }
-    if (attempt > 0) {
-      headers['X-Retry-Count'] = String(attempt)
-    }
-
-    // Timer de timeout PAR TENTATIVE (chaque rejeu repart avec un timeout neuf).
-    // On utilise un AbortController maison (plutôt que AbortSignal.timeout) pour
-    // pouvoir clearTimeout dès la résolution — évite tout timer fantôme en test.
-    let timedOut = false
-    let timeoutTimer: ReturnType<typeof setTimeout> | undefined
-    let attemptSignal = init.signal
-    if (applyTimeout) {
-      const ctrl = new AbortController()
-      timeoutTimer = setTimeout(() => { timedOut = true; ctrl.abort() }, timeoutMs)
-      // `unref` (Node) pour ne pas bloquer la sortie de process ; no-op en navigateur.
-      ;(timeoutTimer as unknown as { unref?: () => void }).unref?.()
-      attemptSignal = ctrl.signal
-    }
-    const clearTimeoutTimer = () => { if (timeoutTimer) clearTimeout(timeoutTimer) }
-
-    const requestInit: RequestInit = {
-      method,
-      headers,
-      signal: attemptSignal,
-    }
-    if (init.body !== undefined) {
-      requestInit.body = isFormData ? (init.body as FormData) : serializeBody(init.body)
-    }
-
-    let res: Response
-    try {
-      res = await client.fetchFn(url, requestInit)
-    } catch (err) {
-      clearTimeoutTimer()
-      // Erreur réseau transitoire : rejeu (méthodes sûres uniquement, jamais sur AbortError).
-      // Un timeout produit un AbortError → non rejoué (échec borné et rapide).
-      if (retryEnabled && attempt < maxRetries && !isAbortError(err)) {
-        const nextAttempt = attempt + 1
-        emitAuraEvent(client.onEvent, client.debug, { kind: 'retry', attempt: nextAttempt, url })
-        await abortableSleep(computeBackoff(attempt), init.signal)
-        attempt = nextAttempt
-        continue
-      }
-      if (timedOut) {
-        emitAuraEvent(client.onEvent, client.debug, { kind: 'timeout', url })
-      }
-      // E18 : vraie instance AuraError (status 0 = erreur côté client).
-      return {
-        data: null,
-        error: new AuraError(0, {
-          error: timedOut
-            ? { code: 'timeout', message: `Request timed out after ${timeoutMs}ms` }
-            : { code: 'network_error', message: err instanceof Error ? err.message : 'Network request failed' },
-        }),
-      }
-    }
-    clearTimeoutTimer()
-
-    // Retry transitoire (GET/HEAD uniquement, statuts 408/429/502/503/504).
-    if (retryEnabled && attempt < maxRetries && isRetryableStatus(res.status)) {
-      // Retry-After prioritaire mais PLAFONNÉ (un serveur mal configuré/hostile pourrait
-      // renvoyer 86400 → sommeil de 24h, ou overflow setTimeout Node → retry immédiat).
-      const delay = Math.min(
-        parseRetryAfter(res.headers.get('Retry-After')) ?? computeBackoff(attempt),
-        RETRY_AFTER_CAP_MS,
-      )
-      // Consommer le corps non lu avant de rejouer (sinon fuite de socket sous undici/Node).
-      await res.body?.cancel().catch(() => {})
-      const nextAttempt = attempt + 1
-      emitAuraEvent(client.onEvent, client.debug, { kind: 'retry', attempt: nextAttempt, status: res.status, url })
-      await abortableSleep(delay, init.signal)
-      attempt = nextAttempt
-      continue
-    }
-
-    // E19 : retry réactif borné sur 401 (inchangé, orthogonal au retry transitoire).
-    if (
-      res.status === 401 &&
-      !init.skipAuthRefresh &&
-      !init._retried &&
-      client.authStore.refreshToken
-    ) {
-      const refreshed = await refreshOnce(client)
-      if (refreshed.data) {
-        // Consommer le corps 401 non lu avant de rejouer la requête.
-        await res.body?.cancel().catch(() => {})
-        return fetchWithAuth<T>(url, { ...init, _retried: true }, client)
-      }
-    }
-
-    // 204 No Content
-    if (res.status === 204) {
-      return { data: null, error: null }
-    }
-
-    // Error responses
-    if (!res.ok) {
-      let body: { error?: { code?: string; message?: string }; message?: string } | null = null
-      try {
-        body = await res.json()
-      } catch {
-        // non-JSON error body
-      }
-      // E18 : retourner la vraie instance (status, isUnauthorized, isRateLimited…).
-      return { data: null, error: new AuraError(res.status, body) }
-    }
-
-    // Successful JSON response
-    try {
-      const body = await res.json()
-      // I5 : `'data' in body` (pas `body.data ?? body`). `??` traite un `data`
-      // EXPLICITEMENT `null` comme absent et retombait sur l'enveloppe entière
-      // (`{data:null,meta:null}`) au lieu de `null` — ce qui rendait menteur le
-      // type `AuraResponse<null>` des méthodes void (`signOut`, `deleteUser`,
-      // `banUser`/`unbanUser`, `revokeSession`, `testEmailTemplate`…) : ces
-      // handlers renvoient réellement `ApiResponse::<()>::empty()` côté backend
-      // (`{"data":null,"meta":null}`, vérifié `services/aura-auth/src/handlers/
-      // {auth,admin,sessions,email_templates}.rs`) — donc `null` est la valeur
-      // honnête, pas l'enveloppe. `'data' in body` distingue « absent » (corps
-      // non enveloppé, legacy) de « explicitement null » (enveloppe vide).
-      return {
-        data: unwrapEnvelope(body) as T,
-        error: null,
-        meta:
-          body !== null && typeof body === 'object' && 'meta' in body
-            ? (body as { meta?: Meta }).meta
-            : undefined,
-      }
-    } catch {
-      return { data: null, error: null }
-    }
-  }
-}

package/packages/core/src/index.ts

@@ -1,22 +0,0 @@
-export { AuraError, isAuraError } from './AuraError'
-export type { AuraClientLike } from './client'
-export { fetchWithAuth, refreshOnce } from './fetch'
-export type { FetchInit } from './fetch'
-export { BaseService } from './BaseService'
-export { BaseAuthStore, isTokenExpired } from './stores/BaseAuthStore'
-export { LocalAuthStore } from './stores/LocalAuthStore'
-export { serializeBody } from './serialize'
-export { parseCookieHeader, serializeCookieHeader } from './cookie-utils'
-export type { SerializeCookieOptions } from './cookie-utils'
-export {
-  RETRYABLE_STATUS,
-  RETRYABLE_METHODS,
-  DEFAULT_MAX_RETRIES,
-  isRetryableStatus,
-  isRetryableMethod,
-  computeBackoff,
-  parseRetryAfter,
-  abortableSleep,
-  isAbortError,
-} from './retry'
-export * from './types'

package/packages/core/src/retry.ts

@@ -1,63 +0,0 @@
-/**
- * Primitives de résilience réseau (module pur, sans I/O).
- * `Math.random`/`Date.now` sont injectables pour des tests déterministes.
- */
-
-export const RETRYABLE_STATUS = new Set([408, 429, 502, 503, 504])
-export const RETRYABLE_METHODS = new Set(['GET', 'HEAD'])
-export const DEFAULT_MAX_RETRIES = 3
-
-const BASE_MS = 500
-const CAP_MS = 10_000
-
-export function isRetryableStatus(status: number): boolean {
-  return RETRYABLE_STATUS.has(status)
-}
-
-export function isRetryableMethod(method: string): boolean {
-  return RETRYABLE_METHODS.has(method.toUpperCase())
-}
-
-/** Full jitter : random(0, min(BASE·2^attempt, CAP)). `attempt` commence à 0. */
-export function computeBackoff(attempt: number, rand: () => number = Math.random): number {
-  const bound = Math.min(BASE_MS * 2 ** attempt, CAP_MS)
-  return Math.floor(rand() * bound)
-}
-
-/** Parse un header `Retry-After` (secondes OU HTTP-date) → délai en ms, ou null. */
-export function parseRetryAfter(header: string | null, now: number = Date.now()): number | null {
-  if (header === null) return null
-  const trimmed = header.trim()
-  if (/^\d+$/.test(trimmed)) return parseInt(trimmed, 10) * 1000
-  const dateMs = Date.parse(trimmed)
-  if (Number.isNaN(dateMs)) return null
-  return Math.max(0, dateMs - now)
-}
-
-/** `sleep(ms)` qui résout tôt (sans rejeter) si `signal` s'annule. */
-export function abortableSleep(ms: number, signal?: AbortSignal): Promise<void> {
-  return new Promise((resolve) => {
-    if (signal?.aborted) {
-      resolve()
-      return
-    }
-    const onAbort = () => {
-      clearTimeout(timer)
-      resolve()
-    }
-    const timer = setTimeout(() => {
-      signal?.removeEventListener('abort', onAbort)
-      resolve()
-    }, ms)
-    signal?.addEventListener('abort', onAbort, { once: true })
-  })
-}
-
-/** True si l'erreur `fetch` est une annulation utilisateur (jamais rejouée). */
-export function isAbortError(err: unknown): boolean {
-  return (
-    typeof err === 'object' &&
-    err !== null &&
-    (err as { name?: unknown }).name === 'AbortError'
-  )
-}

package/packages/core/src/serialize.ts

@@ -1,6 +0,0 @@
-/** JSON.stringify avec support des bigint (sérialisés en string). */
-export function serializeBody(body: unknown): string {
-  return JSON.stringify(body, (_key, value) =>
-    typeof value === 'bigint' ? value.toString() : value,
-  )
-}

package/packages/core/src/stores/BaseAuthStore.ts

@@ -1,164 +0,0 @@
-import type { User, AuraObservabilityEvent } from '../types'
-import { emitAuraEvent } from '../types'
-
-type AuthChangeCallback = (token: string | null, user: User | null) => void
-
-/**
- * Decode the payload of a JWT without verifying the signature.
- * Works in both browser and Node (uses base64url decoding).
- */
-function decodeJwtPayload(token: string): Record<string, unknown> | null {
-  try {
-    const parts = token.split('.')
-    if (parts.length !== 3) return null
-    // base64url → base64
-    let payload = parts[1]!.replace(/-/g, '+').replace(/_/g, '/')
-    // pad to multiple of 4
-    while (payload.length % 4 !== 0) payload += '='
-    // atob is available in all target environments (browsers + Node >= 16)
-    const json = atob(payload)
-    return JSON.parse(json)
-  } catch {
-    return null
-  }
-}
-
-/**
- * Check whether a JWT has expired (or will expire within `marginSec` seconds).
- */
-export function isTokenExpired(token: string, marginSec = 0): boolean {
-  const payload = decodeJwtPayload(token)
-  if (!payload || typeof payload.exp !== 'number') return true
-  const nowSec = Math.floor(Date.now() / 1000)
-  return payload.exp - marginSec <= nowSec
-}
-
-/**
- * In-memory auth store with an event-emitter pattern.
- * Can be extended (see LocalAuthStore) for persistence.
- */
-export class BaseAuthStore {
-  /**
-   * True si le store survit à un redirect pleine page (persistance disque, ex.
-   * localStorage). Le store de base est en mémoire → non persistant. Exploité par
-   * le flux PKCE : le `code_verifier` doit survivre au redirect OAuth.
-   */
-  readonly persistent: boolean = false
-  private _token: string | null = null
-  private _refreshToken: string | null = null
-  private _user: User | null = null
-  private _listeners: Set<AuthChangeCallback> = new Set()
-  private _removalEpoch = 0
-  /** Stockage générique clé/valeur (ex: PKCE `code_verifier`). En mémoire par défaut. */
-  private _kv: Map<string, string> = new Map()
-  /** Hook d'observabilité (LOT 3) — câblé par `AuraClient` via `setObservabilityHook`. */
-  private _onEvent?: (event: AuraObservabilityEvent) => void
-  private _debug = false
-
-  // -- Getters ----------------------------------------------------------------
-
-  /** Compteur incrémenté à chaque `clear()` — sert au commit-guard anti-race du refresh. */
-  get removalEpoch(): number {
-    return this._removalEpoch
-  }
-
-  get token(): string | null {
-    return this._token
-  }
-
-  get refreshToken(): string | null {
-    return this._refreshToken
-  }
-
-  get user(): User | null {
-    return this._user
-  }
-
-  /** True if a non-expired access token is present. */
-  get isValid(): boolean {
-    return this._token !== null && !isTokenExpired(this._token)
-  }
-
-  // -- Mutators ---------------------------------------------------------------
-
-  save(token: string, refreshToken: string, user: User): void {
-    this._token = token
-    this._refreshToken = refreshToken
-    this._user = user
-    this._triggerChange()
-  }
-
-  clear(): void {
-    this._removalEpoch++
-    this._token = null
-    this._refreshToken = null
-    this._user = null
-    // Purge le stockage clé/valeur (dont le `code_verifier` PKCE) : un `signOut`/
-    // `clear()` ne doit laisser aucun résidu d'auth réutilisable en mémoire.
-    this._kv.clear()
-    this._triggerChange()
-  }
-
-  // -- Generic key/value storage ------------------------------------------------
-  // Utilisé par le flux PKCE (`code_verifier`) et tout autre besoin de stockage
-  // arbitraire lié à l'auth. Impl de base : en mémoire (ne survit pas à un
-  // redirect pleine page — voir `LocalAuthStore` pour la persistance).
-
-  setItem(key: string, value: string): void {
-    this._kv.set(key, value)
-  }
-
-  getItem(key: string): string | null {
-    return this._kv.get(key) ?? null
-  }
-
-  removeItem(key: string): void {
-    this._kv.delete(key)
-  }
-
-  // -- Observability (LOT 3) ----------------------------------------------------
-
-  /**
-   * Câble le hook d'observabilité (appelé par `AuraClient` à la construction).
-   * Permet à `LocalAuthStore` d'émettre `storage-blocked` quand `localStorage` est
-   * indisponible (navigation privée Safari, quota dépassé, storage désactivé…).
-   * Sans effet sur `BaseAuthStore` elle-même (en mémoire, jamais "bloquée").
-   */
-  setObservabilityHook(
-    onEvent: ((event: AuraObservabilityEvent) => void) | undefined,
-    debug: boolean | undefined,
-  ): void {
-    this._onEvent = onEvent
-    this._debug = !!debug
-  }
-
-  /** Émet `{kind:'storage-blocked', op}` — ne throw jamais (voir `emitAuraEvent`). */
-  protected _emitStorageBlocked(op: string): void {
-    emitAuraEvent(this._onEvent, this._debug, { kind: 'storage-blocked', op })
-  }
-
-  // -- Event emitter ----------------------------------------------------------
-
-  /**
-   * Register a callback that fires whenever the auth state changes.
-   * Returns an unsubscribe function.
-   */
-  onChange(callback: AuthChangeCallback): () => void {
-    this._listeners.add(callback)
-    return () => {
-      this._listeners.delete(callback)
-    }
-  }
-
-  // -- Internal ---------------------------------------------------------------
-
-  protected _triggerChange(): void {
-    for (const cb of this._listeners) {
-      try {
-        cb(this._token, this._user)
-      } catch {
-        // subscriber errors must not break the store
-      }
-    }
-  }
-}