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

package/dist/nodefony/src/server/RealtimeHub.js

@@ -1,11 +1,14 @@
 import { RealtimeConnection } from "./RealtimeConnection.js";
+import { ChannelPresence, presenceDefect, presenceSettingsOf } from "./channelPresence.js";
+import { PresenceBus } from "./presenceBus.js";
 import { AdmissionBudget } from "./admissionBudget.js";
 import { dropRetainedVerdicts } from "./frameAdmission.js";
-import { isAdmissionClass } from "../../decorators/realtimeDecorators.js";
+import { DEFAULT_ACTION_POLICY } from "../../decorators/realtimeDecorators.js";
+import { USER_CHANNEL_DECLARATION, declarationOf, policyDeclarationsDefect, resolveDeclaredPolicies } from "./channelPolicyResolution.js";
 import { LoopbackBackplane } from "../backplane/LoopbackBackplane.js";
-import { readControlOrder } from "../backplane/controlOrder.js";
+import { isUnknownControlOrder, readControlOrder } from "../backplane/controlOrder.js";
 import { ANONYMOUS_REALTIME_TOKEN } from "./AnonymousRealtimeToken.js";
-import { BootConfigurationError, IDENTITY_DEAD_CLOSE_CODE, IDENTITY_REFRESH_CLOSE_CODE, MAX_CHANNEL_PATTERN_WILDCARDS, NODEFONY_CHANNEL_NAMESPACE, PLATFORM_BUS_CHANNELS, REVOCATION_REVALIDATE_MS, RevocationWatch, TOKEN_EXPIRED_CLOSE_CODE, USER_CHANNEL_PREFIX, compileChannelPattern, containsBytes, countWildcards, frameCodecSet, isOwnUserChannel, isPlatformChannel, isRealtimePayload, realtimePayloadError, userChannel } from "nodefony";
+import { BootConfigurationError, IDENTITY_DEAD_CLOSE_CODE, IDENTITY_REFRESH_CLOSE_CODE, JsonRpcPeer, MAX_CHANNEL_PATTERN_WILDCARDS, NODEFONY_CHANNEL_NAMESPACE, PLATFORM_BUS_CHANNELS, REALTIME_PRESENCE_METHOD, REVOCATION_REVALIDATE_MS, RevocationWatch, TOKEN_EXPIRED_CLOSE_CODE, USER_CHANNEL_PREFIX, channelPatternWeight, compileChannelPattern, containsBytes, countWildcards, frameCodecSet, isPlatformBusChannel, isPlatformChannel, isRealtimePayload, realtimePayloadError, userChannel } from "nodefony";
 import { frameRateRejectedTotal } from "@nodefony/http";
 // nodefony/src/server/RealtimeHub.ts
 /**
@@ -150,51 +153,29 @@ var ChannelFrame = class {
 	}
 };
 /**
-* Règle d'admission prête à appeler d'une politique, ou `null` sans `allow`.
-*
-* Une flèche se retient telle quelle. Une classe exige son instance — résolue au
-* démarrage, jamais ici : le hub n'a pas d'injecteur, et résoudre à la première
-* poignée de main laisserait sans politique un exemplaire qui n'émet que des
-* webhooks. La méthode est liée une fois, et la règle se construit une fois :
-* le `subscribe` n'alloue rien et n'appelle qu'une fonction.
-*/
-function admissionRuleOf(name, policy, admission) {
-	const allow = policy.allow;
-	if (allow === void 0) return null;
-	const anonymous = policy.anonymous === true;
-	if (!isAdmissionClass(allow)) return {
-		allow,
-		anonymous
-	};
-	if (!(admission instanceof allow)) throw new BootConfigurationError(`canal temps réel « ${name} » : la classe d'admission ${allow.name} n'a pas été résolue au démarrage du noyau. Son contrôleur doit être déclaré par @controllers dans un module : c'est là que le framework l'inscrit et résout ses dépendances.`);
-	return {
-		allow: admission.allow.bind(admission),
-		anonymous
-	};
-}
-/**
-* Politique INTÉGRÉE du canal personnel `user:<id>` (ADR-0022 §6, D1) — connexion authentifiée, admise sur SON canal seulement.
-*
-* Constante de module : elle ne s'inscrit nulle part, donc aucun `clear()`,
-* aucun ordre de démarrage, aucun oubli ne peut la retirer. Elle sert de REPLI :
-* une politique que l'application écrit sur `user:…` (nom exact ou motif)
-* l'emporte, comme toute déclaration explicite.
-*/
-const USER_CHANNEL_POLICY = Object.freeze({
-	policy: Object.freeze({
-		authenticated: true,
-		allow: isOwnUserChannel
-	}),
-	admission: Object.freeze({
-		allow: isOwnUserChannel,
-		anonymous: false
-	})
-});
-/**
 * Fabrique intégrée du canal personnel : il n'a pas de source, seul `publish`
 * l'alimente. Partagée par tous les canaux `user:` — aucune allocation par canal.
 */
 const USER_CHANNEL_DISPOSE = () => {};
+/** Identité sous laquelle une connexion figure dans la présence : nommée ⇔ compte local (ADR-0025 P3). */
+function presenceKeyOf(member) {
+	return member.account ? member.userId : null;
+}
+/** Ensemble vide partagé : la présence répartie sans canal servi n'alloue rien. */
+const EMPTY_PRESENCES = /* @__PURE__ */ new Set();
+/** Un ensemble d'abonnés à un seul membre, sans le tableau temporaire de `new Set([sink])`. */
+function singleSink(sink) {
+	const sinks = /* @__PURE__ */ new Set();
+	sinks.add(sink);
+	return sinks;
+}
+/**
+* Prochain instant où la présence d'un canal a quelque chose à faire : la fin de la fenêtre si des changements attendent, la prochaine fin de grâce — `Infinity` sinon. O(1).
+*/
+function presenceDue(presence) {
+	const deadline = presence.nextDeadline();
+	return presence.dirty && presence.windowEnd < deadline ? presence.windowEnd : deadline;
+}
 /**
 * RealtimeHub — broker temps réel **PAR INSTANCE** (1 pod = 1 process = 1 hub local).
 *
@@ -224,6 +205,30 @@ const USER_CHANNEL_DISPOSE = () => {};
 */
 var RealtimeHub = class RealtimeHub {
 	#channels = null;
+	#presenceActive = null;
+	#presenceTimer = null;
+	#presenceTimerAt = Number.POSITIVE_INFINITY;
+	#presenceBus = null;
+	#presenceServed = null;
+	/**
+	* Présences RÉPARTIES dont le dernier client local est parti pendant une grâce :
+	* encore servies au bus jusqu'à l'échéance, reprises si le canal se rouvre ici
+	* (ADR-0025 P5). `null` tant qu'aucune n'attend — le cas de presque tous les pods.
+	*/
+	#presenceLingering = null;
+	/** Publication remise aux fabriques de canal — UNE fermeture par hub, pas une par canal ouvert. */
+	#publishFn = (ch, payload) => {
+		this.publish(ch, payload);
+	};
+	/** Rappel du tic de présence — UNE fermeture par hub, pas une par armement. */
+	#presenceTickFn = () => {
+		this.#presenceTick();
+	};
+	#presenceDeclared = false;
+	#presenceRejectedTotal = 0;
+	#presenceListTotal = 0;
+	#presenceFrameTotal = 0;
+	#presenceListBuiltTotal = 0;
 	#publishTotal = 0;
 	#fanoutTotal = 0;
 	#closedBytesSent = 0;
@@ -233,6 +238,7 @@ var RealtimeHub = class RealtimeHub {
 	#closedMalformedDiscarded = 0;
 	#inboundTotal = 0;
 	#ingressRejectedTotal = 0;
+	#ingressUnknownDiscardedTotal = 0;
 	#localOnlyTotal = 0;
 	#systemFloorDeniedTotal = 0;
 	#notice = null;
@@ -252,12 +258,14 @@ var RealtimeHub = class RealtimeHub {
 	#channelProbe = null;
 	#retainers = null;
 	#channelPolicies = null;
+	#policyDeclarations = null;
 	/**
 	* Classes de contrôleur dont les politiques sont déjà inscrites — `null`
 	* tant qu'aucune ne l'est. Une poignée de main n'en paie qu'un `has` :
 	* l'inscription elle-même n'a lieu qu'une fois par classe.
 	*/
 	#policyOwners = null;
+	#policyClaims = null;
 	/**
 	* Politiques déclarées par MOTIF de nom (`chat:room:*`), triées du plus
 	* spécifique au plus général, et `null` tant qu'aucune n'est déclarée.
@@ -319,11 +327,116 @@ var RealtimeHub = class RealtimeHub {
 		if (!this.subscribe(channel, sink, factory, buildFrame)) return false;
 		if (member !== void 0) {
 			const st = this.#channels?.get(channel);
-			if (st !== void 0) (st.members ??= /* @__PURE__ */ new Map()).set(sink, member);
+			if (st !== void 0) {
+				if (st.members === null) {
+					st.members = /* @__PURE__ */ new Map();
+					const settings = presenceSettingsOf(this.resolveChannelPolicy(channel));
+					if (settings !== null) this.#openPresence(st, channel, settings);
+				}
+				st.members.set(sink, member);
+				const presence = st.presence;
+				if (presence !== null) {
+					presence.join(presenceKeyOf(member));
+					if (presence.distributed) this.#presenceBusChanged(presence);
+				}
+			}
 		}
 		return true;
 	}
 	/**
+	* Ouvre la présence d'un canal à son premier client : répartie s'il est diffusé et qu'un bus est branché, locale sinon (avis unique : un bus est là, ce canal n'en profite pas).
+	*/
+	#openPresence(st, channel, settings) {
+		const backplane = this.#backplane;
+		const distributed = backplane !== null && st.forward;
+		const lingering = this.#presenceLingering?.get(channel);
+		if (lingering !== void 0 && distributed) {
+			this.#presenceLingering?.delete(channel);
+			if (this.#presenceLingering?.size === 0) this.#presenceLingering = null;
+			lingering.live = true;
+			st.presence = lingering;
+			return;
+		}
+		const presence = new ChannelPresence(channel, settings, distributed);
+		st.presence = presence;
+		if (!distributed) {
+			if (backplane !== null) this.#notifyOnce("presence-local", `realtime: le canal « ${channel} » déclare la présence sans être diffusé entre serveurs (@RealtimeBroadcast) : sa présence ne compte que les connexions de CE serveur.`, "INFO");
+			return;
+		}
+		const bus = this.#presenceBusFor(backplane);
+		(this.#presenceServed ??= /* @__PURE__ */ new Set()).add(presence);
+		const now = performance.now();
+		bus.served(presence, now);
+		this.#armPresenceAt(bus.due(), now);
+	}
+	/** La présence répartie de ce hub, créée au premier besoin. */
+	#presenceBusFor(backplane) {
+		const existing = this.#presenceBus;
+		if (existing !== null) return existing;
+		const bus = new PresenceBus({
+			originId: backplane.originId,
+			publish: (channel, payload) => backplane.publish(channel, payload),
+			lookup: (channel) => this.#presenceLookup(channel),
+			served: (channel) => {
+				const presence = this.#channels?.get(channel)?.presence;
+				return presence != null && presence.distributed && presence.live ? presence : null;
+			},
+			servedPresences: () => this.#presenceServed ?? EMPTY_PRESENCES,
+			servedCount: () => this.#presenceServed?.size ?? 0,
+			echoTotal: () => backplane.describe().echoTotal
+		});
+		this.#presenceBus = bus;
+		return bus;
+	}
+	/**
+	* Résout un canal nommé par un pair : sa présence s'il est servi et diffusé ici ; `null` s'il déclare la présence et se diffuse sans être servi (lu puis jeté) ; `false` sinon (refusé, compté).
+	*/
+	#presenceLookup(channel) {
+		const presence = this.#channels?.get(channel)?.presence;
+		if (presence != null && presence.distributed && presence.live) return presence;
+		if (!this.#isBroadcast(channel) || presenceSettingsOf(this.resolveChannelPolicy(channel)) === null) return false;
+		return null;
+	}
+	/** La part locale d'une présence répartie a changé : prochain lot armé. */
+	#presenceBusChanged(presence) {
+		const bus = this.#presenceBus;
+		if (bus === null) return;
+		const now = performance.now();
+		bus.changed(presence, now);
+		this.#armPresenceAt(bus.due(), now);
+	}
+	/** Rafraîchit les canaux que le bus a touchés (vue des pairs, état incomplet). */
+	#presenceTouchFromBus(bus, now) {
+		const touched = bus.takeTouched();
+		if (touched === null) return;
+		const channels = this.#channels;
+		for (const presence of touched) {
+			const st = channels?.get(presence.channel);
+			if (st === void 0 || st.presence !== presence) continue;
+			if (presence.busDirty) bus.changed(presence, now);
+			this.#presenceTouch(st, presence, now);
+		}
+	}
+	/**
+	* Entrée des deux canaux de présence du bus (ADR-0025 P2) — lots, demandes, réponses, preuve de vie.
+	*/
+	#admitPresence(msg, alive) {
+		let bus = this.#presenceBus;
+		if (bus === null) {
+			const backplane = this.#backplane;
+			if (!this.#presenceDeclared || backplane === null) {
+				this.#presenceRejectedTotal += 1;
+				return;
+			}
+			bus = this.#presenceBusFor(backplane);
+		}
+		const now = performance.now();
+		if (alive) bus.receiveAlive(msg.originId, msg.payload, now);
+		else if (bus.receive(msg.originId, msg.payload, now)) this.#discardUnknownFromBus("presence");
+		this.#presenceTouchFromBus(bus, now);
+		this.#armPresenceAt(bus.due(), now);
+	}
+	/**
 	* Abonne un consommateur qui **répond du canal** : il apporte la `factory`, donc
 	* la réponse à « ce canal existe-t-il, et qui le produit ? ». Le provider partagé
 	* est créé au 1ᵉʳ abonné de ce genre. Le sink est inscrit AVANT l'appel à
@@ -359,8 +472,9 @@ var RealtimeHub = class RealtimeHub {
 		st = {
 			dispose: null,
 			owned: false,
-			sinks: /* @__PURE__ */ new Set([sink]),
+			sinks: singleSink(sink),
 			members: null,
+			presence: null,
 			buildFrame: buildFrame ?? null,
 			messages: 0,
 			forward: this.#isBroadcast(channel)
@@ -399,8 +513,9 @@ var RealtimeHub = class RealtimeHub {
 		channels.set(channel, {
 			dispose: null,
 			owned: false,
-			sinks: /* @__PURE__ */ new Set([sink]),
+			sinks: singleSink(sink),
 			members: null,
+			presence: null,
 			buildFrame: null,
 			messages: 0,
 			forward: this.#isBroadcast(channel)
@@ -418,7 +533,7 @@ var RealtimeHub = class RealtimeHub {
 	* canaux SYSTÈME en dernier recours. `null` = canal inconnu des deux.
 	*/
 	#createProvider(channel, factory) {
-		const publishFn = (ch, payload) => this.publish(ch, payload);
+		const publishFn = this.#publishFn;
 		const dispose = factory(channel, publishFn);
 		if (dispose !== null) return dispose;
 		const sys = this.#systemChannelFactories?.get(channel);
@@ -434,15 +549,190 @@ var RealtimeHub = class RealtimeHub {
 		const st = channels?.get(channel);
 		if (!channels || !st) return;
 		st.sinks.delete(sink);
+		const presence = st.presence;
+		if (presence !== null) {
+			const member = st.members?.get(sink);
+			if (member !== void 0) {
+				const now = performance.now();
+				presence.leave(presenceKeyOf(member), now);
+				this.#presenceTouch(st, presence, now);
+				if (presence.distributed) this.#presenceBusChanged(presence);
+			}
+		}
 		st.members?.delete(sink);
 		if (st.sinks.size === 0) {
 			try {
 				st.dispose?.();
 			} catch {}
 			channels.delete(channel);
+			if (presence !== null) {
+				presence.live = false;
+				if (!presence.distributed) {} else if (presence.hasLocalGrace) this.#lingerPresence(presence);
+				else this.#releasePresence(presence);
+			}
 		}
 	}
 	/**
+	* Le dernier client local d'une présence répartie est parti pendant une grâce : elle reste servie au bus jusqu'à l'échéance (ADR-0025 P5) — le départ n'est publié qu'à ce moment, et un retour sur ce pod l'annule.
+	*/
+	#lingerPresence(presence) {
+		(this.#presenceLingering ??= /* @__PURE__ */ new Map()).set(presence.channel, presence);
+		this.#armPresenceAt(presence.nextDeadline(), performance.now());
+	}
+	/**
+	* Un canal à présence répartie n'est plus servi ici : sa part locale part à zéro au prochain lot (aucun fantôme chez les pairs), sa vue des pairs est jetée.
+	*/
+	#releasePresence(presence) {
+		this.#presenceServed?.delete(presence);
+		const bus = this.#presenceBus;
+		if (bus === null) return;
+		bus.remote.dropChannel(presence.channel);
+		presence.release();
+		this.#presenceBusChanged(presence);
+	}
+	/**
+	* Présence d'un canal vue de CE pod (ADR-0025 P3) — `count`, `unnamed`, `members` (toujours, quel que soit le seuil de la trame), `partial`.
+	*
+	* La voie de l'observateur qui lit sans figurer (modérateur, tableau de
+	* bord). Chemin froid : une copie à chaque appel.
+	*
+	* @param channel - nom exact du canal.
+	* @returns la vue (vide si personne n'est là), ou `null` si la politique du
+	*   canal ne déclare pas `presence`.
+	*/
+	presence(channel) {
+		const live = this.#channels?.get(channel)?.presence;
+		if (live != null) return live.view();
+		if (presenceSettingsOf(this.resolveChannelPolicy(channel)) === null) return null;
+		return {
+			count: 0,
+			unnamed: 0,
+			members: /* @__PURE__ */ new Map(),
+			partial: false
+		};
+	}
+	/**
+	* Arrêt propre de la présence répartie (ADR-0025 P5) — le dernier lot part, puis une preuve de vie FINALE : les pairs retirent aussitôt les présents de ce serveur, sans attendre le délai d'oubli. Plus rien ne part ensuite ; idempotent, sans effet sans bus.
+	*
+	* Appelé par le module à l'arrêt du noyau (`onTerminate`), AVANT que le bus ne
+	* se ferme. Les connexions qui se ferment ensuite ne publient plus rien : la
+	* preuve de vie finale les a déjà retirées chez les pairs.
+	*/
+	endPresence() {
+		const bus = this.#presenceBus;
+		if (bus === null) return;
+		bus.end();
+		if (this.#presenceTimer !== null) clearTimeout(this.#presenceTimer);
+		this.#presenceTimer = null;
+		this.#presenceTimerAt = Number.POSITIVE_INFINITY;
+	}
+	/**
+	* Un abonnement vient d'être acquitté : sur un canal à présence, la liste complète part vers CETTE connexion, puis les changements en attente partent si la fenêtre le permet.
+	*
+	* Appelé par le contrôleur APRÈS `realtime:subscribed`, à chaque (re-)`subscribe`
+	* — aucune borne : la contre-pression peut avoir jeté la liste d'avant sans
+	* le dire, et c'est le re-`subscribe` qui répare (ADR-0025 P2 bis). La liste
+	* est encodée une fois par envoi de changements et par codec, puis servie
+	* telle quelle.
+	*
+	* @param channel - nom exact du canal acquitté.
+	* @param connection - la connexion abonnée.
+	*/
+	presenceSubscribed(channel, connection) {
+		const st = this.#channels?.get(channel);
+		const presence = st?.presence;
+		if (st === void 0 || presence == null) return;
+		if (presence.listFrame === null) {
+			presence.listFrame = new ChannelFrame(JsonRpcPeer.buildNotification(REALTIME_PRESENCE_METHOD, presence.listParams()));
+			this.#presenceListBuiltTotal += 1;
+		}
+		this.#presenceListTotal += 1;
+		connection.deliver(presence.listFrame);
+		this.#presenceTouch(st, presence, performance.now());
+	}
+	/**
+	* Un changement de présence vient d'avoir lieu : part tout de suite sur un canal calme (front montant), sinon au tic qui ferme la fenêtre.
+	*/
+	#presenceTouch(st, presence, now) {
+		if (presence.dirty && now >= presence.windowEnd) this.#presenceFlush(st, presence, now);
+		const due = presenceDue(presence);
+		if (due === 1e400) return;
+		(this.#presenceActive ??= /* @__PURE__ */ new Set()).add(st);
+		this.#armPresenceAt(due, now);
+	}
+	/** Envoie les changements en attente à tous les membres, et ouvre une fenêtre. */
+	#presenceFlush(st, presence, now) {
+		const params = presence.takeChanges();
+		if (params === null) return;
+		presence.windowEnd = now + 250;
+		const members = st.members;
+		if (members === null || members.size === 0) return;
+		const frame = new ChannelFrame(JsonRpcPeer.buildNotification(REALTIME_PRESENCE_METHOD, params));
+		this.#presenceFrameTotal += 1;
+		for (const member of members.values()) try {
+			member.deliver(frame);
+		} catch {}
+	}
+	/**
+	* Avance le minuteur UNIQUE de la présence à `at` s'il est plus proche que l'échéance déjà armée — O(1) par changement, aucun parcours des canaux, aucun minuteur par canal ni par présent.
+	*/
+	#armPresenceAt(next, now) {
+		if (this.#presenceTimer !== null && this.#presenceTimerAt <= next) return;
+		if (this.#presenceTimer !== null) clearTimeout(this.#presenceTimer);
+		this.#presenceTimerAt = next;
+		this.#presenceTimer = setTimeout(this.#presenceTickFn, Math.max(0, Math.ceil(next - now)));
+		this.#presenceTimer.unref();
+	}
+	/** Tic unique : grâces écoulées, fenêtres échues ; se retire quand plus rien n'attend. */
+	#presenceTick() {
+		this.#presenceTimer = null;
+		this.#presenceTimerAt = Number.POSITIVE_INFINITY;
+		const now = performance.now();
+		const bus = this.#presenceBus;
+		if (bus !== null) {
+			bus.tick(now);
+			this.#presenceTouchFromBus(bus, now);
+		}
+		let next = Number.POSITIVE_INFINITY;
+		const active = this.#presenceActive;
+		if (active !== null) {
+			for (const st of active) {
+				const presence = st.presence;
+				if (presence === null || !presence.live) {
+					active.delete(st);
+					continue;
+				}
+				presence.expire(now);
+				if (bus !== null && presence.busDirty) bus.changed(presence, now);
+				if (presence.dirty && now >= presence.windowEnd) this.#presenceFlush(st, presence, now);
+				const due = presenceDue(presence);
+				if (due === 1e400) active.delete(st);
+				else if (due < next) next = due;
+			}
+			if (active.size === 0) this.#presenceActive = null;
+		}
+		const lingering = this.#presenceLingering;
+		if (lingering !== null) {
+			for (const presence of lingering.values()) {
+				presence.expire(now);
+				if (bus !== null && presence.busDirty) bus.changed(presence, now);
+				if (presence.hasLocalGrace) {
+					const due = presence.nextDeadline();
+					if (due < next) next = due;
+				} else {
+					lingering.delete(presence.channel);
+					this.#releasePresence(presence);
+				}
+			}
+			if (lingering.size === 0) this.#presenceLingering = null;
+		}
+		if (bus !== null) {
+			const due = bus.due();
+			if (due < next) next = due;
+		}
+		if (next !== Number.POSITIVE_INFINITY) this.#armPresenceAt(next, now);
+	}
+	/**
 	* Les connexions abonnées à un canal par un client — **local à ce pod** : les membres servis par un autre exemplaire n'y figurent pas.
 	*
 	* Les écouteurs et services du serveur (`listen`, `subscribe`) ne sont pas
@@ -569,7 +859,12 @@ var RealtimeHub = class RealtimeHub {
 	/** Applique un ordre reçu du bus : forme vérifiée, canal de la plateforme refusé, sinon compté en rejet. */
 	#applyControl(payload) {
 		const order = readControlOrder(payload);
-		if (order === null || isReservedSystemChannel(order.channel)) {
+		if (order === null) {
+			if (isUnknownControlOrder(payload)) this.#discardUnknownFromBus("order");
+			else this.#ingressRejectedTotal += 1;
+			return;
+		}
+		if (isReservedSystemChannel(order.channel)) {
 			this.#ingressRejectedTotal += 1;
 			return;
 		}
@@ -722,14 +1017,23 @@ var RealtimeHub = class RealtimeHub {
 		if (prefixes.includes(prefix)) return;
 		prefixes.push(prefix);
 		if (this.#channels) {
-			for (const [channel, st] of this.#channels) if (!st.forward && channel.startsWith(prefix)) st.forward = true;
+			for (const [channel, st] of this.#channels) if (!st.forward && channel.startsWith(prefix) && !isPlatformChannel(channel)) st.forward = true;
 		}
 	}
-	/** Un canal est-il broadcast (préfixe déclaré) ? `false` si aucune politique (défaut local). */
+	/**
+	* Un canal est-il broadcast (préfixe déclaré) ? `false` si aucune politique (défaut local).
+	*
+	* Un canal de PLATEFORME ne l'est jamais, quel que soit le préfixe : un
+	* préfixe large (`""`, `"n"`) le couvrirait, et {@link markBroadcastChannel}
+	* ne refuse que le préfixe réservé lui-même. Sans cette exclusion, ses
+	* publications sortaient sur le bus et l'entrée acceptait de faux évènements
+	* d'admin venus d'un pair (F83). Le test n'est payé qu'après une
+	* correspondance de préfixe.
+	*/
 	#isBroadcast(channel) {
 		const prefixes = this.#broadcastPrefixes;
 		if (prefixes === null) return false;
-		for (const prefix of prefixes) if (channel.startsWith(prefix)) return true;
+		for (const prefix of prefixes) if (channel.startsWith(prefix)) return !isPlatformChannel(channel);
 		return false;
 	}
 	/**
@@ -744,6 +1048,9 @@ var RealtimeHub = class RealtimeHub {
 	*/
 	setBackplane(backplane) {
 		this.#backplane = backplane;
+		this.#presenceBus = null;
+		this.#presenceServed = null;
+		this.#presenceLingering = null;
 		this.markBroadcastChannel(USER_CHANNEL_PREFIX);
 		backplane.onMessage((msg) => this.#admitFromBackplane(msg));
 		this.#armBusBytes();
@@ -775,18 +1082,50 @@ var RealtimeHub = class RealtimeHub {
 	* Seule exception, AVANT ce contrôle : le canal de contrôle
 	* (`PLATFORM_BUS_CHANNELS.control`), jamais diffusé aux abonnés — ses ordres,
 	* en liste fermée, sont appliqués aux connexions de ce pod ou comptés en rejet.
+	* Puis, avant le contrôle aussi : un AUTRE canal du territoire `nodefony:bus:`
+	* vient d'une version plus récente — jeté et compté à part
+	* ({@link #discardUnknownFromBus}), jamais comme une injection.
 	*/
 	#admitFromBackplane(msg) {
+		const st = this.#channels?.get(msg.channel);
+		if (st?.forward === true) {
+			this.#fanout(st, msg.payload);
+			return;
+		}
 		if (msg.channel === PLATFORM_BUS_CHANNELS.control) {
 			this.#applyControl(msg.payload);
 			return;
 		}
+		if (isPlatformBusChannel(msg.channel)) {
+			if (msg.channel === PLATFORM_BUS_CHANNELS.presence) this.#admitPresence(msg, false);
+			else if (msg.channel === PLATFORM_BUS_CHANNELS.presenceAlive) this.#admitPresence(msg, true);
+			else this.#discardUnknownFromBus("channel");
+			return;
+		}
 		if (!this.#isBroadcast(msg.channel)) {
 			this.#ingressRejectedTotal += 1;
 			return;
 		}
 		this.publishLocal(msg.channel, msg.payload);
 	}
+	/**
+	* Jette un message du bus venu d'une version plus RÉCENTE — canal `nodefony:bus:` ou type d'ordre inconnus — et le compte à part.
+	*
+	* Règle de lecture figée par l'ADR-0025 (S-rt-92) : pendant un déploiement
+	* progressif, un serveur ancien reçoit à la cadence du message ce qu'une
+	* version suivante ajoute au bus. Le compter dans `#ingressRejectedTotal`
+	* déclencherait de fausses alertes d'injection et noierait la vraie. Rien
+	* n'atteint un abonné ; le journal ne parle qu'une fois par motif (pas une
+	* ligne par message), sans recopier le nom reçu — une donnée venue du bus
+	* n'entre pas dans le journal.
+	*
+	* @param kind - `channel` (canal inconnu) ou `order` (type d'ordre inconnu).
+	*/
+	#discardUnknownFromBus(kind) {
+		this.#ingressUnknownDiscardedTotal += 1;
+		const what = kind === "channel" ? "un canal de la plateforme inconnu" : kind === "order" ? "un ordre de contrôle d'un type inconnu" : "un message de présence d'un type inconnu";
+		this.#notifyOnce(`backplane:unknown-${kind}`, `realtime: ${what} de cette version est arrivé par le bus — ignoré (un serveur plus récent pendant un déploiement ?), compté dans ingressUnknownDiscardedTotal`, "INFO");
+	}
 	/** Backplane cross-process branché, ou `null` en mono-process (lecture/tests/sonde). */
 	get backplane() {
 		return this.#backplane;
@@ -911,6 +1250,7 @@ var RealtimeHub = class RealtimeHub {
 			fanoutTotal: this.#fanoutTotal,
 			inboundTotal: this.#inboundTotal,
 			ingressRejectedTotal: this.#ingressRejectedTotal,
+			ingressUnknownDiscardedTotal: this.#ingressUnknownDiscardedTotal,
 			localOnlyTotal: this.#localOnlyTotal,
 			systemFloorDeniedTotal: this.#systemFloorDeniedTotal,
 			sealRejectedTotal: backplane.sealRejectedTotal ?? 0,
@@ -929,7 +1269,38 @@ var RealtimeHub = class RealtimeHub {
 				slowConsumers,
 				drops
 			},
-			backplane
+			backplane,
+			presence: this.#presenceProbe()
+		};
+	}
+	/** Compteurs de la présence (chemin froid : un parcours des canaux ouverts). */
+	#presenceProbe() {
+		let channels = 0;
+		if (this.#channels !== null) {
+			for (const st of this.#channels.values()) if (st.presence !== null) channels += 1;
+		}
+		const bus = this.#presenceBus;
+		const remote = bus?.remote;
+		return {
+			channels,
+			listTotal: this.#presenceListTotal,
+			listBuiltTotal: this.#presenceListBuiltTotal,
+			frameTotal: this.#presenceFrameTotal,
+			distributedChannels: this.#presenceServed?.size ?? 0,
+			pods: remote?.size ?? 0,
+			gaps: remote?.gaps ?? 0,
+			gapTotal: remote?.gapTotal ?? 0,
+			forgottenTotal: remote?.forgottenTotal ?? 0,
+			presenceRejectedTotal: this.#presenceRejectedTotal + (remote?.rejectedTotal ?? 0),
+			presenceStaleDiscardedTotal: remote?.staleTotal ?? 0,
+			batchTotal: bus?.batchTotal ?? 0,
+			requestTotal: bus?.requestTotal ?? 0,
+			answerTotal: bus?.answerTotal ?? 0,
+			aliveTotal: bus?.aliveTotal ?? 0,
+			endedTotal: remote?.endedTotal ?? 0,
+			busLost: bus?.busLost ?? false,
+			busLostTotal: bus?.busLostTotal ?? 0,
+			rearmTotal: bus?.rearmTotal ?? 0
 		};
 	}
 	/** Canaux actifs (≥ 1 abonné). Lecture seule. */
@@ -1056,8 +1427,16 @@ var RealtimeHub = class RealtimeHub {
 	* **Seam #1 (P13 → P6)** — pose le verrou de frame (cf {@link FrameAuthorizer}).
 	* `null` retire la politique (bypass total). Posé 1× au boot par
 	* `@nodefony/security` depuis les zones `realtime: true`. Cold path.
+	*
+	* @throws BootConfigurationError Le verrou ne déclare pas `judgesWrite`
+	*   alors qu'une écriture distincte de la lecture est inscrite : il la
+	*   laisserait ouverte.
 	*/
 	setFrameAuthorizer(authorizer, options) {
+		if (authorizer !== null && authorizer.judgesWrite !== true) {
+			const defect = policyDeclarationsDefect(this.#policyDeclarations, this.#channelPolicyPatterns, false);
+			if (defect !== null) throw new BootConfigurationError(defect);
+		}
 		this.#frameAuthorizer = authorizer;
 		this.#dropRetainedVerdicts();
 		this.#channelProbe = options?.silentProbe ?? null;
@@ -1123,10 +1502,7 @@ var RealtimeHub = class RealtimeHub {
 		return this.hasChannelPolicies() && this.#frameAuthorizer === null;
 	}
 	/**
-	* **Seam #1b** — déclare la politique d'autorisation d'un canal/méthode
-	* (`@RealtimeChannel`/`@RealtimeInbound` avec opts). Appelé au handshake par
-	* le controller pour CHAQUE canal décoré (idempotent : même nom = écrase, les
-	* controllers d'un même endpoint déclarent la même policy). Cold path.
+	* **Seam #1b** — pose la politique d'un canal/méthode en REMPLAÇANT ce que ce nom déclarait (voie programmatique ; les décorateurs passent par {@link RealtimeHub.declareChannelPolicy}). Cold path.
 	*
 	* Deux formes de nom, et la seconde garde une FAMILLE :
 	*
@@ -1136,35 +1512,124 @@ var RealtimeHub = class RealtimeHub {
 	*   Le `*` remplace n'importe quelle suite de caractères ; tout le reste du
 	*   motif est littéral (échappé), y compris `.` et `(`.
 	*
-	* Précédence : le nom **exact** l'emporte toujours — c'est ainsi qu'on ouvre
-	* une exception dans une famille gardée. Entre deux motifs, le plus
-	* **spécifique** gagne (littéral le plus long).
+	* Précédence, SORTE PAR SORTE (ADR-0022 §6, décision 1 quater) : la lecture
+	* d'un nom vient de la déclaration la plus spécifique qui POSE une lecture —
+	* le nom **exact**, puis le motif au littéral le plus long ; l'écriture de
+	* même. C'est ainsi qu'on ouvre une exception dans une famille gardée, sans
+	* effacer la sorte que l'exception ne déclare pas.
 	*
-	* @param name   - nom exact du canal (subscribe), de la méthode inbound, ou
+	* @param name - nom exact du canal, de la méthode entrante ou de l'action, ou
 	*   MOTIF de famille s'il contient `*`.
-	* Une politique à `allow` porte sa règle d'admission : une flèche est
-	* retenue telle quelle ; une classe exige son instance, résolue au démarrage
-	* par l'injecteur, dont la méthode est liée ICI, une fois — le `subscribe`
-	* n'appelle qu'une fonction prête.
-	*
-	* @param policy - exigences ({@link IChannelPolicy}) lues par security.
+	* @param policy - exigences de LECTURE ({@link IChannelPolicy}) lues par
+	*   security ; seules exigées au `subscribe`.
 	* @param admission - instance de la classe d'admission quand `policy.allow`
 	*   en est une ; ignorée sinon.
-	* @throws BootConfigurationError La politique désigne une classe d'admission
-	*   et aucune instance de CETTE classe n'est fournie.
+	* @param write - exigences d'ÉCRITURE, exigées EN PLUS de la lecture sur une
+	*   trame entrante ; `null` : ce nom n'en déclare pas.
+	* @throws BootConfigurationError Classe d'admission sans instance ; `allow`
+	*   sur une écriture qui rencontre une lecture différente ; écriture distincte
+	*   face à un verrou qui ne sait pas la juger.
 	*/
-	registerChannelPolicy(name, policy, admission) {
-		const entry = {
-			policy,
-			admission: admissionRuleOf(name, policy, admission)
+	registerChannelPolicy(name, policy, admission, write = null) {
+		this.#declare(name, policy, write, null, admission, false);
+	}
+	/**
+	* Déclare la lecture et/ou l'écriture d'un nom en les AJOUTANT à ce qu'il déclarait — une sorte posée remplace la sienne, une sorte `null` garde celle d'avant. Voie des décorateurs (`channelPolicyRegistry.ts#registerControllerPolicies`). Cold path.
+	*
+	* @param name - nom exact ou motif.
+	* @param read - lecture déclarée, ou `null`.
+	* @param write - écriture déclarée, ou `null`.
+	* @param admission - instance de la classe d'admission désignée par l'une ou
+	*   l'autre ; ignorée sinon.
+	* @throws BootConfigurationError Mêmes refus que {@link RealtimeHub.registerChannelPolicy}.
+	*/
+	declareChannelPolicy(name, read, write, admission) {
+		this.#declare(name, read, write, null, admission, true);
+	}
+	/**
+	* Pose le défaut FERMÉ d'une action (`{ authenticated: true }`) — son ÉCRITURE tant que rien d'exact ne déclare son nom et qu'aucun motif ne pose d'écriture ; une lecture de motif s'y ajoute sans l'ouvrir. Idempotent : une poignée de main n'en paie qu'une lecture.
+	*
+	* @param name - nom de l'action.
+	*/
+	declareActionDefault(name) {
+		if (this.#policyDeclarations?.get(name)?.fallback === DEFAULT_ACTION_POLICY) return;
+		this.#declare(name, null, null, DEFAULT_ACTION_POLICY, void 0, true);
+	}
+	/**
+	* Refuse une présence mal déclarée (ADR-0025 P3) : valeur illisible, posée sur une ÉCRITURE seule (rien ne s'y abonne), ou sur un canal réservé de la plateforme.
+	*
+	* Une seule porte pour les décorateurs et la voie programmatique. Une
+	* politique posée par `@RealtimePolicy` sert la lecture ET l'écriture sous le
+	* même objet : elle est admise, c'est la lecture qui la porte.
+	*
+	* @throws BootConfigurationError En nommant le canal et le défaut.
+	*/
+	static #assertPresence(name, read, write) {
+		const refuse = (why) => {
+			throw new BootConfigurationError(`canal temps réel « ${name} » : présence refusée — ${why}`);
 		};
-		this.#dropRetainedVerdicts();
+		for (const policy of [read, write]) {
+			const defect = presenceDefect(policy?.presence);
+			if (defect !== null) refuse(defect);
+		}
+		if (write !== null && write !== read && presenceSettingsOf(write) !== null) refuse("« presence » est posée sur une politique d'ÉCRITURE (@RealtimeInbound, @RealtimeAction), où rien ne s'abonne. La poser sur @RealtimeChannel.");
+		if (presenceSettingsOf(read) !== null && isReservedSystemChannel(name)) refuse(`un canal réservé de la plateforme (${RESERVED_SYSTEM_PREFIXES.join(" ")}) ne publie pas sa présence.`);
+	}
+	/** Construit la déclaration d'un nom (remplacée ou fusionnée), puis la valide et la publie. */
+	#declare(name, read, write, fallback, admission, merge) {
 		if (isReservedSystemChannel(name)) this.#notifyOnce("reserved-policy", `le canal "${name}" est déclaré dans un namespace RÉSERVÉ à la plateforme (${RESERVED_SYSTEM_PREFIXES.join(" ")}) : le plancher système s'y applique et exigera un rôle d'administration, quelle que soit la politique déclarée ici. Renommer le canal avec un préfixe applicatif si ce n'est pas voulu.`);
-		if (name.includes("*")) {
-			this.#registerChannelPolicyPattern(name, entry);
+		const isPattern = name.includes("*");
+		const previous = isPattern ? this.#channelPolicyPatterns?.find((p) => p.source === name) : this.#policyDeclarations?.get(name);
+		const declaration = declarationOf(name, read ?? (merge ? previous?.read ?? null : null), write ?? (merge ? previous?.write ?? null : null), fallback ?? previous?.fallback ?? null, admission ?? previous?.instance);
+		RealtimeHub.#assertPresence(name, declaration.read, declaration.write);
+		if (presenceSettingsOf(declaration.read) !== null) this.#presenceDeclared = true;
+		if (!isPattern) {
+			const exact = new Map(this.#policyDeclarations ?? []);
+			exact.set(name, declaration);
+			this.#commitPolicies(exact, this.#channelPolicyPatterns);
 			return;
 		}
-		(this.#channelPolicies ??= /* @__PURE__ */ new Map()).set(name, entry);
+		const re = compileChannelPattern(name);
+		if (re === null) {
+			this.#notifyOnce(`pattern-too-broad:${name}`, `le motif de politique "${name}" porte ${countWildcards(name)} caractères « * » (maximum ${RealtimeHub.MAX_PATTERN_WILDCARDS}) : il est IGNORÉ. Un motif de canal en demande un, deux au pire — au-delà, la mise en correspondance coûte cher sur des noms que le client choisit.`);
+			return;
+		}
+		const weight = channelPatternWeight(name);
+		const entry = {
+			...declaration,
+			source: name,
+			re,
+			weight
+		};
+		const patterns = [...this.#channelPolicyPatterns ?? []];
+		const at = patterns.findIndex((p) => p.source === name);
+		if (at >= 0) patterns[at] = entry;
+		else {
+			const rank = patterns.findIndex((p) => p.weight < weight);
+			if (rank < 0) patterns.push(entry);
+			else patterns.splice(rank, 0, entry);
+		}
+		this.#commitPolicies(this.#policyDeclarations, patterns);
+	}
+	/**
+	* Valide l'ensemble des déclarations, recalcule la vue fusionnée de chaque nom exact, puis la publie — rien n'est publié si la validation refuse.
+	*
+	* La vue est recalculée à chaque inscription (cold path) pour qu'une trame
+	* sur un nom exact reste UNE lecture de `Map`, motifs compris.
+	*/
+	#commitPolicies(exact, patterns) {
+		const lock = this.#frameAuthorizer;
+		const defect = policyDeclarationsDefect(exact, patterns, lock === null || lock.judgesWrite === true);
+		if (defect !== null) throw new BootConfigurationError(defect);
+		let merged = null;
+		if (exact !== null) for (const [name, declaration] of exact) {
+			const resolved = resolveDeclaredPolicies(name, declaration, patterns);
+			if (resolved !== null) (merged ??= /* @__PURE__ */ new Map()).set(name, resolved);
+		}
+		this.#policyDeclarations = exact;
+		this.#channelPolicyPatterns = patterns;
+		this.#channelPolicies = merged;
+		this.#dropRetainedVerdicts();
 	}
 	/**
 	* Nombre maximum de `*` dans un motif.
@@ -1178,37 +1643,6 @@ var RealtimeHub = class RealtimeHub {
 	*/
 	static MAX_PATTERN_WILDCARDS = MAX_CHANNEL_PATTERN_WILDCARDS;
 	/**
-	* Compile un motif et l'insère à son rang de spécificité.
-	*
-	* Le motif est ÉCHAPPÉ intégralement avant que `*` ne devienne `.*` : rien de
-	* ce que l'auteur écrit n'est interprété comme une expression régulière. Un
-	* `.` reste un point, un `(` reste une parenthèse — sans quoi une déclaration
-	* anodine deviendrait une expression, avec ce que cela ouvre.
-	*/
-	#registerChannelPolicyPattern(source, entry) {
-		const re = compileChannelPattern(source);
-		if (re === null) {
-			this.#notifyOnce(`pattern-too-broad:${source}`, `le motif de politique "${source}" porte ${countWildcards(source)} caractères « * » (maximum ${RealtimeHub.MAX_PATTERN_WILDCARDS}) : il est IGNORÉ. Un motif de canal en demande un, deux au pire — au-delà, la mise en correspondance coûte cher sur des noms que le client choisit.`);
-			return;
-		}
-		const weight = source.split("*").join("").length;
-		const policies = this.#channelPolicyPatterns ??= [];
-		const existing = policies.findIndex((p) => p.source === source);
-		const policyEntry = {
-			source,
-			re,
-			weight,
-			...entry
-		};
-		if (existing >= 0) {
-			policies[existing] = policyEntry;
-			return;
-		}
-		const rank = policies.findIndex((p) => p.weight < weight);
-		if (rank < 0) policies.push(policyEntry);
-		else policies.splice(rank, 0, policyEntry);
-	}
-	/**
 	* Politique déclarée pour ce canal/méthode, ou `null` si aucune. Lu par
 	* `@nodefony/security` (`resolveChannelPolicy` de la surface DI) au moment de
 	* la frame `subscribe`/inbound. O(1), 0 alloc quand le registre est vide.
@@ -1217,6 +1651,39 @@ var RealtimeHub = class RealtimeHub {
 		return this.#resolvePolicyEntry(name)?.policy ?? null;
 	}
 	/**
+	* Lecture ET écriture qui s'appliquent à ce nom, en UNE résolution — `null` si aucune politique ne le couvre (ADR-0022 §6, décision 1 quater).
+	*
+	* Même résolution que {@link resolveChannelPolicy} : l'entrée la plus
+	* spécifique (nom exact, puis motif) gouverne les deux sortes. Rendue telle
+	* quelle : aucune allocation, une seule recherche par trame jugée.
+	*
+	* @param name - nom du canal, de la méthode entrante ou de l'action.
+	*/
+	resolveChannelPolicies(name) {
+		return this.#resolvePolicyEntry(name);
+	}
+	/**
+	* Retient la PREMIÈRE classe qui déclare une sorte de politique sous ce nom, et rend celle qui l'avait déjà déclarée — pour refuser au démarrage deux classes en désaccord.
+	*
+	* @param name - nom exact ou motif.
+	* @param kind - sorte déclarée : lecture ou écriture.
+	* @param owner - constructeur du contrôleur qui déclare.
+	* @param policy - la politique déclarée.
+	* @returns la déclaration antérieure de cette sorte, ou `null`.
+	*/
+	claimChannelPolicy(name, kind, owner, policy) {
+		const claims = this.#policyClaims ??= /* @__PURE__ */ new Map();
+		const key = `${kind}\u0000${name}`;
+		const previous = claims.get(key);
+		if (previous !== void 0) return previous;
+		claims.set(key, {
+			owner,
+			ownerName: typeof owner === "function" ? owner.name : "(contrôleur)",
+			policy
+		});
+		return null;
+	}
+	/**
 	* Règle d'admission prête à appeler pour ce canal — `null` s'il ne déclare pas `allow`. Lue au `subscribe`, jamais par trame.
 	*
 	* Même résolution que {@link resolveChannelPolicy} (nom exact, puis motif le
@@ -1241,23 +1708,23 @@ var RealtimeHub = class RealtimeHub {
 	addPolicyOwner(owner) {
 		(this.#policyOwners ??= /* @__PURE__ */ new WeakSet()).add(owner);
 	}
-	/** Entrée du registre qui s'applique à ce nom — exact d'abord, puis motif. */
+	/**
+	* Politiques qui s'appliquent à ce nom : la vue fusionnée d'un nom exact (une lecture de `Map`), sinon la résolution par motifs, sorte par sorte.
+	*/
 	#resolvePolicyEntry(name) {
-		const exact = this.#channelPolicies?.get(name);
-		if (exact !== void 0) return exact;
+		const merged = this.#channelPolicies?.get(name);
+		if (merged !== void 0) return merged;
 		const patterns = this.#channelPolicyPatterns;
-		if (patterns !== null) {
-			for (const pattern of patterns) if (pattern.re.test(name)) return pattern;
-		}
-		return name.startsWith(USER_CHANNEL_PREFIX) ? USER_CHANNEL_POLICY : null;
+		if (patterns === null) return name.startsWith(USER_CHANNEL_PREFIX) ? USER_CHANNEL_DECLARATION.self : null;
+		return resolveDeclaredPolicies(name, void 0, patterns);
 	}
 	/**
-	* Une politique est-elle déclarée sous ce nom EXACT — motifs ignorés ? C'est la question du défaut fermé des actions.
+	* Ce nom EXACT porte-t-il une déclaration — motifs ignorés ?
 	*
 	* @param name - nom d'action ou de canal.
 	*/
 	hasExactChannelPolicy(name) {
-		return this.#channelPolicies?.has(name) === true;
+		return this.#policyDeclarations?.has(name) === true;
 	}
 	/** Des politiques de canal sont-elles déclarées (au moins une) ? */
 	hasChannelPolicies() {
@@ -1305,16 +1772,6 @@ var RealtimeHub = class RealtimeHub {
 		(this.#systemChannelFactories ??= /* @__PURE__ */ new Map()).set(channel, factory);
 	}
 	/**
-	* Pont hot-path entre `JsonRpcPeer.beforeDispatch` et le verrou métier : lit
-	* le token déjà caché du peer (O(1), 0 lecture base) puis délègue à
-	* l'authorizer. `true` (autorisée) si aucun verrou posé (bypass 0-coût) —
-	* mais en pratique `beforeDispatch` n'est branché que si `hasFrameAuthorizer()`.
-	*
-	* @param frame - frame JSON-RPC entrante (brute) à autoriser.
-	* @param peer  - peer émetteur (clé du mapping `peer → token`).
-	* @returns `true` si la frame peut être dispatchée, `false` si refusée.
-	*/
-	/**
 	* Ouvre (ou referme) la réception des journaux du navigateur, avec ses bornes.
 	*
 	* @param limits - bornes de débit et de taille, ou `null` pour refermer le canal.
@@ -1326,6 +1783,38 @@ var RealtimeHub = class RealtimeHub {
 	get clientLogsLimits() {
 		return this.#clientLogs;
 	}
+	/**
+	* La raison d'un refus du verrou, quand il sait la dire — `null` sinon, ou si l'explication lève.
+	*
+	* Chemin FROID : appelé après un refus, jamais par trame acceptée. Le
+	* verdict, lui, est déjà rendu : une explication fautive ne change rien à la
+	* décision, elle se tait.
+	*
+	* @param frame - la trame refusée.
+	* @param peer - la connexion qui l'a émise.
+	* @returns la phrase, ou `null`.
+	*/
+	explainDenial(frame, peer) {
+		const explain = this.#frameAuthorizer?.explain;
+		if (explain === void 0) return null;
+		try {
+			const said = explain(frame, this.getTokenForPeer(peer));
+			return typeof said === "string" && said.length > 0 ? said : null;
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Pont hot-path entre `JsonRpcPeer.beforeDispatch` et le verrou métier : lit
+	* le token déjà caché du peer (O(1), 0 lecture base) puis délègue à
+	* l'authorizer. `true` (autorisée) si aucun verrou posé : `beforeDispatch`
+	* est armé sur TOUTE connexion, et c'est ici que le bypass se paie — un
+	* appel et une comparaison de champ.
+	*
+	* @param frame - frame JSON-RPC entrante (brute) à autoriser.
+	* @param peer  - peer émetteur (clé du mapping `peer → token`).
+	* @returns `true` si la frame peut être dispatchée, `false` si refusée.
+	*/
 	runAuthorizer(frame, peer) {
 		const authorizer = this.#frameAuthorizer;
 		if (authorizer === null) return true;
@@ -1394,6 +1883,18 @@ var RealtimeHub = class RealtimeHub {
 	}
 	/** Dispose tous les providers et vide le hub (arrêt process / reset de test). */
 	clear() {
+		if (this.#presenceTimer !== null) clearTimeout(this.#presenceTimer);
+		this.#presenceTimer = null;
+		this.#presenceTimerAt = Number.POSITIVE_INFINITY;
+		this.#presenceActive = null;
+		this.#presenceBus = null;
+		this.#presenceServed = null;
+		this.#presenceLingering = null;
+		this.#presenceDeclared = false;
+		this.#presenceRejectedTotal = 0;
+		this.#presenceListTotal = 0;
+		this.#presenceFrameTotal = 0;
+		this.#presenceListBuiltTotal = 0;
 		if (this.#channels) {
 			for (const st of this.#channels.values()) try {
 				st.dispose?.();
@@ -1413,6 +1914,8 @@ var RealtimeHub = class RealtimeHub {
 		this.#channelPolicies = null;
 		this.#channelPolicyPatterns = null;
 		this.#policyOwners = null;
+		this.#policyClaims = null;
+		this.#policyDeclarations = null;
 		this.#originGuard = null;
 		this.#backplane = null;
 		this.#busBytes = false;
@@ -1425,6 +1928,7 @@ var RealtimeHub = class RealtimeHub {
 		this.#closedMalformedDiscarded = 0;
 		this.#inboundTotal = 0;
 		this.#ingressRejectedTotal = 0;
+		this.#ingressUnknownDiscardedTotal = 0;
 		this.#localOnlyTotal = 0;
 		this.#systemFloorDeniedTotal = 0;
 		this.admissionBudget.reset();