@hgdc/auth 0.7.0 → 0.8.0

package/README.md

@@ -7,6 +7,7 @@ Connexion d'un produit de la famille à Account (OIDC) : bouton « Se connecter
 | `@hgdc/auth`        | `HGDC_ISSUER`, `HGDC_PROVIDER_ID`, `HGDC_SCOPES`, entrée commune (`HGDC_ENTRY_PATH`, `safeNextPath`, `hgdcEntryUrl`), rôles (`highestRole`, `hasRole`), `parseHgdcProfile`, `verifiedOrganizationsFromIdToken`, `verifyHgdcIdToken`, `planOrganizationSync`, fraîcheur (`membershipIsFresh`, `SESSION_TTL_SECONDS`, `MEMBERSHIP_TTL_MS`, `KEY_MEMBERSHIP_TTL_MS`) |
 | `@hgdc/auth/server` | `hgdcProvider` (plugin `genericOAuth`), `createAuthProxy`, `restoreFetchMode`, `createHgdcEntry`                                                                                                                                                                                                                                                                  |
 | `@hgdc/auth/convex` | `requireIdentity`, `requireOrgMember`, `isAuthError`, `authErrorReason`, `AUTH_ERROR_MESSAGES`                                                                                                                                                                                                                                                                    |
+| `@hgdc/auth/events` | Événements poussés par Account : `ACCOUNT_EVENTS_PATH`, `signAccountEvent`, `verifyAccountEvent`, `handleAccountEventRequest`, `accountEventSchema`, `accountEventIsStale`, `ACCOUNT_EVENT_RETENTION_MS`, et pour Convex `vAccountEvent`, `accountEventsTable`                                                                                                    |
 | `@hgdc/auth/react`  | `HgdcSignInButton`, `startHgdcSignIn`, `HgdcMark` (le H tricolore de la famille, `HGDC_MARK_SVG`)                                                                                                                                                                                                                                                                 |
 
 Pairs : better-auth 1.6, convex 1.46+, React 19 (chacun facultatif selon l'import).
@@ -111,13 +112,18 @@ Le claim `organizations` n'est lu qu'à la création d'une session (étape 1 ci-
 - Barre et menu des produits (`@hgdc/ui/products`) : `https://<mot>.hgdc.ch/auth/hgdc?refresh=1&next=/`. Chaque passage d'un produit à l'autre resynchronise.
 - Page d'une organisation inconnue du produit (ou dont la personne n'est pas membre localement) : une seule redirection vers `hgdcRefreshPath("/o/acme")` avant d'afficher « introuvable ». Au retour, `next` porte `?synced=1` : `hasSyncedMarker(location.search)` vrai, la page affiche « introuvable » au lieu de relancer. L'entrée elle-même ne relance jamais un `next` déjà marqué : pas de boucle.
 
-```ts
-import { hasSyncedMarker, hgdcRefreshPath } from "@hgdc/auth"
+```tsx
+// Côté client, une fois les organisations chargées
+import { useOrganizationRefresh } from "@hgdc/auth/react"
 
-if (org === null && !hasSyncedMarker(window.location.search)) {
-  window.location.replace(hgdcRefreshPath(`/o/${slug}`))
-  return null
-}
+const refreshing = useOrganizationRefresh(viewer !== undefined && !space)
+if (refreshing) return <FamilyLoader page />
+if (!space) return <NotFound />
+
+// Dans un loader ou un beforeLoad (rendu serveur compris)
+import { hasSyncedMarker, hgdcRefreshPath } from "@hgdc/auth"
+if (!organization && !hasSyncedMarker(location.searchStr))
+  throw redirect({ href: hgdcRefreshPath(location.href), reloadDocument: true })
 ```
 
 - L'ancienne session n'est pas révoquée : si Account ne répond pas, la personne garde son accès, et la session expire seule (`SESSION_TTL_SECONDS`).
@@ -188,4 +194,48 @@ load: async (ctx, { organizationId, userId }) => {
 
 `verifyHgdcIdToken` rend aussi les claims du profil (nom, adresse, photo) pour les recopier. La signature n'est pas revérifiée : le jeton arrive du point de jeton d'Account, reçu en TLS par le serveur (OpenID Connect Core 3.1.3.7, point 6) ; le contrôle de fraîcheur empêche qu'un ancien jeton resté dans la table `account` rejoue des organisations. Une clé d'API vit hors session : `membershipIsFresh(member, now, KEY_MEMBERSHIP_TTL_MS)` lui laisse 30 jours. Les copies périmées se purgent par un cron.
 
+## Appliquer les événements d'Account
+
+Account pousse les retraits, changements de rôle et suppressions d'organisation à chaque produit, sans attendre la session suivante (ADR 0014). Le produit expose `POST /hgdc/v1/account-events` sur son déploiement Convex :
+
+```ts
+// convex/http.ts
+import { ACCOUNT_EVENTS_PATH, handleAccountEventRequest } from "@hgdc/auth/events"
+
+http.route({
+  path: ACCOUNT_EVENTS_PATH,
+  method: "POST",
+  handler: httpAction(async (ctx, request) =>
+    handleAccountEventRequest(request, {
+      secret: process.env.ACCOUNT_EVENTS_SECRET,
+      apply: (event) => ctx.runMutation(internal.organizations.applyAccountEvent, { event }),
+    }),
+  ),
+})
+
+// convex/schema.ts : accountEvents: accountEventsTable (de @hgdc/auth/events)
+
+// convex/organizations.ts
+export const applyAccountEvent = internalMutation({
+  args: { event: vAccountEvent },
+  handler: async (ctx, { event }) => {
+    const seen = await ctx.db
+      .query("accountEvents")
+      .withIndex("by_event_id", (q) => q.eq("eventId", event.id))
+      .first()
+    if (seen) return "duplicate"
+    await ctx.db.insert("accountEvents", { eventId: event.id, type: event.type, receivedAt: Date.now() })
+    // personne locale : compte better-auth `providerId: "hgdc"`, `accountId: event.userId`
+    // member.removed : retirer l'appartenance, sauf si accountEventIsStale(event, membre.syncedAt)
+    // member.role_changed : rôle et syncedAt = max(syncedAt, event.occurredAt) ; ne crée jamais d'appartenance
+    // organization.deleted : retirer toutes les appartenances, garder les données de l'espace
+    return "applied"
+  },
+})
+```
+
+Le secret (32 caractères au moins) est propre au produit : `ACCOUNT_EVENTS_SECRET` chez lui, `ACCOUNT_EVENTS_SECRET_<PRODUIT>` chez Account avec l'adresse de l'endpoint. Sans secret, l'endpoint répond 503 et Account réessaie (1, 5, 15, 60 minutes). Une signature invalide, un horodatage à plus de 5 minutes ou un corps altéré rendent 401 ; un identifiant déjà traité, `duplicate`. Les identifiants se purgent après `ACCOUNT_EVENT_RETENTION_MS` (cron, index `by_received`).
+
+Les gardes doivent lire l'appartenance à chaque requête (chargeur de `requireOrgMember`) : c'est ce qui rend le retrait immédiat.
+
 Tous droits réservés, Hugo Gebel Développement Conseil.

package/dist/events.d.ts

@@ -0,0 +1,130 @@
+import { type TableDefinition } from "convex/server";
+import { type Validator, type VFloat64, type VObject, type VString } from "convex/values";
+import { z } from "zod";
+import { type OrgRole } from "./index.ts";
+/** Chemin de l'endpoint de chaque produit, sur son déploiement Convex (`https://<…>.convex.site`). */
+export declare const ACCOUNT_EVENTS_PATH = "/hgdc/v1/account-events";
+/** En-têtes de la requête signée. */
+export declare const ACCOUNT_EVENT_HEADERS: {
+    readonly id: "x-hgdc-event-id";
+    readonly timestamp: "x-hgdc-timestamp";
+    readonly signature: "x-hgdc-signature";
+};
+/** Écart toléré entre l'horodatage signé et l'horloge du produit, en secondes. */
+export declare const ACCOUNT_EVENT_TOLERANCE_SECONDS = 300;
+/** Taille maximale du corps, en octets. Un événement en pèse moins de 400. */
+export declare const ACCOUNT_EVENT_MAX_BYTES: number;
+/** Longueur minimale du secret partagé (32 octets aléatoires en base64url : 43 caractères). */
+export declare const ACCOUNT_EVENT_SECRET_MIN_LENGTH = 32;
+/**
+ * Conservation des identifiants d'événements déjà traités chez le produit : 1 jour. Les nouveaux
+ * essais d'Account s'étalent sur 81 minutes, et une requête de plus de 5 minutes est refusée.
+ */
+export declare const ACCOUNT_EVENT_RETENTION_MS: number;
+type EventBase = {
+    /** Identifiant unique, le même à chaque nouvel essai : clé d'idempotence. */
+    id: string;
+    /** Instant du changement dans Account, en millisecondes. */
+    occurredAt: number;
+    /** Organisation d'Account (`id` du claim `organizations`). */
+    organizationId: string;
+};
+/** Événement d'organisation poussé par Account. Les personnes sont désignées par leur `sub` Account. */
+export type AccountEvent = (EventBase & {
+    type: "member.removed";
+    /** Personne retirée : son `sub` Account, l'`accountId` de son compte `hgdc` chez le produit. */
+    userId: string;
+    /** Retrait par un admin, départ volontaire, ou compte supprimé par HGDC. */
+    reason: "removed" | "left" | "user_deleted";
+}) | (EventBase & {
+    type: "member.role_changed";
+    userId: string;
+    /** Nouveau rôle, déjà ramené au plus fort (`highestRole`). */
+    role: OrgRole;
+}) | (EventBase & {
+    type: "organization.deleted";
+});
+export declare const accountEventSchema: z.ZodType<AccountEvent>;
+export type AccountEventType = AccountEvent["type"];
+/** Ce que le produit a fait de l'événement : rendu dans la réponse, pour les journaux d'Account. */
+export type AccountEventOutcome = "applied" | "ignored" | "duplicate";
+/** Identifiant d'événement neuf (UUID sans tirets), à garder pour tous les essais. */
+export declare function newAccountEventId(): string;
+/**
+ * Côté Account : corps et en-têtes d'un envoi. À rappeler à chaque essai (horodatage neuf),
+ * avec le même événement (même `id`).
+ */
+export declare function signAccountEvent(event: AccountEvent, options: {
+    secret: string;
+    now: number;
+}): Promise<{
+    body: string;
+    headers: Record<string, string>;
+}>;
+/** Pourquoi une requête est refusée. La réponse ne porte que le code, jamais le détail. */
+export type AccountEventRejection = "too_large" | "unauthorized" | "invalid_body";
+export type AccountEventVerification = {
+    ok: true;
+    event: AccountEvent;
+} | {
+    ok: false;
+    status: 400 | 401 | 413;
+    error: AccountEventRejection;
+};
+/**
+ * Côté produit : vérifie taille, horodatage (±5 minutes), signature en temps constant, puis le
+ * corps (`accountEventSchema`) et l'accord entre l'identifiant signé et celui du corps. Ne lit le
+ * corps qu'une fois. Ne dit rien du rejeu : à écarter par la table des événements traités.
+ */
+export declare function verifyAccountEvent(request: Request, options: {
+    secret: string;
+    now: number;
+}): Promise<AccountEventVerification>;
+/**
+ * Endpoint complet d'un produit, à envelopper dans une `httpAction` Convex :
+ *
+ * ```ts
+ * export const accountEvents = httpAction(async (ctx, request) =>
+ *   handleAccountEventRequest(request, {
+ *     secret: process.env.ACCOUNT_EVENTS_SECRET,
+ *     apply: (event) => ctx.runMutation(internal.organizations.applyAccountEvent, { event }),
+ *   }),
+ * )
+ * http.route({ path: ACCOUNT_EVENTS_PATH, method: "POST", handler: accountEvents })
+ * ```
+ *
+ * `apply` est une mutation interne qui, dans la même transaction, écarte un `id` déjà traité,
+ * l'enregistre et applique l'événement. Sans secret posé : 503, Account réessaie plus tard.
+ * Une erreur de `apply` remonte (500) : Account réessaie aussi.
+ */
+export declare function handleAccountEventRequest(request: Request, options: {
+    secret: string | undefined;
+    apply: (event: AccountEvent) => Promise<AccountEventOutcome>;
+    now?: number;
+}): Promise<Response>;
+/**
+ * Vrai si l'appartenance a été confirmée par Account après l'événement (`syncedAt` plus récent) :
+ * un essai en retard ne doit pas défaire une connexion plus récente (personne retirée puis
+ * réinvitée, rôle changé deux fois). Une copie sans `syncedAt` n'est jamais plus récente.
+ */
+export declare function accountEventIsStale(event: Pick<AccountEvent, "occurredAt">, syncedAt: number | null | undefined): boolean;
+/** Validateur Convex d'un `AccountEvent` : argument de la mutation interne qui l'applique. */
+export declare const vAccountEvent: Validator<AccountEvent, "required", string>;
+type AccountEventRow = {
+    eventId: string;
+    type: string;
+    receivedAt: number;
+};
+/**
+ * Table des événements déjà traités, pour l'idempotence (`accountEvents: accountEventsTable` dans
+ * le schéma du produit). Purge après `ACCOUNT_EVENT_RETENTION_MS` par l'index `by_received`.
+ */
+export declare const accountEventsTable: TableDefinition<VObject<AccountEventRow, {
+    eventId: VString;
+    type: VString;
+    receivedAt: VFloat64;
+}>, {
+    by_event_id: ["eventId", "_creationTime"];
+    by_received: ["receivedAt", "_creationTime"];
+}>;
+export {};

package/dist/events.js

@@ -0,0 +1,210 @@
+import { defineTable } from "convex/server";
+import { v } from "convex/values";
+import { z } from "zod";
+import { ORG_ROLES } from "./index.js";
+/*
+ * Événements d'organisation poussés par Account vers chaque produit (ADR 0014 du kit) : un retrait,
+ * un changement de rôle ou une organisation supprimée s'appliquent tout de suite, sans attendre la
+ * relecture des organisations à la connexion suivante.
+ *
+ * Signature HMAC-SHA256 par produit, Web Crypto seulement (Convex, Node, Bun, navigateurs) :
+ * `v1=` hex de HMAC(secret, "<id>.<horodatage>.<corps brut>"). L'identifiant de l'événement est
+ * dans le MAC : rejouer une requête captée dans la fenêtre de 5 minutes ne passe pas la table des
+ * événements déjà traités du produit.
+ */
+/** Chemin de l'endpoint de chaque produit, sur son déploiement Convex (`https://<…>.convex.site`). */
+export const ACCOUNT_EVENTS_PATH = "/hgdc/v1/account-events";
+/** En-têtes de la requête signée. */
+export const ACCOUNT_EVENT_HEADERS = {
+    id: "x-hgdc-event-id",
+    timestamp: "x-hgdc-timestamp",
+    signature: "x-hgdc-signature",
+};
+/** Écart toléré entre l'horodatage signé et l'horloge du produit, en secondes. */
+export const ACCOUNT_EVENT_TOLERANCE_SECONDS = 300;
+/** Taille maximale du corps, en octets. Un événement en pèse moins de 400. */
+export const ACCOUNT_EVENT_MAX_BYTES = 8 * 1024;
+/** Longueur minimale du secret partagé (32 octets aléatoires en base64url : 43 caractères). */
+export const ACCOUNT_EVENT_SECRET_MIN_LENGTH = 32;
+/**
+ * Conservation des identifiants d'événements déjà traités chez le produit : 1 jour. Les nouveaux
+ * essais d'Account s'étalent sur 81 minutes, et une requête de plus de 5 minutes est refusée.
+ */
+export const ACCOUNT_EVENT_RETENTION_MS = 24 * 60 * 60 * 1000;
+const id = z.string().min(1).max(64);
+const base = {
+    id: z.string().regex(/^[A-Za-z0-9_-]{16,64}$/),
+    occurredAt: z.number().int().positive(),
+    organizationId: id,
+};
+export const accountEventSchema = z.discriminatedUnion("type", [
+    z.strictObject({
+        ...base,
+        type: z.literal("member.removed"),
+        userId: id,
+        reason: z.enum(["removed", "left", "user_deleted"]),
+    }),
+    z.strictObject({
+        ...base,
+        type: z.literal("member.role_changed"),
+        userId: id,
+        role: z.enum(ORG_ROLES),
+    }),
+    z.strictObject({
+        ...base,
+        type: z.literal("organization.deleted"),
+    }),
+]);
+const encoder = new TextEncoder();
+async function hmacHex(secret, payload) {
+    const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, [
+        "sign",
+    ]);
+    const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
+    return [...new Uint8Array(signature)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function constantTimeEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < a.length; i++)
+        diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    return diff === 0;
+}
+function assertSecret(secret) {
+    if (typeof secret !== "string" || secret.length < ACCOUNT_EVENT_SECRET_MIN_LENGTH)
+        throw new Error(`Secret des événements Account absent ou trop court (${ACCOUNT_EVENT_SECRET_MIN_LENGTH} caractères au moins).`);
+}
+/** Identifiant d'événement neuf (UUID sans tirets), à garder pour tous les essais. */
+export function newAccountEventId() {
+    return crypto.randomUUID().replaceAll("-", "");
+}
+/**
+ * Côté Account : corps et en-têtes d'un envoi. À rappeler à chaque essai (horodatage neuf),
+ * avec le même événement (même `id`).
+ */
+export async function signAccountEvent(event, options) {
+    assertSecret(options.secret);
+    const parsed = accountEventSchema.parse(event);
+    const body = JSON.stringify(parsed);
+    const timestamp = String(Math.floor(options.now / 1000));
+    const signature = `v1=${await hmacHex(options.secret, `${parsed.id}.${timestamp}.${body}`)}`;
+    return {
+        body,
+        headers: {
+            "content-type": "application/json",
+            [ACCOUNT_EVENT_HEADERS.id]: parsed.id,
+            [ACCOUNT_EVENT_HEADERS.timestamp]: timestamp,
+            [ACCOUNT_EVENT_HEADERS.signature]: signature,
+        },
+    };
+}
+const reject = (status, error) => ({
+    ok: false,
+    status,
+    error,
+});
+/**
+ * Côté produit : vérifie taille, horodatage (±5 minutes), signature en temps constant, puis le
+ * corps (`accountEventSchema`) et l'accord entre l'identifiant signé et celui du corps. Ne lit le
+ * corps qu'une fois. Ne dit rien du rejeu : à écarter par la table des événements traités.
+ */
+export async function verifyAccountEvent(request, options) {
+    assertSecret(options.secret);
+    const declared = Number(request.headers.get("content-length") ?? "0");
+    if (declared > ACCOUNT_EVENT_MAX_BYTES)
+        return reject(413, "too_large");
+    const raw = await request.text();
+    if (encoder.encode(raw).byteLength > ACCOUNT_EVENT_MAX_BYTES)
+        return reject(413, "too_large");
+    const eventId = request.headers.get(ACCOUNT_EVENT_HEADERS.id) ?? "";
+    const timestamp = request.headers.get(ACCOUNT_EVENT_HEADERS.timestamp) ?? "";
+    const signature = request.headers.get(ACCOUNT_EVENT_HEADERS.signature) ?? "";
+    if (!/^[A-Za-z0-9_-]{16,64}$/.test(eventId) || !/^\d{1,12}$/.test(timestamp))
+        return reject(401, "unauthorized");
+    if (Math.abs(options.now / 1000 - Number(timestamp)) > ACCOUNT_EVENT_TOLERANCE_SECONDS)
+        return reject(401, "unauthorized");
+    const expected = `v1=${await hmacHex(options.secret, `${eventId}.${timestamp}.${raw}`)}`;
+    if (!constantTimeEqual(signature, expected))
+        return reject(401, "unauthorized");
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch {
+        return reject(400, "invalid_body");
+    }
+    const parsed = accountEventSchema.safeParse(json);
+    if (!parsed.success || parsed.data.id !== eventId)
+        return reject(400, "invalid_body");
+    return { ok: true, event: parsed.data };
+}
+const json = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+/**
+ * Endpoint complet d'un produit, à envelopper dans une `httpAction` Convex :
+ *
+ * ```ts
+ * export const accountEvents = httpAction(async (ctx, request) =>
+ *   handleAccountEventRequest(request, {
+ *     secret: process.env.ACCOUNT_EVENTS_SECRET,
+ *     apply: (event) => ctx.runMutation(internal.organizations.applyAccountEvent, { event }),
+ *   }),
+ * )
+ * http.route({ path: ACCOUNT_EVENTS_PATH, method: "POST", handler: accountEvents })
+ * ```
+ *
+ * `apply` est une mutation interne qui, dans la même transaction, écarte un `id` déjà traité,
+ * l'enregistre et applique l'événement. Sans secret posé : 503, Account réessaie plus tard.
+ * Une erreur de `apply` remonte (500) : Account réessaie aussi.
+ */
+export async function handleAccountEventRequest(request, options) {
+    const { secret } = options;
+    if (typeof secret !== "string" || secret.length < ACCOUNT_EVENT_SECRET_MIN_LENGTH)
+        return json(503, { error: "not_configured" });
+    const verified = await verifyAccountEvent(request, { secret, now: options.now ?? Date.now() });
+    if (!verified.ok)
+        return json(verified.status, { error: verified.error });
+    const outcome = await options.apply(verified.event);
+    return json(200, { status: outcome });
+}
+/**
+ * Vrai si l'appartenance a été confirmée par Account après l'événement (`syncedAt` plus récent) :
+ * un essai en retard ne doit pas défaire une connexion plus récente (personne retirée puis
+ * réinvitée, rôle changé deux fois). Une copie sans `syncedAt` n'est jamais plus récente.
+ */
+export function accountEventIsStale(event, syncedAt) {
+    return typeof syncedAt === "number" && syncedAt > event.occurredAt;
+}
+const vRole = v.union(...ORG_ROLES.map((role) => v.literal(role)));
+/** Validateur Convex d'un `AccountEvent` : argument de la mutation interne qui l'applique. */
+export const vAccountEvent = v.union(v.object({
+    id: v.string(),
+    type: v.literal("member.removed"),
+    occurredAt: v.number(),
+    organizationId: v.string(),
+    userId: v.string(),
+    reason: v.union(v.literal("removed"), v.literal("left"), v.literal("user_deleted")),
+}), v.object({
+    id: v.string(),
+    type: v.literal("member.role_changed"),
+    occurredAt: v.number(),
+    organizationId: v.string(),
+    userId: v.string(),
+    role: vRole,
+}), v.object({
+    id: v.string(),
+    type: v.literal("organization.deleted"),
+    occurredAt: v.number(),
+    organizationId: v.string(),
+}));
+/**
+ * Table des événements déjà traités, pour l'idempotence (`accountEvents: accountEventsTable` dans
+ * le schéma du produit). Purge après `ACCOUNT_EVENT_RETENTION_MS` par l'index `by_received`.
+ */
+export const accountEventsTable = defineTable({
+    eventId: v.string(),
+    type: v.string(),
+    receivedAt: v.number(),
+})
+    .index("by_event_id", ["eventId"])
+    .index("by_received", ["receivedAt"]);

package/dist/react.d.ts

@@ -52,3 +52,18 @@ export declare function HgdcMark({ className }: {
  * `className`, l'état d'attente est exposé par `aria-busy` et `data-pending`.
  */
 export declare function HgdcSignInButton({ authClient, callbackURL, errorCallbackURL, onError, label, disabled, ...rest }: HgdcSignInButtonProps): ReactElement;
+/**
+ * Page d'une organisation inconnue du produit, ou dont la personne n'est pas membre dans sa copie :
+ * une invitation acceptée dans Account n'y arrive qu'à la session suivante (ADR 0013). Quand
+ * `unknown` est vrai, part une fois vers `/auth/hgdc?refresh=1&next=<page>` et rend `true` (afficher
+ * un chargement). Au retour (`?synced=1`), rend `false` : afficher « introuvable ».
+ *
+ * Côté client seulement : à appeler une fois la liste des organisations chargée.
+ *
+ * ```tsx
+ * const refreshing = useOrganizationRefresh(viewer !== undefined && !space)
+ * if (refreshing) return <FamilyLoader page />
+ * if (!space) return <NotFound />
+ * ```
+ */
+export declare function useOrganizationRefresh(unknown: boolean): boolean;

package/dist/react.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from "react";
-import { HGDC_PROVIDER_ID } from "./index.js";
+import { useEffect, useState } from "react";
+import { HGDC_PROVIDER_ID, hasSyncedMarker, hgdcRefreshPath } from "./index.js";
 /**
  * Part vers HGDC Account. Renvoie `{ ok: true }` quand la redirection est lancée,
  * sinon l'erreur du client ou du réseau, sans lever.
@@ -50,3 +50,28 @@ export function HgdcSignInButton({ authClient, callbackURL = "/", errorCallbackU
     }
     return (_jsxs("button", { ...rest, type: "button", disabled: disabled === true || pending, "aria-busy": pending, "data-pending": pending ? "" : undefined, onClick: () => void signIn(), children: [_jsx(HgdcMark, {}), _jsx("span", { children: pending ? "Redirection vers Account…" : label })] }));
 }
+/**
+ * Page d'une organisation inconnue du produit, ou dont la personne n'est pas membre dans sa copie :
+ * une invitation acceptée dans Account n'y arrive qu'à la session suivante (ADR 0013). Quand
+ * `unknown` est vrai, part une fois vers `/auth/hgdc?refresh=1&next=<page>` et rend `true` (afficher
+ * un chargement). Au retour (`?synced=1`), rend `false` : afficher « introuvable ».
+ *
+ * Côté client seulement : à appeler une fois la liste des organisations chargée.
+ *
+ * ```tsx
+ * const refreshing = useOrganizationRefresh(viewer !== undefined && !space)
+ * if (refreshing) return <FamilyLoader page />
+ * if (!space) return <NotFound />
+ * ```
+ */
+export function useOrganizationRefresh(unknown) {
+    const synced = typeof window === "undefined" || hasSyncedMarker(window.location.search);
+    const refreshing = unknown && !synced;
+    useEffect(() => {
+        if (!refreshing)
+            return;
+        const { pathname, search, hash } = window.location;
+        window.location.replace(hgdcRefreshPath(`${pathname}${search}${hash}`));
+    }, [refreshing]);
+    return refreshing;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hgdc/auth",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Connexion HGDC : bouton « Se connecter avec HGDC », config better-auth et gardes Convex.",
   "license": "UNLICENSED",
   "homepage": "https://github.com/hugogebel-boop/hgdc-kit/tree/main/packages/auth#readme",
@@ -27,6 +27,10 @@
       "types": "./dist/convex.d.ts",
       "default": "./dist/convex.js"
     },
+    "./events": {
+      "types": "./dist/events.d.ts",
+      "default": "./dist/events.js"
+    },
     "./server": {
       "types": "./dist/server.d.ts",
       "default": "./dist/server.js"