@idp.global/sdk 18.1.0 → 18.2.0

package/dist_ts_relyingparty/classes.rpmodels.d.ts

@@ -57,7 +57,13 @@ export declare const RELYING_PARTY_DEFAULT_COLLECTION_NAMES: {
     readonly loginAttempts: "IdpRelyingPartyLoginAttempt";
 };
 export interface IRelyingPartyModelsOptions {
-    db: plugins.nosqldb.SmartdataDb;
+    /**
+     * The database, or a function that answers it once it exists. The function
+     * is called on every use of a model — never while the models or
+     * `RelyingPartySessions` are constructed — so an application creates both
+     * before its database connects and binds the database it connects later.
+     */
+    db: plugins.nosqldb.SmartdataDb | (() => plugins.nosqldb.SmartdataDb);
     /**
      * The persisted collection names. An application that already stores these
      * documents names its existing collections here.
@@ -74,6 +80,8 @@ export interface IRelyingPartyModels {
 /**
  * Binds the two relying-party models to one database. Each call declares its
  * own model classes, so several databases — and several applications in one
- * process — never share a binding.
+ * process — never share a binding. A deferred `db` is resolved on every use,
+ * the way `@Collection(() => db)` resolves it; a use before it answers a
+ * `SmartdataDb` throws `RelyingPartyDatabaseUnavailableError`.
  */
 export declare const createRelyingPartyModels: (optionsArg: IRelyingPartyModelsOptions) => IRelyingPartyModels;

package/dist_ts_relyingparty/classes.rpmodels.js

@@ -33,6 +33,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import * as plugins from './plugins.js';
+import { RelyingPartyDatabaseUnavailableError } from './classes.errors.js';
 /**
  * One browser session of a relying party. The persisted field names, their
  * types and the index declarations are the ones nevermind.finance has stored
@@ -232,18 +233,36 @@ export const RELYING_PARTY_DEFAULT_COLLECTION_NAMES = {
 /**
  * Binds the two relying-party models to one database. Each call declares its
  * own model classes, so several databases — and several applications in one
- * process — never share a binding.
+ * process — never share a binding. A deferred `db` is resolved on every use,
+ * the way `@Collection(() => db)` resolves it; a use before it answers a
+ * `SmartdataDb` throws `RelyingPartyDatabaseUnavailableError`.
  */
 export const createRelyingPartyModels = (optionsArg) => {
-    const db = optionsArg.db;
-    if (!(db instanceof plugins.nosqldb.SmartdataDb)) {
-        throw new Error('createRelyingPartyModels needs a SmartdataDb of @lossless.org/client/nosqldb');
+    const dbOption = optionsArg.db;
+    if (!(dbOption instanceof plugins.nosqldb.SmartdataDb) && typeof dbOption !== 'function') {
+        throw new Error('createRelyingPartyModels needs a SmartdataDb of @lossless.org/client/nosqldb or a function answering one');
     }
+    const resolveDb = () => {
+        if (dbOption instanceof plugins.nosqldb.SmartdataDb) {
+            return dbOption;
+        }
+        let resolved;
+        try {
+            resolved = dbOption();
+        }
+        catch (error) {
+            throw new RelyingPartyDatabaseUnavailableError(error);
+        }
+        if (!(resolved instanceof plugins.nosqldb.SmartdataDb)) {
+            throw new RelyingPartyDatabaseUnavailableError();
+        }
+        return resolved;
+    };
     const sessions = optionsArg.collectionNames?.sessions ?? RELYING_PARTY_DEFAULT_COLLECTION_NAMES.sessions;
     const loginAttempts = optionsArg.collectionNames?.loginAttempts
         ?? RELYING_PARTY_DEFAULT_COLLECTION_NAMES.loginAttempts;
     let BoundSessionDoc = (() => {
-        let _classDecorators = [plugins.nosqldb.Collection(() => db, { collectionName: sessions })];
+        let _classDecorators = [plugins.nosqldb.Collection(resolveDb, { collectionName: sessions })];
         let _classDescriptor;
         let _classExtraInitializers = [];
         let _classThis;
@@ -261,7 +280,7 @@ export const createRelyingPartyModels = (optionsArg) => {
         return BoundSessionDoc = _classThis;
     })();
     let BoundLoginAttemptDoc = (() => {
-        let _classDecorators = [plugins.nosqldb.Collection(() => db, { collectionName: loginAttempts })];
+        let _classDecorators = [plugins.nosqldb.Collection(resolveDb, { collectionName: loginAttempts })];
         let _classDescriptor;
         let _classExtraInitializers = [];
         let _classThis;
@@ -280,4 +299,4 @@ export const createRelyingPartyModels = (optionsArg) => {
     })();
     return { Session: BoundSessionDoc, LoginAttempt: BoundLoginAttemptDoc };
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_relyingparty/classes.socketbinding.d.ts

@@ -4,6 +4,10 @@ import type { IRelyingPartySession } from './interfaces.js';
 /** The part of a server `TypedSocket` the binding uses. */
 export type TRelyingPartySocketTransport = Pick<plugins.typedsocket.TypedSocket, 'setServerTag' | 'findAllTargetConnectionsByTag'>;
 export type TRelyingPartySocketConnection = plugins.typedsocket.ISmartServeConnectionWrapper;
+/** The SmartServe WebSocket peer underneath a connection, as a TypedSocket server hands it out. */
+export type TRelyingPartySocketPeer = TRelyingPartySocketConnection['peer'];
+/** A connection wrapper or its peer; `TypedSocket.setServerTag` takes either. */
+export type TRelyingPartySocketTarget = TRelyingPartySocketConnection | TRelyingPartySocketPeer;
 /** What a browser connection is pinned to for its whole life; no cookie and no CSRF token is kept. */
 export interface IRelyingPartyPinnedSession {
     sessionId: string;
@@ -23,8 +27,8 @@ export type TRelyingPartySocketRegistration = {
     registered: false;
     refusal: IRelyingPartySocketRefusal;
 };
-export interface IRelyingPartySocketBindingOptions {
-    sessions: RelyingPartySessions;
+export interface IRelyingPartySocketBindingOptions<TPrincipal extends object | undefined = undefined> {
+    sessions: RelyingPartySessions<TPrincipal>;
     /** the transport typedserver created; `undefined` before the server runs */
     transport: () => TRelyingPartySocketTransport | undefined;
     /** the server-owned tag prefix that finds the connections of a session */
@@ -39,12 +43,12 @@ export interface IRelyingPartySocketBindingOptions {
  * request. Connection limits, rate limits and sweeps belong to the
  * application's socket gate.
  */
-export declare class RelyingPartySocketBinding {
+export declare class RelyingPartySocketBinding<TPrincipal extends object | undefined = undefined> {
     #private;
     readonly tagPrefix: string;
-    constructor(optionsArg: IRelyingPartySocketBindingOptions);
-    /** The upgrade headers a connection arrived with. */
-    upgradeOf(connectionArg: TRelyingPartySocketConnection): {
+    constructor(optionsArg: IRelyingPartySocketBindingOptions<TPrincipal>);
+    /** The upgrade headers a connection (or its peer) arrived with. */
+    upgradeOf(targetArg: TRelyingPartySocketTarget): {
         origin: string | null;
         cookie: string | null;
     };
@@ -58,16 +62,21 @@ export declare class RelyingPartySocketBinding {
         cookie: string | null;
     }): Promise<TRelyingPartySocketRegistration>;
     tagOf(sessionIdArg: string): string;
-    /** Tags a connection with its session; throws when the transport is not running or the connection is gone. */
-    tagConnection(connectionArg: TRelyingPartySocketConnection, sessionIdArg: string): void;
+    /**
+     * Tags a connection — its wrapper or its peer — with its session; throws
+     * when the transport is not running or the connection is gone.
+     */
+    tagConnection(targetArg: TRelyingPartySocketTarget, sessionIdArg: string): void;
     /**
      * The pinned session as it stands right now: re-read, live, its principal
-     * active and unchanged, touched under the liveness it was read with. The
+     * active and unchanged (and resolved, with `principals.resolve`), touched
+     * under the liveness it was read with. The
      * browser keeps proving itself with its CSRF token, compared against the
      * hash the registration kept. Nothing of this is cached.
      */
     revalidate(pinnedArg: IRelyingPartyPinnedSession): Promise<{
         session: IRelyingPartySession;
+        principal: TPrincipal;
         verifyCsrf(candidateArg: unknown): boolean;
     } | null>;
     /** The live connections of one session, for closing them when it ends. */

package/dist_ts_relyingparty/classes.socketbinding.js

@@ -1,5 +1,6 @@
 import * as plugins from './plugins.js';
 import { sha256, timingSafeEqualString } from './helpers.crypto.js';
+const peerOf = (targetArg) => 'peer' in targetArg ? targetArg.peer : targetArg;
 /**
  * Binds typed socket connections to relying-party browser sessions. A
  * connection registers once with the CSRF token of the page; the proof is the
@@ -18,9 +19,9 @@ export class RelyingPartySocketBinding {
         this.#transport = optionsArg.transport;
         this.tagPrefix = optionsArg.tagPrefix ?? 'idp_rp_session:';
     }
-    /** The upgrade headers a connection arrived with. */
-    upgradeOf(connectionArg) {
-        const headers = connectionArg.peer.context.headers;
+    /** The upgrade headers a connection (or its peer) arrived with. */
+    upgradeOf(targetArg) {
+        const headers = peerOf(targetArg).context.headers;
         return { origin: headers.get('origin'), cookie: headers.get('cookie') };
     }
     /**
@@ -55,28 +56,33 @@ export class RelyingPartySocketBinding {
     tagOf(sessionIdArg) {
         return this.tagPrefix + sessionIdArg;
     }
-    /** Tags a connection with its session; throws when the transport is not running or the connection is gone. */
-    tagConnection(connectionArg, sessionIdArg) {
+    /**
+     * Tags a connection — its wrapper or its peer — with its session; throws
+     * when the transport is not running or the connection is gone.
+     */
+    tagConnection(targetArg, sessionIdArg) {
         const transport = this.#transport();
         if (!transport) {
             throw new Error('The socket transport is not running');
         }
-        transport.setServerTag(connectionArg, this.tagOf(sessionIdArg));
+        transport.setServerTag(targetArg, this.tagOf(sessionIdArg));
     }
     /**
      * The pinned session as it stands right now: re-read, live, its principal
-     * active and unchanged, touched under the liveness it was read with. The
+     * active and unchanged (and resolved, with `principals.resolve`), touched
+     * under the liveness it was read with. The
      * browser keeps proving itself with its CSRF token, compared against the
      * hash the registration kept. Nothing of this is cached.
      */
     async revalidate(pinnedArg) {
-        const session = await this.#sessions.revalidateSession(pinnedArg.sessionId);
-        if (!session || session.principalId !== pinnedArg.principalId) {
+        const live = await this.#sessions.revalidateLiveSession(pinnedArg.sessionId);
+        if (!live || live.session.principalId !== pinnedArg.principalId) {
             return null;
         }
         const expectedHash = pinnedArg.csrfTokenHash;
         return {
-            session,
+            session: live.session,
+            principal: live.principal,
             verifyCsrf: (candidateArg) => typeof candidateArg === 'string'
                 && expectedHash.length > 0
                 && timingSafeEqualString(expectedHash, sha256(candidateArg)),
@@ -91,4 +97,4 @@ export class RelyingPartySocketBinding {
         return transport.findAllTargetConnectionsByTag(this.tagOf(sessionIdArg));
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_relyingparty/interfaces.d.ts

@@ -11,13 +11,23 @@ export interface IRelyingPartySession {
     idpSubject?: string;
     loginAttemptId?: string;
 }
-/** A live session behind a cookie, with the CSRF token derived for it. */
-export interface IResolvedRelyingPartySession {
+/**
+ * A live session with the principal it acts as. `principal` is what
+ * `principals.resolve` answered for it in the same read; with `isActive`
+ * principals it is `undefined`.
+ */
+export interface IRelyingPartyLiveSession<TPrincipal extends object | undefined = undefined> {
     session: IRelyingPartySession;
+    principal: TPrincipal;
+}
+/** A live session behind a cookie, with its principal and the CSRF token derived for it. */
+export interface IResolvedRelyingPartySession<TPrincipal extends object | undefined = undefined> extends IRelyingPartyLiveSession<TPrincipal> {
     csrfToken: string;
 }
 /** A session just opened: the answer, the CSRF token and the `Set-Cookie` value that carries it. */
-export interface IRelyingPartySessionOpening extends IResolvedRelyingPartySession {
+export interface IRelyingPartySessionOpening {
+    session: IRelyingPartySession;
+    csrfToken: string;
     sessionCookie: string;
 }
 /** The redirect that starts a provider login, and the cookie that binds it to this browser. */
@@ -54,6 +64,25 @@ export interface IRelyingPartyPrincipals {
     /** Whether a principal may act right now; a session of an inactive principal resolves to nothing. */
     isActive(principalIdArg: string): Promise<boolean>;
 }
+/**
+ * Principals that answer the principal itself instead of a yes or no, so a
+ * request reads its user once: `resolve` answers the principal when it may act
+ * right now and `null` otherwise, and every live session carries the answer as
+ * `principal`. Give either `isActive` or `resolve`, never both.
+ */
+export interface IRelyingPartyPrincipalResolver<TPrincipal extends object | undefined> {
+    admit(completionArg: IOidcCompletion): Promise<{
+        principalId: string;
+    }>;
+    /** The principal object when it may act right now, `null` otherwise; any answer that is not an object (including `false`) resolves the session to nothing. */
+    resolve(principalIdArg: string): Promise<TPrincipal | null>;
+}
+/**
+ * What `RelyingPartySessions` accepts as its principals: a resolver whose
+ * principal type every live session carries, or — only while that type is
+ * left `undefined` — the `isActive` form.
+ */
+export type TRelyingPartyPrincipals<TPrincipal extends object | undefined> = IRelyingPartyPrincipalResolver<TPrincipal> | (undefined extends TPrincipal ? IRelyingPartyPrincipals : never);
 export type TRelyingPartySessionEndReason = 
 /** the application or the user ended it */
 'logout'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idp.global/sdk",
-  "version": "18.1.0",
+  "version": "18.2.0",
   "private": false,
   "description": "Reusable browser and server SDK for idp.global authentication.",
   "type": "module",

package/readme.md

@@ -561,19 +561,76 @@ A deployment without a provider (`provider` omitted) keeps the same session
 store for sessions it opens itself with `openSession({ principalId })`, for
 example after a local password check.
 
+**Building before the database connects.** `db` may be a function that answers
+the database once it exists. It is called on every use of a model, the way
+`@Collection(() => db)` resolves it, and never while the models,
+`RelyingPartySessions`, `RelyingPartyRoutes` or `RelyingPartySocketBinding` are
+constructed — none of them does I/O in its constructor. A use before the
+function answers a `SmartdataDb` (or while it throws) rejects with
+`RelyingPartyDatabaseUnavailableError`, whose `cause` is the function's error:
+
+```ts
+const models = createRelyingPartyModels({ db: () => appDatabase.db });
+const sessions = new RelyingPartySessions({ models, /* … */ });
+// later, at startup
+await appDatabase.init();
+await models.Session.ensureInitialized();
+await models.LoginAttempt.ensureInitialized();
+```
+
+**Reading the principal once.** `principals.isActive` answers a yes or no, so a
+request that needs the user reads it a second time. Principals may give
+`resolve` instead: it answers the principal when it may act right now and
+`null` otherwise, and every live session carries that answer as `principal` —
+on `resolveCookieSession`, `revalidateLiveSession`, `RelyingPartySocketBinding.revalidate`
+and the routes' `sessionAnswer`. The principal type is inferred from `resolve`;
+with `isActive` it is `undefined`. Give exactly one of the two; the constructor
+refuses both or neither.
+
+```ts
+const sessions = new RelyingPartySessions({
+  // …
+  principals: {
+    admit: async (completion) => ({ principalId: await users.upsertFromIdp(completion) }),
+    resolve: async (principalId) => {
+      const user = await users.get(principalId);
+      return user?.status === 'active' ? user : null;
+    },
+  },
+});
+const resolved = await sessions.resolveCookieSession(cookieHeader);
+resolved?.principal.displayName; // typed as the user
+```
+
+**Recording a logout.** `RelyingPartyRoutes` takes
+`onLogout({ session, endedLiveSession })`. It runs only for a `POST
+<prefix>logout` that passed the origin and CSRF checks, after the session was
+ended, and the answer waits for it, so an audit record is written before the
+browser learns the logout is done. `endedLiveSession` is `true` only when this
+call ended a live session: a logout that lost a race to another end gets
+`false`, and a repeated logout finds no session and does not call it. A hook
+that throws or rejects never keeps the session alive and never changes the
+answer — the session is already over — and is reported as a `hook_failed`
+route event (`hook: 'onLogout'`) through `onRouteEvent`. The hook runs without
+a deadline of its own; bound a slow audit store inside it.
+
+**Socket peers.** `RelyingPartySocketBinding.tagConnection` and `upgradeOf` take
+the connection wrapper or the bare SmartServe peer (`TRelyingPartySocketPeer`),
+the two forms `TypedSocket.setServerTag` accepts.
+
 ### Relying-Party API Surface
 
 | API | Description |
 | --- | --- |
 | `IdpOidcProvider` | Discovery, PKCE authorization URL, code exchange with UserInfo, refresh, revocation and organization introspection for idp.global. Implements `IOidcProvider`. |
-| `createRelyingPartyModels()` | Binds the session and login-attempt models to one `SmartdataDb`, optionally under existing collection names. |
-| `RelyingPartySessions` | Login start/complete/abandon/finalize, `openSession`, `resolveCookieSession`, `revalidateSession`, `isSessionLive`, `validateCsrf`, `logout`/`endSession`, `endSessionsOfPrincipal`, `liveProviderToken`. |
+| `createRelyingPartyModels()` | Binds the session and login-attempt models to one `SmartdataDb`, or to a function asked for it on every use, optionally under existing collection names. |
+| `RelyingPartySessions<TPrincipal>` | Login start/complete/abandon/finalize, `openSession`, `resolveCookieSession`, `revalidateSession`, `revalidateLiveSession`, `isSessionLive`, `validateCsrf`, `logout`/`endSession`, `endSessionsOfPrincipal`, `liveProviderToken`. Principals give `isActive` or `resolve` (`IRelyingPartyPrincipals`, `IRelyingPartyPrincipalResolver<TPrincipal>`); with `resolve`, live sessions carry `principal`. |
 | `AuthorityObserver` | Live organization authority with opt-in positive and negative reuse. |
-| `RelyingPartyRoutes` | `handle(ctx)` for `/auth/login`, `/auth/callback`, `/auth/finalize`, `/auth/session` and `/auth/logout`; `null` for anything else. Takes a typedserver route context. |
+| `RelyingPartyRoutes` | `handle(ctx)` for `/auth/login`, `/auth/callback`, `/auth/finalize`, `/auth/session` and `/auth/logout`; `null` for anything else. Takes a typedserver route context. `onLogout` is awaited after a CSRF-checked logout ended the session. |
 | `createActorScope()` | AsyncLocalStorage actor context with a TypedRouter request scope. |
-| `RelyingPartySocketBinding` | TypedSocket browser registration, per-request re-validation and session tags. |
+| `RelyingPartySocketBinding` | TypedSocket browser registration, per-request re-validation and session tags; takes a connection wrapper or its peer. |
 | `SecretBox`, `deriveCsrfToken()`, `decodeSecretKey()`, `parseCookies()`, `serializeCookie()`, `sanitizeReturnPath()` | The primitives underneath. |
-| `RelyingPartyError`, `RelyingPartyRefusal`, `LoginCallbackError`, `AuthorityTokenError`, `AuthorityRefusedError` | Errors with stable codes; none carries token material. |
+| `RelyingPartyError`, `RelyingPartyRefusal`, `LoginCallbackError`, `AuthorityTokenError`, `AuthorityRefusedError`, `RelyingPartyDatabaseUnavailableError` | Errors with stable codes; none carries token material. |
 
 ## Runtime Notes
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@idp.global/sdk',
-  version: '18.1.0',
+  version: '18.2.0',
   description: 'Reusable browser and server SDK for idp.global authentication.'
 }

package/ts_relyingparty/classes.errors.ts

@@ -67,3 +67,11 @@ export class AuthorityTokenError extends Error {
     this.status = code === 'authority_login_required' ? 403 : 503;
   }
 }
+
+/** A relying-party model was used before the database it is bound to exists. */
+export class RelyingPartyDatabaseUnavailableError extends Error {
+  constructor(causeArg?: unknown) {
+    super('The relying-party models were used before their database exists', { cause: causeArg });
+    this.name = 'RelyingPartyDatabaseUnavailableError';
+  }
+}

package/ts_relyingparty/classes.relyingpartyroutes.ts

@@ -1,7 +1,7 @@
 import * as plugins from './plugins.js';
 import { LoginCallbackError, RelyingPartyError, RelyingPartyRefusal } from './classes.errors.js';
 import type { RelyingPartySessions } from './classes.relyingpartysessions.js';
-import type { IResolvedRelyingPartySession } from './interfaces.js';
+import type { IRelyingPartySession, IResolvedRelyingPartySession } from './interfaces.js';
 
 /**
  * The part of an HTTP request context the routes read. `IRequestContext` of
@@ -16,8 +16,8 @@ export interface IRelyingPartyHttpContext {
   readonly request: Request;
 }
 
-export interface IRelyingPartyRoutesOptions {
-  sessions: RelyingPartySessions;
+export interface IRelyingPartyRoutesOptions<TPrincipal extends object | undefined = undefined> {
+  sessions: RelyingPartySessions<TPrincipal>;
   /** where a sign-in that did not finish sends the browser; no provider text is ever echoed into it */
   failureLocation: string;
   /**
@@ -30,7 +30,17 @@ export interface IRelyingPartyRoutesOptions {
    * The body `GET <prefix>session` answers with. Default:
    * `{ session: { sessionId, principalId, expiresAt, csrfToken } | null }`.
    */
-  sessionAnswer?(resolvedArg: IResolvedRelyingPartySession | null): Promise<object>;
+  sessionAnswer?(resolvedArg: IResolvedRelyingPartySession<TPrincipal> | null): Promise<object>;
+  /**
+   * A `POST <prefix>logout` passed the origin and CSRF checks and the session
+   * was ended. Awaited before the answer, so an audit record is written
+   * before the browser learns the logout is done. `endedLiveSession` is `true`
+   * only when this call ended a live session; a logout that lost a race to
+   * another end answers `false` and records nothing. The session is already
+   * over when this runs: a throw (or a rejection) never keeps it alive and
+   * never changes the answer — it is reported as a `hook_failed` route event.
+   */
+  onLogout?(eventArg: { session: IRelyingPartySession; endedLiveSession: boolean }): Promise<void>;
   /** the largest logout body read, in bytes; a longer one is cancelled as soon as it passes the limit */
   maxBodyBytes?: number;
   /**
@@ -39,7 +49,15 @@ export interface IRelyingPartyRoutesOptions {
    * event and its failure go to `console.error` instead.
    */
   onRouteEvent?(eventArg: {
-    event: 'auth_login_start_failed' | 'auth_callback_failed' | 'auth_callback_declined' | 'auth_callback_refused';
+    event:
+      | 'auth_login_start_failed'
+      | 'auth_callback_failed'
+      | 'auth_callback_declined'
+      | 'auth_callback_refused'
+      /** an application hook of the routes threw; the step it belonged to is complete */
+      | 'hook_failed';
+    hook?: 'onLogout';
+    sessionId?: string;
     stage?: string;
     code?: string;
     correlationId?: string;
@@ -78,18 +96,19 @@ const redirect = (locationArg: string, headersArg?: Record<string, string>): Res
  * - `GET finalize` releases the return path only to the browser holding the
  *   session this attempt created
  * - `GET session` answers the current session
- * - `POST logout` ends the session; it needs this origin and the CSRF token
+ * - `POST logout` ends the session; it needs this origin and the CSRF token,
+ *   and `onLogout` runs before it answers
  *
  * `handle()` answers `null` for every other request, so the application
  * chains its own routes (a local password login) around it. Cookies are only
  * ever set here: a `/typedrequest` answer cannot carry `Set-Cookie`.
  */
-export class RelyingPartyRoutes {
-  readonly #sessions: RelyingPartySessions;
-  readonly #options: IRelyingPartyRoutesOptions;
+export class RelyingPartyRoutes<TPrincipal extends object | undefined = undefined> {
+  readonly #sessions: RelyingPartySessions<TPrincipal>;
+  readonly #options: IRelyingPartyRoutesOptions<TPrincipal>;
   readonly #maxBodyBytes: number;
 
-  constructor(optionsArg: IRelyingPartyRoutesOptions) {
+  constructor(optionsArg: IRelyingPartyRoutesOptions<TPrincipal>) {
     this.#sessions = optionsArg.sessions;
     this.#options = optionsArg;
     this.#maxBodyBytes = optionsArg.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
@@ -200,10 +219,24 @@ export class RelyingPartyRoutes {
     if (!this.#sessions.validateCsrf(resolved, csrfToken)) {
       return jsonResponse({ error: 'forbidden' }, 403);
     }
-    return jsonResponse({ endedLiveSession: await this.#sessions.logout(resolved.session.id) }, 200, clearSession);
+    // the session ends first: whatever the hook does, it cannot keep it alive
+    const endedLiveSession = await this.#sessions.logout(resolved.session.id);
+    if (this.#options.onLogout) {
+      try {
+        await this.#options.onLogout({ session: resolved.session, endedLiveSession });
+      } catch (error) {
+        this.emit({
+          event: 'hook_failed',
+          hook: 'onLogout',
+          sessionId: resolved.session.id,
+          message: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+    return jsonResponse({ endedLiveSession }, 200, clearSession);
   }
 
-  private async sessionAnswer(resolvedArg: IResolvedRelyingPartySession | null): Promise<object> {
+  private async sessionAnswer(resolvedArg: IResolvedRelyingPartySession<TPrincipal> | null): Promise<object> {
     if (this.#options.sessionAnswer) {
       return this.#options.sessionAnswer(resolvedArg);
     }
@@ -261,7 +294,7 @@ export class RelyingPartyRoutes {
     }
   }
 
-  private emit(eventArg: Parameters<NonNullable<IRelyingPartyRoutesOptions['onRouteEvent']>>[0]): void {
+  private emit(eventArg: Parameters<NonNullable<IRelyingPartyRoutesOptions<TPrincipal>['onRouteEvent']>>[0]): void {
     if (!this.#options.onRouteEvent) {
       console.error(JSON.stringify(eventArg));
       return;