@nodefony/security 10.0.0-beta.6 → 10.0.0-beta.7

package/dist/types/nodefony/command/security-mcp-token.d.ts

@@ -19,6 +19,18 @@ export declare function ttlSeconds(raw: string | undefined): number | undefined
  * @returns les secondes, `undefined` pour le défaut de configuration, une `Error` sinon
  */
 export declare function tokenTtlSeconds(raw: string | undefined, write: boolean): number | undefined | Error;
+/**
+ * Le jeton vise-t-il une AUTRE porte que celle de l'outillage ?
+ *
+ * `NF_MCP_TOKEN` et `--write` servent la porte par défaut, et elle seule : un
+ * jeton d'une autre audience (RFC 8707) y prendrait sa place, et cette porte le
+ * refuserait — ses outils réservés disparaîtraient sans un mot.
+ *
+ * @param resource - la valeur de `--resource`, ou rien
+ * @param defaultResource - la porte par défaut de l'application
+ * @returns `true` quand `--resource` désigne une autre porte
+ */
+export declare function targetsOtherGate(resource: string | undefined, defaultResource: string): boolean;
 /**
  * `nodefony security:mcp:token` — émet un jeton d'accès pour une porte de cette
  * application (la porte MCP par défaut).

package/dist/types/nodefony/config/config.d.ts

@@ -340,6 +340,12 @@ export declare const securityConfigSchema: z.ZodObject<{
         immutable: z.ZodDefault<z.ZodBoolean>;
         stream: z.ZodDefault<z.ZodBoolean>;
         retentionDays: z.ZodDefault<z.ZodNumber>;
+        aggregate: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            windowMs: z.ZodDefault<z.ZodNumber>;
+            burst: z.ZodDefault<z.ZodNumber>;
+            maxKeys: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     studio: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;

package/dist/types/nodefony/errors/FetchPublicError.d.ts

@@ -0,0 +1,15 @@
+import { nodefonyError } from "nodefony";
+/** Cause d'un échec de {@link FetchPublicError}. */
+export type FetchPublicFailure = "timeout" | "too-many-redirects" | "network";
+/**
+ * Échec d'une requête sortante vers un site tiers (`fetchPublic`) qui n'est PAS
+ * un refus de cible : délai total dépassé (`504`), trop de redirections ou
+ * échec réseau (`502`). Une cible interdite lève `SsrfError` (422), pas
+ * celle-ci — l'appelant distingue ainsi « tu n'as pas le droit d'y aller » de
+ * « le site n'a pas répondu ».
+ */
+export declare class FetchPublicError extends nodefonyError {
+    /** Cause de l'échec, stable et exploitable sans lire le message. */
+    readonly reason: FetchPublicFailure;
+    constructor(reason: FetchPublicFailure, message: string);
+}

package/dist/types/nodefony/errors/SsrfError.d.ts

@@ -8,6 +8,13 @@ import { nodefonyError } from "nodefony";
  * d'un webhook invalide).
  */
 export declare class SsrfError extends nodefonyError {
-    constructor(message?: string | Error);
+    /**
+     * `forbidden` : la cible est interdite (protocole, identifiants, IP non
+     * publique). `unresolvable` : l'hôte n'a aucune adresse — rien d'interne n'est
+     * visé, le site est simplement injoignable ; un appelant qui rend ces deux cas
+     * à l'utilisateur les distingue par ce champ, jamais par le texte du message.
+     */
+    readonly reason: "forbidden" | "unresolvable";
+    constructor(message?: string | Error, reason?: "forbidden" | "unresolvable");
 }
 export default SsrfError;

package/dist/types/nodefony/errors/StaleSessionError.d.ts

@@ -0,0 +1,17 @@
+import { AuthenticationError } from "./AuthenticationError.js";
+/**
+ * Session PÉRIMÉE — elle ne désigne plus personne de valide : compte supprimé,
+ * verrouillé, désactivé, recréé sous le même identifiant, mot de passe changé
+ * depuis son ouverture, ou blob vidé. C'est un ÉTAT à purger, pas une preuve
+ * fausse présentée par un tiers : le `SessionAuthenticator` la détruit côté
+ * serveur ET côté navigateur (cookie expiré, RFC 6265 §5.3), puis le firewall
+ * poursuit comme si aucune session n'avait été présentée — une page ouverte
+ * aux anonymes s'affiche, une zone fermée redemande la connexion.
+ *
+ * Jamais levée pour une PANNE de la source d'identité : une base injoignable
+ * ne dit rien de la session, qui doit survivre à l'incident.
+ */
+export declare class StaleSessionError extends AuthenticationError {
+    constructor(message?: string | Error);
+}
+export default StaleSessionError;

package/dist/types/nodefony/errors/index.d.ts

@@ -1,9 +1,12 @@
 export { AuthenticationError } from "./AuthenticationError.js";
+export { StaleSessionError } from "./StaleSessionError.js";
 export { AccessDeniedError } from "./AccessDeniedError.js";
 export { ThrottledError } from "./ThrottledError.js";
 export { UnverifiableTokenError } from "./UnverifiableTokenError.js";
 export { InvalidTargetError } from "./InvalidTargetError.js";
 export { CsrfError } from "./CsrfError.js";
 export { SsrfError } from "./SsrfError.js";
+export { FetchPublicError } from "./FetchPublicError.js";
+export type { FetchPublicFailure } from "./FetchPublicError.js";
 export { WebAuthnError } from "./WebAuthnError.js";
 export { InsecureTransportError } from "./InsecureTransportError.js";

package/dist/types/nodefony/keycloak/scaffold.d.ts

@@ -7,13 +7,13 @@ export declare const APP_KEYCLOAK_REALM_FILE = "docker/keycloak/import/realm.jso
 export declare const APP_KEYCLOAK_THEMES_DIR = "docker/keycloak/themes";
 export declare const APP_KEYCLOAK_THEME_DIR = "docker/keycloak/themes/nodefony";
 /**
- * Ressource de l'API partenaire d'une application neuve en développement :
- * ce que rend `partnerResource()` du gabarit `complete` sans `NF_JWT_ISSUER`
- * ni `NF_PORT_HTTPS` — le port HTTPS par défaut, comme les URL de retour du
- * realm. Deux paquets, une valeur : le test de contribution compare le
- * gabarit rendu à cette constante.
+ * Ressource de l'API partenaire de la démo en développement : le chemin de sa
+ * zone (`/demo/api/partner`) rendu absolu contre l'émetteur de développement
+ * — le port HTTPS par défaut, comme les URL de retour du realm. Deux paquets,
+ * une valeur : le test de contribution la confronte à une application
+ * `--demo` réellement rendue.
  */
-export declare const APP_PARTNER_DEV_RESOURCE = "https://localhost:5152/api/partner";
+export declare const APP_PARTNER_DEV_RESOURCE = "https://localhost:5152/demo/api/partner";
 /** Les types de thème que le realm sait déclarer, et la clé qui les porte. */
 declare const THEME_TYPES: readonly ["login", "account", "email", "admin"];
 type TThemeType = (typeof THEME_TYPES)[number];
@@ -68,6 +68,12 @@ export declare function devMachineSecret(appName: string): string;
  * rôle client `admin` (`roleMapping: { admin: "ROLE_ADMIN" }`), et les
  * audiences des zones `external-jwt` que la configuration rendue déclare.
  *
+ * Le client « machine » (`<app>-machine`, `client_credentials`) n'existe que
+ * s'il a une audience à recevoir : une application neuve n'ouvre aucune zone à
+ * jeton tiers (#746), et un client que rien n'accepte serait un secret de plus
+ * à garder pour rien. La démo, qui apporte l'API entre programmes, le fait
+ * naître en déclarant sa ressource.
+ *
  * @param appName - nom de l'application (= realm = identifiant de client)
  * @param themes - types de thème à déclarer
  * @param ids - `sub` des comptes de démonstration, FIXÉS dans le fichier :

package/dist/types/nodefony/service/authFlow.d.ts

@@ -132,8 +132,8 @@ declare class AuthFlow extends Service {
      * (mêmes contrôles que le `SessionAuthenticator` — source unique).
      *
      * @returns la projection publique, ou `null` (pas de session, session
-     *   orpheline, compte verrouillé/désactivé) — le handler répond `200`
-     *   `{ user: null }`.
+     *   orpheline, compte verrouillé/désactivé — la session périmée est alors
+     *   détruite, cookie compris) — le handler répond `200` `{ user: null }`.
      */
     me(context: ContextType): Promise<ISafeUser | null>;
     /**

package/dist/types/nodefony/service/webAuthn.d.ts

@@ -143,3 +143,16 @@ declare class WebAuthnService extends Service {
 }
 export default WebAuthnService;
 export { WebAuthnService };
+/**
+ * Origines WebAuthn rendues en ASCII (punycode), forme sous laquelle le
+ * navigateur les présente — `https://café.example` → `https://xn--caf-dma.example`.
+ *
+ * Une entrée qui n'est pas une origine (`scheme://hôte[:port]`) est écartée et
+ * signalée : la garder ferait échouer CHAQUE cérémonie, sans que personne ne
+ * sache pourquoi.
+ *
+ * @param origins - origines telles qu'écrites dans la config.
+ * @param onInvalid - appelé pour chaque entrée écartée.
+ * @returns les origines valides, sérialisées en ASCII, dans l'ordre reçu.
+ */
+export declare function asciiOrigins(origins: readonly string[], onInvalid: (origin: string) => void): string[];

package/dist/types/nodefony/src/audit/AuditRefusalAggregator.d.ts

@@ -0,0 +1,55 @@
+import type { IAuditEventDraft } from "../../contracts/IAuditEvent.js";
+/** Réglages de l'agrégation des refus (section `security.audit.aggregate`). */
+export interface IAuditAggregateOptions {
+    /** Durée d'une fenêtre, en ms, ouverte au premier refus d'une clé. */
+    windowMs: number;
+    /** Refus d'une clé écrits tels quels par fenêtre ; les suivants sont comptés. */
+    burst: number;
+    /** Clés suivies au plus ; au-delà, les refus se regroupent sans l'IP. */
+    maxKeys: number;
+}
+/**
+ * Agrège les REFUS du journal d'audit par source, pour qu'un flot ne se paie pas
+ * d'une ligne par requête (OWASP Logging Cheat Sheet : la journalisation ne doit
+ * pas épuiser les ressources ni le journal de la base).
+ *
+ * Clé : catégorie, action, motif, ressource et IP — l'IP résolue par le contexte
+ * (`trustProxy`), donc non forgeable par le client. L'acteur n'entre PAS dans la
+ * clé : un bourrage d'identifiants change d'acteur à chaque essai, c'est sa
+ * source qui le trahit.
+ *
+ * Par clé et par fenêtre (ouverte au premier refus) : les `burst` premiers refus
+ * sont écrits tels quels — l'enquêteur voit les premiers essais, acteur compris ;
+ * les suivants sont seulement comptés, et la fenêtre close émet UNE ligne de
+ * synthèse (`metadata.aggregated`). Mémoire bornée : au-delà de `maxKeys` clés,
+ * les refus se regroupent sous l'IP `*`.
+ *
+ * Pur : l'horloge est passée à chaque appel, la synthèse part par `emit`. Les
+ * succès n'y passent jamais (l'appelant les écarte).
+ */
+export declare class AuditRefusalAggregator {
+    #private;
+    /**
+     * @param options - fenêtre, rafale écrite telle quelle, borne de clés.
+     * @param emit - écrit une ligne de synthèse dans le journal.
+     */
+    constructor(options: IAuditAggregateOptions, emit: (draft: IAuditEventDraft) => void);
+    /** Nombre de clés suivies (fenêtres ouvertes). */
+    get size(): number;
+    /**
+     * Compte un refus.
+     *
+     * @param draft - l'événement de refus.
+     * @param now - horloge, en ms.
+     * @returns `true` : l'écrire tel quel ; `false` : il est compté dans la synthèse.
+     */
+    admit(draft: IAuditEventDraft, now: number): boolean;
+    /**
+     * Ferme les fenêtres échues : émet leur synthèse et libère leurs clés.
+     *
+     * @param now - horloge, en ms.
+     */
+    sweep(now: number): void;
+    /** Émet la synthèse de toutes les fenêtres ouvertes (arrêt) et vide la table. */
+    flush(): void;
+}

package/dist/types/nodefony/src/authenticator/JwtAuthenticator.d.ts

@@ -3,7 +3,7 @@ import type { ContextType } from "@nodefony/http";
 import type { IUser } from "@nodefony/user";
 import type { IAuthenticator } from "../../contracts/IAuthenticator.js";
 import type { IToken } from "../../contracts/IToken.js";
-import type { IJwtRuntime } from "../token/jwtRuntime.js";
+import { type IJwtRuntime } from "../token/jwtRuntime.js";
 /**
  * Authentification par **JWT Bearer** (RFC 6750) — réservée API service↔service /
  * agents (le web utilise la session BFF). Vérifie un access token EdDSA signé par
@@ -15,7 +15,8 @@ import type { IJwtRuntime } from "../token/jwtRuntime.js";
  *  - **clé par `kid` depuis le keyset LOCAL** (`createLocalJWKSet`) — jamais
  *    `jku`/`jwk` de l'en-tête (injection de clé / SSRF, §3.5).
  *  - **`aud` (§3.9) + `iss` (§3.8) obligatoires** + `typ:"at+jwt"` (§3.11, sépare
- *    access et refresh) + `exp`/`nbf` (jose).
+ *    access et refresh) + `exp`/`nbf` (jose). L'audience est celle de la ZONE
+ *    (`resource`, ou l'audience par défaut), jamais toute la liste `jwt.audiences`.
  *  - **révocation** : denylist `jti` + seuil `invalidBefore` par porteur (le JWT
  *    est auto-porté et non révocable sans état serveur).
  *  - **sujet revérifié** (§3.10) : `loadUserByIdentifier(sub)` → compte disparu,
@@ -48,12 +49,25 @@ export declare class JwtAuthenticator implements IAuthenticator {
      * qu'un credential qui disparaîtrait sans laisser de trace.
      */
     supports(context: ContextType): boolean;
-    /** Extrait le token brut (non vérifié) → porté par un `UserToken` type `"jwt"`. */
+    /**
+     * Extrait le token brut (non vérifié) → porté par un `UserToken` type `"jwt"`,
+     * avec la ressource de la zone quand elle en déclare une.
+     *
+     * L'audience transite par le token parce que `authenticate()` ne reçoit pas
+     * le contexte (même patron que `ExternalJwtAuthenticator`). Rien n'est posé
+     * pour une zone sans ressource : l'audience par défaut s'y applique.
+     */
     createToken(context: ContextType): Promise<IToken>;
     /**
      * Vérifie la signature + les claims du JWT, applique la révocation et résout le
      * sujet — ou lève un 401 au message uniforme.
      *
+     * L'audience exigée est celle de la ZONE, jamais la liste blanche d'émission
+     * entière (RFC 8707, RFC 9068 §4) : la `resource` de la zone si elle en
+     * déclare une, sinon l'audience par défaut — l'application elle-même. Un
+     * jeton émis pour la porte MCP, ou pour la ressource d'une autre zone, figure
+     * dans `jwt.audiences` sans pour autant ouvrir celle-ci.
+     *
      * @throws AuthenticationError (401) — token absent/invalide/expiré/révoqué, ou
      *   sujet disparu/banni.
      * @throws Error (câblage : keystore/store/users absents) — logguée ERROR par le

package/dist/types/nodefony/src/authenticator/SessionAuthenticator.d.ts

@@ -57,8 +57,10 @@ export declare class SessionAuthenticator implements IAuthenticator {
      * token. Les contrôles d'état (existe, actif, non verrouillé) vivent dans
      * {@link resolveSessionIdentity} — partagés avec `AuthFlow.me()`.
      *
-     * @throws AuthenticationError (401, message uniforme) — session orpheline,
-     *   compte verrouillé ou désactivé.
+     * @throws StaleSessionError (401, message uniforme) — session orpheline,
+     *   compte verrouillé ou désactivé, liaison au compte rompue : un état à
+     *   purger ({@link onFailure}). Une PANNE de la source d'identité remonte
+     *   telle quelle, et ne purge rien.
      */
     authenticate(token: IToken): Promise<IToken>;
     /**
@@ -66,7 +68,12 @@ export declare class SessionAuthenticator implements IAuthenticator {
      * (`saveSession`) lie le blob au principal courant (string attendu).
      */
     onSuccess(context: ContextType, token: IToken): Promise<void>;
-    /** Slot audit (P6.14). Le 401 est posé par le firewall. */
-    onFailure(_context: ContextType, _error: Error): Promise<void>;
+    /**
+     * Une session périmée est DÉTRUITE, côté serveur (entrée du stockage) et
+     * côté navigateur (cookie expiré, RFC 6265 §5.3) — sans quoi le navigateur la
+     * renvoie à chaque requête et chaque page lui répond 401, sans issue pour
+     * l'utilisateur. Le firewall poursuit ensuite la chaîne de la zone.
+     */
+    onFailure(context: ContextType, error: Error): Promise<void>;
 }
 export default SessionAuthenticator;

package/dist/types/nodefony/src/net/fetchPublic.d.ts

@@ -0,0 +1,73 @@
+import { type IncomingHttpHeaders } from "node:http";
+import { type DnsResolver } from "./ssrfGuard.js";
+/**
+ * Requête sortante vers un site TIERS, sûre par construction — la primitive que
+ * tout code de Nodefony (webhooks, aperçu de lien, agents, RAG) appelle quand
+ * l'adresse vient d'un humain.
+ *
+ * Guide pour un agent : n'écris jamais `fetch(urlUtilisateur)`. Appelle
+ * {@link fetchPublic} ; la règle de cible vit dans `assertPublicUrl`
+ * (`ssrfGuard.ts`) et n'est jamais recopiée ici.
+ */
+/** Options de {@link fetchPublic}. */
+export interface IFetchPublicOptions {
+    /** Méthode HTTP. Défaut : `GET` (`POST` si un corps est fourni). */
+    readonly method?: string;
+    /** En-têtes ajoutés. Ni `Cookie` ni `Authorization` ne sont posés d'office. */
+    readonly headers?: Readonly<Record<string, string>>;
+    /** Corps de la requête (texte UTF-8 ou octets). */
+    readonly body?: string | Uint8Array;
+    /** Redirections suivies au plus. Défaut : `0` (un 3xx est rendu tel quel). */
+    readonly maxRedirects?: number;
+    /** Octets du corps de réponse lus au plus. Défaut : 1 Mio. */
+    readonly maxBytes?: number;
+    /** Délai TOTAL (résolution, connexions, redirections, lecture), en ms. Défaut : 10 000. */
+    readonly timeoutMs?: number;
+    /** Autorise `http:` en plus de `https:`. Défaut : `false`. */
+    readonly allowHttp?: boolean;
+    /** Autorise les cibles non publiques (dev/test seulement). Défaut : `false`. */
+    readonly allowPrivate?: boolean;
+    /** Résolveur DNS injectable (tests). Défaut : `node:dns`. */
+    readonly resolver?: DnsResolver;
+    /**
+     * IP DÉJÀ vérifiées par `assertPublicUrl` pour l'adresse de départ : la
+     * connexion y est épinglée sans nouvelle résolution. Pour un appelant qui a
+     * contrôlé l'adresse plus tôt (webhooks) ; les redirections, elles, sont
+     * toujours revérifiées.
+     */
+    readonly vettedAddresses?: readonly string[];
+}
+/** Réponse de {@link fetchPublic}. */
+export interface IFetchPublicResult {
+    /** Code de statut HTTP de la réponse finale. */
+    readonly status: number;
+    /** En-têtes de la réponse finale. */
+    readonly headers: IncomingHttpHeaders;
+    /** Corps reçu, NON décodé (`Content-Encoding` n'est jamais appliqué). */
+    readonly body: Uint8Array;
+    /** `true` si `maxBytes` a coupé la lecture (la connexion a alors été détruite). */
+    readonly truncated: boolean;
+    /** Adresse de la réponse finale (après redirections). */
+    readonly url: URL;
+    /** Nombre de redirections suivies. */
+    readonly redirects: number;
+}
+/**
+ * Lit une URL fournie par un humain sans jamais atteindre le réseau interne.
+ *
+ * À CHAQUE saut (adresse de départ comme redirections) : protocole, absence
+ * d'identifiants et IP sont jugés par `assertPublicUrl`, puis la connexion est
+ * ÉPINGLÉE sur l'IP vérifiée (aucune seconde résolution : un rebinding DNS ne
+ * mène nulle part). Le délai est TOTAL — un serveur qui goutte un octet par
+ * seconde est coupé — et la lecture s'arrête à `maxBytes` en détruisant la
+ * connexion. Aucun cookie, aucun `Authorization` n'est ajouté ni conservé à
+ * travers une redirection, et le corps n'est jamais décodé (pas de bombe de
+ * décompression).
+ *
+ * @param rawUrl - adresse à lire.
+ * @param options - méthode, corps, bornes et politique de cible.
+ * @returns la réponse finale, corps borné et non décodé.
+ * @throws SsrfError si la cible, ou une redirection, est interdite.
+ * @throws FetchPublicError si le délai total, le nombre de redirections ou le réseau échoue.
+ */
+export declare function fetchPublic(rawUrl: string, options?: IFetchPublicOptions): Promise<IFetchPublicResult>;

package/dist/types/nodefony/src/realtime/frameAuthorizer.d.ts

@@ -1,4 +1,4 @@
-import type { FrameAuthorizer, IChannelPolicy, IRealtimeToken } from "./realtimeContracts.js";
+import type { FrameAuthorizer, IChannelPolicies, IChannelPolicy, IRealtimeToken } from "./realtimeContracts.js";
 /**
  * Surface MINIMALE du firewall consommée par le verrou de frame : matcher une
  * zone par pathname ET vérifier un rôle (hiérarchie comprise). `Firewall` la
@@ -21,6 +21,12 @@ export interface IFrameAuthorizerFirewall {
  */
 export interface IChannelPolicyResolver {
     resolveChannelPolicy?(channel: string): IChannelPolicy | null;
+    /**
+     * Lecture ET écriture distincte d'un nom, en une résolution (ADR-0022 §6,
+     * décision 1 quater). Préférée quand elle existe ; un hub d'une version
+     * antérieure ne l'expose pas, et ne porte alors aucune écriture distincte.
+     */
+    resolveChannelPolicies?(channel: string): IChannelPolicies | null;
 }
 /**
  * Règle de canal **système** (plateforme) — un préfixe de namespace réservé et
@@ -42,7 +48,9 @@ export interface ISystemChannelRule {
  * @param surface - cible refusée : pont socket (`api.request`) ou canal
  *   (subscribe/inbound).
  * @param target  - pathname (api.request) ou nom de canal refusé.
- * @param reason  - raison machine stable (`zone_protected` | `channel_policy`).
+ * @param reason  - raison machine stable (`zone_protected` | `channel_policy`
+ *   | `channel_write_policy` — l'écriture distincte du canal a refusé, la
+ *   lecture était satisfaite).
  * @param token   - jeton WS de l'acteur (lu pour `getUserIdentifier()`).
  */
 export type FrameDenyReporter = (surface: "api.request" | "channel", target: string, reason: string, token: IRealtimeToken) => void;

package/dist/types/nodefony/src/realtime/realtimeContracts.d.ts

@@ -1,4 +1,4 @@
-import type { IChannelPolicy, ISubscriberIdentity, TokenStatus } from "nodefony";
+import type { IChannelPolicies, IChannelPolicy, ISubscriberIdentity, TokenStatus } from "nodefony";
 /**
  * Miroirs STRUCTURELS des contrats `@nodefony/realtime` — **zéro import** du
  * module realtime (ni runtime ni type-only).
@@ -89,8 +89,18 @@ export interface IRealtimeAuthenticatorMatcher {
 /**
  * Verrou de frame (miroir de `FrameAuthorizer`) — SYNC : `true` = frame
  * autorisée. Lit le token déjà résolu au handshake (0 lecture base par frame).
+ *
+ * `judgesWrite` : le verrou juge l'écriture distincte d'un canal (ADR-0022 §6,
+ * décision 1 quater) ; un hub refuse de démarrer face à un verrou qui ne le
+ * déclare pas dès qu'une telle écriture est inscrite.
+ *
+ * `explain` : la phrase qui dit pourquoi une trame a été refusée, ou `null` —
+ * lue par le hub après un refus seulement (chemin froid).
  */
-export type FrameAuthorizer = (frame: unknown, token: IRealtimeToken) => boolean;
+export type FrameAuthorizer = ((frame: unknown, token: IRealtimeToken) => boolean) & {
+    readonly judgesWrite?: true;
+    readonly explain?: (frame: unknown, token: IRealtimeToken) => string | null;
+};
 /**
  * Politique d'autorisation d'un canal — déclaration UNIQUE au cœur (`nodefony`), que le
  * hub realtime transporte et que ce module juge. Plus de miroir structurel : la
@@ -102,7 +112,7 @@ export type FrameAuthorizer = (frame: unknown, token: IRealtimeToken) => boolean
  * (`defineSecurityConfig().realtimeChannels` + namespaces système réservés —
  * cf {@link buildFrameAuthorizer}).
  */
-export type { IChannelPolicy };
+export type { IChannelPolicy, IChannelPolicies };
 /**
  * Surface consommée du `realtimeService` (miroir partiel de `RealtimeService`) —
  * seulement les seams que security câble/lit au boot et au dispatch. Résolu par
@@ -131,6 +141,12 @@ export interface IRealtimeService {
      * hub d'une version antérieure ne l'expose pas → traité comme `undefined`.
      */
     resolveChannelPolicy?(channel: string): IChannelPolicy | null;
+    /**
+     * Seam #1b — lecture ET écriture distincte d'un nom, en une résolution
+     * (ADR-0022 §6, décision 1 quater). Optionnel : un hub d'une version
+     * antérieure ne l'expose pas, et ne porte alors aucune écriture distincte.
+     */
+    resolveChannelPolicies?(channel: string): IChannelPolicies | null;
     /**
      * Namespaces de canaux **réservés à la plateforme**, tels que le hub les connaît
      * (`syslog:`, `orm:`, `kernel:`…). Le firewall y accroche ses politiques au lieu

package/dist/types/nodefony/src/token/jwtRuntime.d.ts

@@ -9,7 +9,11 @@ import type { ISecurityConfig } from "../../config/defineModuleConfig.js";
 export interface IJwtRuntime {
     /** Émetteur (`iss`). */
     readonly issuer: string;
-    /** Audiences acceptées au verify ; la première sert d'`aud` à l'émission. */
+    /**
+     * Liste blanche des audiences ÉMETTABLES (RFC 8707) ; la première est
+     * l'audience par défaut. Ce n'est pas ce qu'une zone accepte : une zone `jwt`
+     * n'accepte que SA ressource, ou l'audience par défaut si elle n'en a pas.
+     */
     readonly audiences: string[];
     /** TTL access token (s). */
     readonly accessTtlS: number;
@@ -24,8 +28,23 @@ export interface IJwtRuntime {
  * Dérive les paramètres effectifs depuis la config sécurité. `issuer` omis →
  * `"nodefony"` (DEVRAIT être surchargé en prod) ; `audiences` vide → l'app est sa
  * propre audience (`[issuer]`).
+ *
+ * La ressource d'une ZONE (`areas.<zone>.resource`) entre aussi dans la liste,
+ * APRÈS les audiences déclarées : c'est une ressource que ce serveur protège, et
+ * la redéclarer dans `jwt.audiences` était une seconde écriture de la même
+ * valeur — celle qu'on oublie, et dont le seul symptôme est un `invalid_target`
+ * à l'émission. Ajoutée en fin de liste, elle ne change jamais l'audience par
+ * défaut ({@link defaultAudience}).
+ *
+ * Elle n'ouvre rien de plus à la VÉRIFICATION : chaque zone, `jwt` comme
+ * `external-jwt`, exige SA ressource (l'audience par défaut pour une zone `jwt`
+ * qui n'en déclare pas) — un jeton émis pour une zone n'en ouvre pas une autre.
+ *
+ * @param jwt - section `jwt` de la config validée
+ * @param areas - zones du pare-feu ; omises, seules les audiences déclarées comptent
+ * @returns les paramètres partagés par l'émetteur et les vérificateurs
  */
-export declare function resolveJwtRuntime(jwt: ISecurityConfig["jwt"]): IJwtRuntime;
+export declare function resolveJwtRuntime(jwt: ISecurityConfig["jwt"], areas?: ISecurityConfig["areas"]): IJwtRuntime;
 /**
  * Audience inscrite dans un jeton quand aucune ressource n'est demandée : la
  * première de la liste blanche. La liste n'est jamais vide après

package/dist/types/nodefony/src/webhook/webhookDelivery.d.ts

@@ -22,7 +22,10 @@ export interface IDeliveryOptions {
     readonly allowHttp?: boolean;
 }
 /**
- * POST le corps signé vers l'URL, en pinnant l'IP validée et sans suivre les
- * redirections. Ne lève jamais : tout échec est encodé dans {@link IDeliveryResult}.
+ * POST le corps signé vers l'URL, par {@link fetchPublic} : IP vérifiée épinglée,
+ * aucune redirection suivie, délai TOTAL (un destinataire qui goutte un octet
+ * ne retient pas la livraison) et lecture du corps coupée à
+ * {@link RESPONSE_BODY_CAP} (connexion détruite, pas drainée). Ne lève jamais :
+ * tout échec est encodé dans {@link IDeliveryResult}.
  */
 export declare function deliverWebhook(url: string, body: string, headers: Record<string, string>, opts: IDeliveryOptions): Promise<IDeliveryResult>;