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

package/dist/types/nodefony/src/server/channelPresence.d.ts

@@ -0,0 +1,155 @@
+import type { IChannelPolicy, IPresenceView, IRealtimePresenceCount, IRealtimePresenceList, RealtimePresenceFrame } from "nodefony";
+import type { IPresenceChannelDelta, IPresenceChannelState } from "../backplane/presenceMessage.js";
+import type { ChannelFrame } from "./RealtimeHub.js";
+import type { IPresenceAggregate } from "./remotePresence.js";
+/**
+ * Fenêtre de regroupement des changements de présence vers le navigateur (ms) — front montant : le premier changement d'un canal calme part tout de suite, les suivants attendent la fin de la fenêtre (ADR-0025 P2 bis).
+ */
+export declare const PRESENCE_WINDOW_MS = 250;
+/** Seuil par défaut d'identités nommées au-delà duquel la trame ne porte que les nombres (ADR-0025 P2 bis). */
+export declare const DEFAULT_PRESENCE_MAX_NAMED = 1000;
+/** Réglages RÉSOLUS de la présence d'un canal — défauts appliqués. */
+export interface IPresenceSettings {
+    /** Délai de grâce d'un départ (ms), `0` = départs exacts. */
+    readonly grace: number;
+    /** Identités nommées au-delà desquelles la trame ne porte que les nombres. */
+    readonly maxNamed: number;
+}
+/**
+ * Ce qu'un observateur serveur lit de la présence d'un canal (`hub.presence()`, ADR-0025 P3) — les membres TOUJOURS, quel que soit le seuil de la trame.
+ *
+ * La forme est celle du cœur (`IPresenceView`), que le navigateur lit aussi : serveur et client voient le même objet.
+ */
+export type IChannelPresenceView = IPresenceView;
+/**
+ * Défaut de la valeur de la clé `presence` d'une politique, ou `null` si elle est recevable — en clair, pour que le refus au démarrage dise QUOI corriger.
+ *
+ * @param value - valeur de `policy.presence` (`unknown` : une politique se lit
+ *   depuis une métadonnée publique).
+ */
+export declare function presenceDefect(value: unknown): string | null;
+/**
+ * Réglages résolus de la présence qu'une politique déclare, ou `null` si elle n'en déclare pas.
+ *
+ * Précondition : la politique a passé {@link presenceDefect}.
+ */
+export declare function presenceSettingsOf(policy: IChannelPolicy | null | undefined): IPresenceSettings | null;
+/**
+ * Deux politiques déclarent-elles la même présence ? Défauts appliqués : `true` et `{ grace: 0 }` sont la même.
+ *
+ * Sert à refuser deux déclarations d'un même nom qui ne diffèrent que par la
+ * présence — une seule s'appliquerait. Démarrage seulement.
+ */
+export declare function samePresence(a: IChannelPolicy, b: IChannelPolicy): boolean;
+/**
+ * État de présence LOCAL d'un canal à présence (ADR-0025 P2 bis, P5) — identités nommées et onglets, connexions non nommées, version, changements en attente de la fenêtre, départs en grâce.
+ *
+ * Alloué au premier client d'un canal qui déclare `presence`, jamais pour un
+ * autre canal. Ne connaît ni l'horloge ni le protocole : le hub lui passe
+ * l'instant et fabrique les trames. Les changements portent des valeurs
+ * ABSOLUES (nombre d'onglets, départ), donc rejouer un changement déjà inclus
+ * dans une liste ne change rien — c'est ce qui permet de servir à un nouvel
+ * abonné la liste prise au dernier envoi, encodée une fois.
+ *
+ * Sur un canal DIFFUSÉ entre pods, c'est aussi l'agrégat de la vue des pairs
+ * ({@link IPresenceAggregate}) : les compteurs portent le TOTAL (local + pairs),
+ * et une table à part garde la seule part locale — ce que ce pod annonce à ses
+ * pairs, en deltas par lot. Ailleurs, cette table n'existe pas.
+ */
+export declare class ChannelPresence implements IPresenceAggregate {
+    #private;
+    readonly channel: string;
+    readonly settings: IPresenceSettings;
+    /** Canal diffusé entre pods : sa part locale part sur le bus, la vue des pairs s'y ajoute. */
+    readonly distributed: boolean;
+    /** Fin de la fenêtre de regroupement en cours (horloge monotone, ms). */
+    windowEnd: number;
+    /** Liste complète encodée, servie telle quelle jusqu'au prochain envoi. */
+    listFrame: ChannelFrame | null;
+    /** Le canal est-il encore tenu par le hub ? `false` après son retrait. */
+    live: boolean;
+    /**
+     * Fin de la synchronisation initiale avec les pairs (ms monotone) — la vue
+     * n'est que locale tant que la demande d'état du premier abonné n'a pas eu le
+     * temps d'être servie ; `0` = synchronisée (ou canal non diffusé).
+     */
+    syncUntil: number;
+    /**
+     * @param distributed - le canal est diffusé entre pods (bus branché, préfixe
+     *   diffusé) : la part locale est tenue à part pour le bus.
+     */
+    constructor(channel: string, settings: IPresenceSettings, distributed?: boolean);
+    /** La part locale a-t-elle changé depuis le dernier lot ? */
+    get busDirty(): boolean;
+    /** La vue est-elle connue incomplète (synchronisation initiale, trou chez un pair) ? */
+    get partial(): boolean;
+    /** Version courante de la vue (+1 par trame de changements). */
+    get version(): number;
+    /** Des changements attendent-ils un envoi ? */
+    get dirty(): boolean;
+    /**
+     * Une connexion entre.
+     *
+     * @param key - identité nommée, ou `null` pour une connexion non nommée.
+     */
+    join(key: string | null): void;
+    /**
+     * Une connexion sort.
+     *
+     * Un départ nommé attend la grâce du canal ; un départ non nommé est décompté
+     * tout de suite (rien ne reconnaîtrait son retour).
+     *
+     * @param key - même valeur qu'à {@link ChannelPresence.join}.
+     * @param now - instant monotone (ms), pour la grâce.
+     */
+    leave(key: string | null, now: number): void;
+    /** Publie les départs dont la grâce est écoulée. */
+    expire(now: number): void;
+    /** Prochaine échéance de grâce (ms monotone), `Infinity` sans départ retenu — O(1). */
+    nextDeadline(): number;
+    /**
+     * Trame complète à la version COURANTE — la liste, ou les nombres seuls au-delà du seuil.
+     *
+     * Une liste ne prend jamais de numéro : servie à un nouvel abonné, elle ferait
+     * voir un trou à tous les autres (ADR-0025 P2 bis).
+     */
+    listParams(): IRealtimePresenceList | IRealtimePresenceCount;
+    /**
+     * Consomme les changements en attente et rend la trame à envoyer à tous les membres, ou `null` s'il n'y en a pas.
+     *
+     * Sous le seuil : les changements, version +1. Au-delà : les nombres seuls,
+     * version inchangée (trame complète). Au retour sous le seuil : la liste.
+     * Toute trame envoyée périme la liste encodée.
+     */
+    takeChanges(): RealtimePresenceFrame | null;
+    /** Vue de l'observateur serveur : les membres toujours, une copie. */
+    view(): IChannelPresenceView;
+    /**
+     * Pose l'état « incomplet » de la vue ; un changement fait partir une trame (la version suit) et périme la liste encodée.
+     */
+    setPartial(partial: boolean): void;
+    /** {@inheritDoc IPresenceAggregate.remoteTabs} */
+    remoteTabs(key: string, delta: number): void;
+    /** {@inheritDoc IPresenceAggregate.remoteUnnamed} */
+    remoteUnnamed(delta: number): void;
+    /** {@inheritDoc IPresenceAggregate.remoteLeave} */
+    remoteLeave(key: string, tabs: number, now: number): void;
+    /**
+     * Consomme les changements de la part locale depuis le dernier lot et rend l'entrée du lot, en valeurs absolues — `null` s'ils s'annulent tous.
+     */
+    takeBusDelta(): IPresenceChannelDelta | null;
+    /** État COMPLET de la part locale, pour une réponse d'état (paires à plat). */
+    localState(): IPresenceChannelState;
+    /**
+     * Des départs LOCAUX attendent-ils la fin de leur grâce ? Le dernier client
+     * parti d'un pod n'y échappe pas : la présence reste servie au bus jusqu'à
+     * l'échéance (ADR-0025 P5), puis se libère.
+     */
+    get hasLocalGrace(): boolean;
+    /** La part locale compte-t-elle quelqu'un ? */
+    get hasLocal(): boolean;
+    /**
+     * Le canal n'est plus servi ici : toute la part locale part à zéro au prochain lot, pour que les pairs ne gardent aucun fantôme.
+     */
+    release(): void;
+}

package/dist/types/nodefony/src/server/contractRoutes.d.ts

@@ -5,7 +5,7 @@
 export interface IMountedBridgeRoute {
     /** Chemin complet, préfixe du contrôleur compris (`/chat/send`). */
     readonly path: string;
-    /** Méthodes acceptées, en capitales ; `undefined` = toutes. */
+    /** Méthodes acceptées, en capitales ; `undefined` = aucune déclarée (tous les verbes HTTP, jamais la socket). */
     readonly methods: ReadonlySet<string> | undefined;
     /** Schémas d'entrée de l'action (`schema` de la route), ou `null`. */
     readonly schema: {

package/dist/types/nodefony/src/server/frameAdmission.d.ts

@@ -10,16 +10,6 @@ import type { RealtimeHub } from "./RealtimeHub.js";
  * de la connexion.
  */
 export declare const MAX_RETAINED_FRAME_VERDICTS = 64;
-/**
- * Admet les trames entrantes d'un canal que sa règle `allow` vient d'ouvrir à la connexion.
- *
- * Pas de plafond propre : le nombre de canaux ouverts l'est déjà. Sans effet si le
- * canal n'accepte pas d'entrée client.
- *
- * @param state - état de la connexion.
- * @param channel - canal ouvert par `allow`.
- */
-export declare function admitByRule(state: IRealtimeConnectionState, channel: string): void;
 /**
  * Retire TOUTE admission d'un canal à la connexion — marque de sa règle ET verdict retenu du verrou — quand le serveur l'en éjecte ou le termine (ADR-0022 §6 décision 3).
  *
@@ -31,18 +21,22 @@ export declare function admitByRule(state: IRealtimeConnectionState, channel: st
  */
 export declare function revokeAdmission(state: IRealtimeConnectionState, channel: string): void;
 /**
- * Retire l'admission d'un canal à la fin de son abonnement — celle de sa règle
- * `allow`, que rien ne justifie plus. Un verdict du verrou, lui, ne tient qu'à
- * l'identité et survit au désabonnement.
+ * Retire l'admission d'un canal à la fin de son abonnement quand elle en dépendait — celle d'un canal à `allow`, dont l'abonnement est la condition.
+ *
+ * Un verdict du verrou sur un canal SANS `allow` ne tient qu'à l'identité et
+ * survit au désabonnement ; sur un canal à `allow`, il ne valait que le temps
+ * de l'abonnement (ADR-0022 §6, décisions 1 et 1 quater).
  *
  * @param state - état de la connexion.
  * @param channel - canal quitté.
+ * @param hub - hub qui porte les règles d'admission.
  */
-export declare function releaseRuleAdmission(state: IRealtimeConnectionState, channel: string): void;
+export declare function releaseRuleAdmission(state: IRealtimeConnectionState, channel: string, hub: RealtimeHub): void;
 /**
  * Oublie les verdicts du verrou retenus par la connexion — leur politique vient
- * de changer. Les admissions par `allow` restent : elles valent autant que
- * l'abonnement qui les porte.
+ * de changer. Ceux des canaux à `allow` compris : une écriture inscrite après
+ * coup doit être jugée à la trame suivante, abonnement ou pas. `allow`, lui,
+ * n'est pas redemandé — l'abonnement reste.
  *
  * @param state - état de la connexion.
  */
@@ -55,8 +49,10 @@ export declare function dropRetainedVerdicts(state: IRealtimeConnectionState): v
  * - `ping` et `unsubscribe` passent sans règle ;
  * - `subscribe` passe par le verrou (`allow` est jugé après, à l'ouverture) ;
  * - un nom hérité du prototype de la table entrante est refusé ;
- * - un canal entrant à `allow` que l'abonnement n'a pas admis est refusé ;
- * - un canal entrant à politique fixe passe par le verrou, dont le « oui » est retenu ;
+ * - un canal entrant à `allow` exige l'abonnement de CETTE connexion (`allow`
+ *   n'est jamais rappelé), puis passe par le verrou comme les autres ;
+ * - un canal entrant passe par le verrou — lecture ET écriture —, dont le « oui »
+ *   est retenu ;
  * - toute autre notification passe par le verrou.
  *
  * Le premier test du contrôleur (`admitted[method] === true`) a déjà écarté les trames

package/dist/types/nodefony/src/server/presenceBus.d.ts

@@ -0,0 +1,112 @@
+import type { ChannelPresence } from "./channelPresence.js";
+import { RemotePresence } from "./remotePresence.js";
+/** Fenêtre des lots, demandes et réponses entre pods (ms) — ADR-0025 P2. */
+export declare const PRESENCE_BATCH_MS = 50;
+/** Intervalle local de la preuve de vie (ms), annoncé aux pairs — ADR-0025 P2, « Oubli ». */
+export declare const PRESENCE_INTERVAL_MS = 5000;
+/** Délai d'oubli d'un pair muet, en intervalles ANNONCÉS (≥ 2) — ADR-0025 P2. */
+export declare const PRESENCE_FORGET_FACTOR = 3;
+/**
+ * Ce que la présence répartie demande au hub qui la porte — le bus, et les canaux à présence DIFFUSÉS qu'il sert.
+ */
+export interface IPresenceBusHost {
+    /** `originId` de ce pod (celui de son backplane). */
+    readonly originId: string;
+    /** Publie sur le bus (la file d'envoi tranche : la preuve de vie passe hors quota). */
+    publish(channel: string, payload: object): void;
+    /**
+     * Résout un canal reçu : sa présence s'il est servi et diffusé ici, `null` s'il déclare la présence sans être servi, `false` s'il ne la déclare pas (refus compté).
+     */
+    lookup(channel: string): ChannelPresence | null | false;
+    /** Présence d'un canal servi et diffusé ici, `null` sinon. */
+    served(channel: string): ChannelPresence | null;
+    /** Les présences servies et diffusées ici — itérées aux seules transitions. */
+    servedPresences(): Iterable<ChannelPresence>;
+    /** Nombre de présences servies et diffusées ici. */
+    servedCount(): number;
+    /**
+     * Échos de ses propres messages comptés par le pilote (`IBackplaneInfo.echoTotal`), `undefined` s'il n'en expose pas — l'oubli reste alors normal.
+     */
+    echoTotal(): number | undefined;
+}
+/** Réglages de la présence répartie (défauts de l'ADR). */
+export interface IPresenceBusOptions {
+    /** Intervalle de la preuve de vie (ms). */
+    readonly interval?: number;
+    /** Délai d'oubli, en intervalles annoncés (≥ 2). */
+    readonly factor?: number;
+    /** Tirage dans [0, 1) — incarnation et gigue ; injecté par les tests. */
+    readonly random?: () => number;
+    /** Horloge murale (ms) — incarnation seulement ; injectée par les tests. */
+    readonly wallClock?: () => number;
+}
+/**
+ * Présence répartie d'UN pod (ADR-0025 P2) — ce qu'il émet sur le bus (lots de 50 ms, demandes d'état, réponses, preuve de vie) et ce qu'il en reçoit (vue des pairs, {@link RemotePresence}).
+ *
+ * Sans minuteur ni horloge : le hub la fait avancer à son tic UNIQUE
+ * ({@link PresenceBus.tick}) et arme ce tic sur {@link PresenceBus.due}, O(1).
+ * Elle ne parle qu'à `IBackplane` par son hôte : un pilote neuf (Kafka,
+ * NATS…) n'écrit rien pour la présence.
+ *
+ * Coût : rien n'existe tant qu'aucun canal à présence n'est diffusé ; un
+ * changement local = un ajout dans un `Set` ; un lot = un parcours des seuls
+ * canaux changés.
+ */
+export declare class PresenceBus {
+    #private;
+    /** Vue des pairs. */
+    readonly remote: RemotePresence;
+    /** Vie de ce processus : `Date.now() × 1024 + aléa sur 10 bits` (entier sûr jusqu'en 2248). */
+    readonly incarnation: number;
+    /**
+     * @throws RangeError si le délai d'oubli est sous 2 intervalles (cf `RemotePresence`).
+     */
+    constructor(host: IPresenceBusHost, options?: IPresenceBusOptions);
+    /** Prochain instant (ms monotone) où le bus a quelque chose à faire — O(1). */
+    due(): number;
+    /**
+     * Présences à rafraîchir depuis le dernier appel (agrégat changé, état incomplet changé) — `null` si aucune ; le hub les touche.
+     */
+    takeTouched(): Set<ChannelPresence> | null;
+    /**
+     * Un canal à présence diffusé vient d'être servi (premier abonné local) : la vue reste incomplète le temps que la demande d'état groupée soit servie.
+     */
+    served(presence: ChannelPresence, now: number): void;
+    /** La part locale d'une présence a changé : elle part au prochain lot. */
+    changed(presence: ChannelPresence, now: number): void;
+    /**
+     * Applique un message du canal des lots, demandes et réponses.
+     *
+     * @returns `true` si c'est un type de message inconnu de cette version (le
+     *   hub le compte dans `ingressUnknownDiscardedTotal`) ; `false` sinon — y
+     *   compris refusé, compté ici (`presenceRejectedTotal`).
+     */
+    receive(origin: string, payload: unknown, now: number): boolean;
+    /** Applique une preuve de vie ; une forme fausse est refusée et comptée. */
+    receiveAlive(origin: string, payload: unknown, now: number): void;
+    /** Fait avancer la présence répartie à l'instant `now` (tic unique du hub). */
+    tick(now: number): void;
+    /**
+     * Arrêt propre (ADR-0025 P5) : le dernier lot part, puis une preuve de vie FINALE — les pairs retirent aussitôt les présents de ce pod, sans attendre le délai d'oubli. Plus rien ne part ensuite ; idempotent.
+     *
+     * Rien n'est émis si ce pod ne s'est jamais annoncé (aucune preuve de vie
+     * émise ni vue des pairs) : personne n'a rien à retirer.
+     */
+    end(): void;
+    /** Arrêt propre émis ? */
+    get ended(): boolean;
+    /** Bus perdu, constaté par l'écho : la vue est figée et `partial` (instantané). */
+    get busLost(): boolean;
+    /** Pertes du bus constatées par l'écho. */
+    get busLostTotal(): number;
+    /** Réarmements du délai d'oubli (tic en retard, retour de l'écho). */
+    get rearmTotal(): number;
+    /** Compteurs de la sonde. */
+    get batchTotal(): number;
+    /** Demandes d'état émises (ciblées et non ciblées). */
+    get requestTotal(): number;
+    /** Parts de réponse d'état émises. */
+    get answerTotal(): number;
+    /** Preuves de vie émises. */
+    get aliveTotal(): number;
+}

package/dist/types/nodefony/src/server/realtimeShutdown.d.ts

@@ -0,0 +1,21 @@
+import type { IBackplane } from "../../interfaces/IBackplane.js";
+import type { RealtimeHub } from "./RealtimeHub.js";
+/**
+ * Délai laissé au bus pour faire partir ce qui est déjà émis à l'arrêt (ms) — sous la limite d'arrêt du noyau (15 s) et sous le délai de grâce d'un orchestrateur.
+ */
+export declare const BACKPLANE_STOP_TIMEOUT_MS = 2000;
+/**
+ * Arrêt propre du temps réel d'un processus — la présence répartie annonce sa fin (dernier lot, puis preuve de vie FINALE, ADR-0025 P5), puis le bus POSSÉDÉ s'arrête en laissant partir ce qui est émis, dans une limite de temps.
+ *
+ * Sans l'attente du bus, la sortie du processus au tick suivant perdait la
+ * preuve de vie finale sur un bus réseau (Redis) : les pairs gardaient ce
+ * serveur jusqu'au délai d'oubli. Un bus fourni par l'application (`owned`
+ * `null`) n'est pas arrêté ici : c'est à elle de le faire.
+ *
+ * @param hub - le hub du processus.
+ * @param owned - le bus que l'appelant a créé et doit arrêter, `null` sinon.
+ * @param timeoutMs - limite de l'arrêt du bus.
+ * @returns `false` si le bus n'a pas fini dans la limite (ou a échoué) — ce
+ *   qui restait peut être perdu, les pairs oublieront ce serveur au délai.
+ */
+export declare function shutdownRealtime(hub: RealtimeHub, owned: IBackplane | null, timeoutMs?: number): Promise<boolean>;

package/dist/types/nodefony/src/server/remotePresence.d.ts

@@ -0,0 +1,151 @@
+import { type IPresenceAlive, type IPresenceRequest, type PresenceMessage } from "../backplane/presenceMessage.js";
+/**
+ * Agrégat d'un canal servi par ce pod — ce que la vue distante ajuste quand la présence d'un pair change (ADR-0025 P2).
+ *
+ * Les deux méthodes reçoivent un DELTA : la vue distante range ce que chaque
+ * pod annonce (valeurs absolues) et ne transmet que la différence, si bien que
+ * l'agrégat n'a jamais à reparcourir les pods.
+ */
+export interface IPresenceAggregate {
+    /**
+     * L'identité a `delta` onglets de plus (négatif : de moins) chez les pairs.
+     *
+     * @param key - identité nommée.
+     * @param delta - entier non nul.
+     */
+    remoteTabs(key: string, delta: number): void;
+    /**
+     * Les pairs comptent `delta` connexions non nommées de plus (négatif : de moins).
+     *
+     * @param delta - entier non nul.
+     */
+    remoteUnnamed(delta: number): void;
+    /**
+     * Un pair PART (oublié, arrêt propre, vie remplacée) avec les `tabs` onglets de l'identité qu'il annonçait — retenu par la grâce du canal s'il en déclare une (ADR-0025 P5), annulé si l'identité revient pendant ce délai.
+     *
+     * @param key - identité nommée.
+     * @param tabs - onglets retirés, entier > 0.
+     * @param now - instant monotone local (ms).
+     */
+    remoteLeave(key: string, tabs: number, now: number): void;
+}
+/**
+ * Résout un canal reçu du bus : son agrégat s'il est SERVI ici, `null` s'il déclare la présence sans être servi (lu puis jeté, sans stockage), `false` s'il ne déclare pas la présence sur ce pod (refusé, compté).
+ */
+export type PresenceAggregateLookup = (channel: string) => IPresenceAggregate | null | false;
+/** Réglages de la vue distante. */
+export interface IRemotePresenceOptions {
+    /** Résolution d'un canal reçu (cf {@link PresenceAggregateLookup}). */
+    readonly lookup: PresenceAggregateLookup;
+    /** Délai d'oubli en intervalles ANNONCÉS par le pair (≥ 2, défaut de l'ADR : 3). */
+    readonly factor: number;
+    /**
+     * Intervalle LOCAL (ms) : cadence des demandes répétées pendant un trou, et
+     * intervalle supposé d'un pair dont aucune preuve de vie n'est encore arrivée.
+     */
+    readonly interval: number;
+}
+/**
+ * Vue de la présence des PAIRS, rangée par pod puis par canal (ADR-0025 P2) — la règle répartie, sans horloge, sans minuteur, sans bus.
+ *
+ * Elle applique ce que le bus apporte — lots chaînés par `seq`/`prev`, réponses
+ * d'état en parts appliquées d'un bloc, preuves de vie —, détecte les trous
+ * (règle pure `classifyNumberedChange`, RFC 5263 §4.5), départage les vies d'un
+ * même `originId` par l'incarnation, oublie un pair muet au bout de `factor`
+ * intervalles ANNONCÉS, et ne transmet aux agrégats que des DELTAS. L'instant
+ * (`now`, horloge monotone) est passé à chaque appel : la règle se prouve à
+ * l'horloge simulée, au compte exact.
+ *
+ * Coût : un canal non servi ne stocke rien ; oublier un pod libère ses tables
+ * d'un coup ; un message ne parcourt que ses propres entrées. Aucun parcours de
+ * tous les pods hors de {@link RemotePresence.expire},
+ * {@link RemotePresence.nextDeadline}, {@link RemotePresence.rearm} et
+ * {@link RemotePresence.takeRequests}, appelés au tic.
+ */
+export declare class RemotePresence {
+    #private;
+    /**
+     * @throws RangeError si `factor` < 2 (Phoenix Tracker exige le même plancher :
+     *   sous deux intervalles, une seule preuve de vie retardée fait oublier un pair
+     *   vivant) ou si `interval` n'est pas un entier > 0.
+     */
+    constructor(options: IRemotePresenceOptions);
+    /** Pairs connus (pierres tombales comprises). */
+    get size(): number;
+    /** Pairs dont la vue est en trou — la présence servie est alors `partial`. */
+    get gaps(): number;
+    /** Messages refusés : canal non déclaré à présence ici, plafond dépassé (`presenceRejectedTotal`). */
+    get rejectedTotal(): number;
+    /** Messages déjà vus ou d'une vie plus ancienne (`presenceStaleDiscardedTotal`). */
+    get staleTotal(): number;
+    /** Pairs oubliés faute de signe de vie. */
+    get forgottenTotal(): number;
+    /** Arrêts propres reçus (preuve de vie `final`) — présents retirés sans attendre l'oubli. */
+    get endedTotal(): number;
+    /** Trous ouverts depuis le début (lot perdu, pair inconnu, vie neuve). */
+    get gapTotal(): number;
+    /**
+     * Compte un message de présence REFUSÉ par le lecteur à liste fermée (forme invalide) — même compteur que les refus de la vue.
+     */
+    countRejected(): void;
+    /**
+     * Applique un message du canal des lots, demandes et réponses.
+     *
+     * @param origin - `originId` de l'émetteur, lu dans l'enveloppe.
+     * @param message - message validé par `readPresenceMessage`.
+     * @param now - instant monotone local (ms).
+     * @returns la demande d'état si le message en est une, FRAÎCHE, à servir par
+     *   le répondeur ; `null` sinon.
+     */
+    receive(origin: string, message: PresenceMessage, now: number): IPresenceRequest | null;
+    /**
+     * Applique une preuve de vie.
+     *
+     * @param origin - `originId` de l'émetteur.
+     * @param alive - preuve de vie validée par `readPresenceAlive`.
+     * @param now - instant monotone local (ms).
+     */
+    receiveAlive(origin: string, alive: IPresenceAlive, now: number): void;
+    /**
+     * Pairs à qui demander leur état MAINTENANT — en trou, et pas encore redemandés depuis un intervalle local ; ils sont marqués demandés.
+     *
+     * @param now - instant monotone local (ms).
+     * @param served - canaux à présence servis ici, nommés par la demande ; une
+     *   réponse ne ferme le trou que si elle les couvre tous.
+     * @returns les `originId` à viser (`to`), `null` s'il n'y en a pas.
+     */
+    takeRequests(now: number, served: readonly string[]): string[] | null;
+    /**
+     * Oublie les pairs muets depuis `factor` intervalles ANNONCÉS, et retire les pierres tombales échues.
+     *
+     * @param now - instant monotone local (ms).
+     * @returns le nombre de pairs VIVANTS oubliés (hors pierres tombales).
+     */
+    expire(now: number): number;
+    /**
+     * Plus proche échéance d'oubli APPARUE depuis le dernier appel — celle d'une preuve de vie, dont l'intervalle annoncé peut être plus court que le local ; `Infinity` sinon. O(1), relevée à chaque réception pour que le porteur avance son tic sans attendre le suivant.
+     *
+     * Tout autre message recule l'échéance, et celle d'un pair neuf tombe au
+     * moins deux intervalles LOCAUX plus loin : le tic suivant la relève à temps.
+     * {@link RemotePresence.nextDeadline} reste la valeur exacte, recalculée au tic.
+     */
+    takeCloserDeadline(): number;
+    /** Prochaine échéance d'oubli (ms monotone), `Infinity` sans pair. */
+    nextDeadline(): number;
+    /**
+     * Réarme le délai d'oubli de TOUS les pairs — après un tic en retard (récepteur gelé) ou au retour de l'écho (bus revenu).
+     *
+     * Sans lui, un pod bloqué 20 s oublierait d'un coup tous les pairs vivants
+     * dont les preuves de vie attendent encore dans son tampon : les minuteurs
+     * passent avant la lecture des sockets (Lifeguard).
+     *
+     * @param now - instant monotone local (ms).
+     */
+    rearm(now: number): void;
+    /**
+     * Retire un canal de toutes les vues — il n'est plus servi ici (dernier abonné local parti). L'agrégat n'est pas notifié : il disparaît avec le canal.
+     */
+    dropChannel(channel: string): void;
+    /** Oublie tout, sans notifier les agrégats (arrêt, réinitialisation). */
+    clear(): void;
+}

package/dist/types/nodefony/src/server/subscribedAck.d.ts

@@ -17,6 +17,9 @@
 /**
  * Sérialise la notification `realtime:subscribed { channel }`.
  *
+ * Connexion TEXTE seulement : sous codec binaire, l'accusé passe par
+ * `peer.notify` (`RealtimeController.ts#RealtimeController.acknowledgeSubscription`).
+ *
  * @param channel - le canal acquitté (entrée réseau : échappé par `JSON.stringify`).
  * @returns la trame JSON-RPC 2.0 prête à écrire sur le transport.
  */

package/dist/types/nodefony/src/service/RealtimeService.d.ts

@@ -1,4 +1,4 @@
-import { Service, Module, type IFrameCodec, type JsonRpcPeer } from "nodefony";
+import { Service, Module, type IChannelPolicies, type IFrameCodec, type JsonRpcPeer } from "nodefony";
 import { type RealtimeHub, type ChannelFactory, type ChannelSink, type FrameAuthorizer } from "../server/RealtimeHub.js";
 import type { IBackplane } from "../../interfaces/IBackplane.js";
 import type { IRealtimeProbe } from "../../interfaces/IRealtimeProbe.js";
@@ -163,6 +163,13 @@ declare class RealtimeService extends Service {
      * @returns la politique déclarée, ou `null`.
      */
     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). Lu par `@nodefony/security` sur chaque trame jugée.
+     *
+     * @param channel - nom du canal, de la méthode entrante ou de l'action.
+     * @returns les deux politiques, ou `null` si aucune ne couvre ce nom.
+     */
+    resolveChannelPolicies(channel: string): IChannelPolicies | null;
     /**
      * Renvoie le token associé à un peer (posé au handshake par le hub). Jamais
      * `null` (Zero Trust : `ANONYMOUS_REALTIME_TOKEN` si aucun authenticator n'a

package/dist/types/nodefony/testing/backplaneConformance.d.ts

@@ -28,6 +28,14 @@ export interface IBackplaneConformanceOptions extends IConformanceRunner {
     quietMs?: number;
     /** Délai maximal d'arrivée d'un message attendu, en millisecondes. Défaut 2 000. */
     timeoutMs?: number;
+    /**
+     * Octets publiés d'une traite avant l'ordre du cas « ordre sous saturation ».
+     * Défaut : deux fois le seuil par défaut de la file d'envoi (16 Mio). Un driver
+     * dont la file est bornée plus haut relève cette valeur : si la rafale ne
+     * sature pas la file que `describe().queue` déclare, le cas échoue plutôt que
+     * de passer sans rien prouver.
+     */
+    floodBytes?: number;
 }
 /**
  * Fabrique d'un pair du driver, relié au MÊME bus que les autres pairs de la suite.
@@ -45,7 +53,10 @@ export declare const BACKPLANE_CONFORMANCE_CASES: {
     readonly noReplay: "pas de rejeu : un pair démarré après une publication ne la reçoit pas";
     readonly seal: "sceau : un message non scellé ou mal scellé est refusé";
     readonly control: "ordres de contrôle : le canal de contrôle traverse intact";
+    readonly controlUnderLoad: "ordre sous saturation : un ordre de contrôle n'est jamais jeté pour faire place aux publications";
+    readonly aliveUnderLoad: "preuve de vie sous saturation : la preuve de vie de la présence n'est jamais jetée pour faire place aux publications";
     readonly reserved: "espace réservé : refusé et compté à l'entrée du hub, la diffusion passe sans revenir";
+    readonly presence: "présence entre deux pods : chaque hub voit les présents de l'autre, l'arrêt propre les retire sans attendre l'oubli, sans doublon ni rejeu";
     readonly replaceHandler: "onMessage remplace le handler précédent";
     readonly stop: "stop coupe la réception, et se rappelle sans erreur";
 };
@@ -56,8 +67,9 @@ export declare const BACKPLANE_CONFORMANCE_CASES: {
  * Vérifie, sur plusieurs pairs reliés au même bus : la diffusion à TOUS les pairs
  * sans écho, l'ordre par émetteur, l'absence de rejeu au démarrage, le sceau
  * (message non scellé ou mal scellé refusé), le transport des ordres de contrôle,
- * le refus de l'espace réservé à l'entrée du hub, le remplacement du handler et
- * l'arrêt.
+ * même quand une rafale de publications sature la file d'envoi, le refus de
+ * l'espace réservé à l'entrée du hub, la présence répartie entre deux hubs
+ * (ADR-0025), le remplacement du handler et l'arrêt.
  *
  * @param name - nom du driver, affiché dans le rapport.
  * @param makePeer - fabrique d'un pair relié au bus commun.

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

@@ -31,7 +31,7 @@
  */
 import { type IChannelAdmission, type IRealtimeDenied } from "nodefony";
 import type { ContextType } from "@nodefony/http";
-import type { RealtimeController } from "../src/server/RealtimeController.js";
+import { type RealtimeController } from "../src/server/RealtimeController.js";
 import { type RealtimeHub, type FrameAuthorizer } from "../src/server/RealtimeHub.js";
 import type { IRealtimeToken } from "../interfaces/IRealtimeToken.js";
 /**

package/dist/types/nodefony/testing/presenceClient.d.ts

@@ -0,0 +1,20 @@
+import { PresenceView, type NumberedChangeOutcome, type RealtimePresenceFrame } from "nodefony";
+import type { RealtimeHub } from "../src/server/RealtimeHub.js";
+/** Un client de présence branché sur un hub : ses trames `realtime:presence`, sa vue, et son départ. */
+export interface IPresenceClient {
+    /** Trames reçues, dans l'ordre. */
+    frames: RealtimePresenceFrame[];
+    /** Sort de chaque trame appliquée à {@link view} (même index que {@link frames}). */
+    outcomes: NumberedChangeOutcome[];
+    /**
+     * Vue du canal tenue par la vue PURE du cœur — celle du navigateur (`NodefonySocket`) : ce que le serveur écrit, le navigateur le lit ainsi.
+     */
+    view: PresenceView;
+    leave: () => void;
+}
+/**
+ * Abonne à `channel` une connexion de `hub` — nommée `user`, ou anonyme (`null`) — et relève les trames de présence qu'elle reçoit, lues et appliquées par le lecteur et la vue du cœur, comme le ferait un navigateur. Une trame que le lecteur refuse est un défaut du serveur : le banc lève en la citant.
+ */
+export declare function presenceClient(hub: RealtimeHub, channel: string, user: string | null): IPresenceClient;
+/** Présents nommés d'un canal vus par `hub` (identité → onglets), triés. */
+export declare function presenceView(hub: RealtimeHub, channel: string): Record<string, number>;

package/docs/actions.md

@@ -966,6 +966,7 @@ contrainte passe par `requirements`. Le chat complet, messages privés compris :
 | `-32601 method not found`                                           | nom mal orthographié, ou action déclarée sur un **autre** endpoint                 | vérifier `socket.serverMethods` — c'est la liste réelle de CETTE connexion                   |
 | `-32603 internal error` sans détail                                 | un `throw` ordinaire est rendu opaque au client (Zero Trust)                       | lever une `RpcError` avec un code et un message publiables                                   |
 | `api.request` rejeté avec `data.status: 422`                        | la route invoquée valide son entrée (`schema`, ou une `ZodError` de l'action)      | lire `data.fields` : chaque champ fautif, sa partie (`in`) et son message                    |
+| `api.request` rejeté avec `data.status: 429`                        | la route borne le débit de l'appelant                                              | attendre `data.retryAfter` secondes (l'en-tête `Retry-After` de la même route en HTTP)       |
 | `-32001 unauthorized` sur une action légitime                       | le nom commence par `nodefony:`, le namespace réservé à la plateforme              | renommer hors de `nodefony:`, ou obtenir `ROLE_NODEFONY_ADMIN`                               |
 | Une action est refusée à un anonyme alors qu'on la croyait publique | une action est fermée par défaut (`{ authenticated: true }`)                       | déclarer `{ authenticated: false }` pour l'ouvrir ; un rôle se pose par une règle de préfixe |
 | Un travail relancé crée deux jobs                                   | action non idempotente rejouée après une reconnexion                               | action compagnon d'annulation, ou identifiant fourni par l'appelant + mémorisation           |